Help us shape the future of Go! Take the 2026 Go Developer Survey

compute

package
v0.193.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 3, 2026 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockClusterPoliciesInterface 

type MockClusterPoliciesInterface struct {
	mock.Mock
}

MockClusterPoliciesInterface is an autogenerated mock type for the ClusterPoliciesInterface type

func NewMockClusterPoliciesInterface 

func NewMockClusterPoliciesInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClusterPoliciesInterface

NewMockClusterPoliciesInterface creates a new instance of MockClusterPoliciesInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockClusterPoliciesInterface) Create 

func (_mock *MockClusterPoliciesInterface) Create(ctx context.Context, request compute.CreatePolicy) (*compute.CreatePolicyResponse, error)

Create provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) Delete 

func (_mock *MockClusterPoliciesInterface) Delete(ctx context.Context, request compute.DeletePolicy) error

Delete provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) DeleteByPolicyId 

func (_mock *MockClusterPoliciesInterface) DeleteByPolicyId(ctx context.Context, policyId string) error

DeleteByPolicyId provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) EXPECT 

func (_m *MockClusterPoliciesInterface) EXPECT() *MockClusterPoliciesInterface_Expecter

func (*MockClusterPoliciesInterface) Edit 

func (_mock *MockClusterPoliciesInterface) Edit(ctx context.Context, request compute.EditPolicy) error

Edit provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) Get 

func (_mock *MockClusterPoliciesInterface) Get(ctx context.Context, request compute.GetClusterPolicyRequest) (*compute.Policy, error)

Get provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) GetByName 

func (_mock *MockClusterPoliciesInterface) GetByName(ctx context.Context, name string) (*compute.Policy, error)

GetByName provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) GetByPolicyId 

func (_mock *MockClusterPoliciesInterface) GetByPolicyId(ctx context.Context, policyId string) (*compute.Policy, error)

GetByPolicyId provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) GetPermissionLevels 

func (_mock *MockClusterPoliciesInterface) GetPermissionLevels(ctx context.Context, request compute.GetClusterPolicyPermissionLevelsRequest) (*compute.GetClusterPolicyPermissionLevelsResponse, error)

GetPermissionLevels provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) GetPermissionLevelsByClusterPolicyId 

func (_mock *MockClusterPoliciesInterface) GetPermissionLevelsByClusterPolicyId(ctx context.Context, clusterPolicyId string) (*compute.GetClusterPolicyPermissionLevelsResponse, error)

GetPermissionLevelsByClusterPolicyId provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) GetPermissions 

func (_mock *MockClusterPoliciesInterface) GetPermissions(ctx context.Context, request compute.GetClusterPolicyPermissionsRequest) (*compute.ClusterPolicyPermissions, error)

GetPermissions provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) GetPermissionsByClusterPolicyId 

func (_mock *MockClusterPoliciesInterface) GetPermissionsByClusterPolicyId(ctx context.Context, clusterPolicyId string) (*compute.ClusterPolicyPermissions, error)

GetPermissionsByClusterPolicyId provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) List 

func (_mock *MockClusterPoliciesInterface) List(ctx context.Context, request compute.ListClusterPoliciesRequest) listing.Iterator[compute.Policy]

List provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) ListAll 

func (_mock *MockClusterPoliciesInterface) ListAll(ctx context.Context, request compute.ListClusterPoliciesRequest) ([]compute.Policy, error)

ListAll provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) PolicyNameToPolicyIdMap 

func (_mock *MockClusterPoliciesInterface) PolicyNameToPolicyIdMap(ctx context.Context, request compute.ListClusterPoliciesRequest) (map[string]string, error)

PolicyNameToPolicyIdMap provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) SetPermissions 

func (_mock *MockClusterPoliciesInterface) SetPermissions(ctx context.Context, request compute.ClusterPolicyPermissionsRequest) (*compute.ClusterPolicyPermissions, error)

SetPermissions provides a mock function for the type MockClusterPoliciesInterface

func (*MockClusterPoliciesInterface) UpdatePermissions 

func (_mock *MockClusterPoliciesInterface) UpdatePermissions(ctx context.Context, request compute.ClusterPolicyPermissionsRequest) (*compute.ClusterPolicyPermissions, error)

UpdatePermissions provides a mock function for the type MockClusterPoliciesInterface

type MockClusterPoliciesInterface_Create_Call 

type MockClusterPoliciesInterface_Create_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockClusterPoliciesInterface_Create_Call) Return 

func (_c *MockClusterPoliciesInterface_Create_Call) Return(createPolicyResponse *compute.CreatePolicyResponse, err error) *MockClusterPoliciesInterface_Create_Call

func (*MockClusterPoliciesInterface_Create_Call) Run 

func (_c *MockClusterPoliciesInterface_Create_Call) Run(run func(ctx context.Context, request compute.CreatePolicy)) *MockClusterPoliciesInterface_Create_Call

func (*MockClusterPoliciesInterface_Create_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_Create_Call) RunAndReturn(run func(ctx context.Context, request compute.CreatePolicy) (*compute.CreatePolicyResponse, error)) *MockClusterPoliciesInterface_Create_Call

type MockClusterPoliciesInterface_DeleteByPolicyId_Call 

type MockClusterPoliciesInterface_DeleteByPolicyId_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_DeleteByPolicyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByPolicyId'

func (*MockClusterPoliciesInterface_DeleteByPolicyId_Call) Return 

func (_c *MockClusterPoliciesInterface_DeleteByPolicyId_Call) Return(err error) *MockClusterPoliciesInterface_DeleteByPolicyId_Call

func (*MockClusterPoliciesInterface_DeleteByPolicyId_Call) Run 

func (_c *MockClusterPoliciesInterface_DeleteByPolicyId_Call) Run(run func(ctx context.Context, policyId string)) *MockClusterPoliciesInterface_DeleteByPolicyId_Call

func (*MockClusterPoliciesInterface_DeleteByPolicyId_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_DeleteByPolicyId_Call) RunAndReturn(run func(ctx context.Context, policyId string) error) *MockClusterPoliciesInterface_DeleteByPolicyId_Call

type MockClusterPoliciesInterface_Delete_Call 

type MockClusterPoliciesInterface_Delete_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockClusterPoliciesInterface_Delete_Call) Return 

func (_c *MockClusterPoliciesInterface_Delete_Call) Return(err error) *MockClusterPoliciesInterface_Delete_Call

func (*MockClusterPoliciesInterface_Delete_Call) Run 

func (_c *MockClusterPoliciesInterface_Delete_Call) Run(run func(ctx context.Context, request compute.DeletePolicy)) *MockClusterPoliciesInterface_Delete_Call

func (*MockClusterPoliciesInterface_Delete_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_Delete_Call) RunAndReturn(run func(ctx context.Context, request compute.DeletePolicy) error) *MockClusterPoliciesInterface_Delete_Call

type MockClusterPoliciesInterface_Edit_Call 

type MockClusterPoliciesInterface_Edit_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_Edit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Edit'

func (*MockClusterPoliciesInterface_Edit_Call) Return 

func (_c *MockClusterPoliciesInterface_Edit_Call) Return(err error) *MockClusterPoliciesInterface_Edit_Call

func (*MockClusterPoliciesInterface_Edit_Call) Run 

func (_c *MockClusterPoliciesInterface_Edit_Call) Run(run func(ctx context.Context, request compute.EditPolicy)) *MockClusterPoliciesInterface_Edit_Call

func (*MockClusterPoliciesInterface_Edit_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_Edit_Call) RunAndReturn(run func(ctx context.Context, request compute.EditPolicy) error) *MockClusterPoliciesInterface_Edit_Call

type MockClusterPoliciesInterface_Expecter 

type MockClusterPoliciesInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockClusterPoliciesInterface_Expecter) Create 

func (_e *MockClusterPoliciesInterface_Expecter) Create(ctx any, request any) *MockClusterPoliciesInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • request compute.CreatePolicy

func (*MockClusterPoliciesInterface_Expecter) Delete 

func (_e *MockClusterPoliciesInterface_Expecter) Delete(ctx any, request any) *MockClusterPoliciesInterface_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • request compute.DeletePolicy

func (*MockClusterPoliciesInterface_Expecter) DeleteByPolicyId 

func (_e *MockClusterPoliciesInterface_Expecter) DeleteByPolicyId(ctx any, policyId any) *MockClusterPoliciesInterface_DeleteByPolicyId_Call

DeleteByPolicyId is a helper method to define mock.On call

  • ctx context.Context
  • policyId string

func (*MockClusterPoliciesInterface_Expecter) Edit 

func (_e *MockClusterPoliciesInterface_Expecter) Edit(ctx any, request any) *MockClusterPoliciesInterface_Edit_Call

Edit is a helper method to define mock.On call

  • ctx context.Context
  • request compute.EditPolicy

func (*MockClusterPoliciesInterface_Expecter) Get 

func (_e *MockClusterPoliciesInterface_Expecter) Get(ctx any, request any) *MockClusterPoliciesInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterPolicyRequest

func (*MockClusterPoliciesInterface_Expecter) GetByName 

func (_e *MockClusterPoliciesInterface_Expecter) GetByName(ctx any, name any) *MockClusterPoliciesInterface_GetByName_Call

GetByName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockClusterPoliciesInterface_Expecter) GetByPolicyId 

func (_e *MockClusterPoliciesInterface_Expecter) GetByPolicyId(ctx any, policyId any) *MockClusterPoliciesInterface_GetByPolicyId_Call

GetByPolicyId is a helper method to define mock.On call

  • ctx context.Context
  • policyId string

func (*MockClusterPoliciesInterface_Expecter) GetPermissionLevels 

func (_e *MockClusterPoliciesInterface_Expecter) GetPermissionLevels(ctx any, request any) *MockClusterPoliciesInterface_GetPermissionLevels_Call

GetPermissionLevels is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterPolicyPermissionLevelsRequest

func (*MockClusterPoliciesInterface_Expecter) GetPermissionLevelsByClusterPolicyId 

func (_e *MockClusterPoliciesInterface_Expecter) GetPermissionLevelsByClusterPolicyId(ctx any, clusterPolicyId any) *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call

GetPermissionLevelsByClusterPolicyId is a helper method to define mock.On call

  • ctx context.Context
  • clusterPolicyId string

func (*MockClusterPoliciesInterface_Expecter) GetPermissions 

func (_e *MockClusterPoliciesInterface_Expecter) GetPermissions(ctx any, request any) *MockClusterPoliciesInterface_GetPermissions_Call

GetPermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterPolicyPermissionsRequest

func (*MockClusterPoliciesInterface_Expecter) GetPermissionsByClusterPolicyId 

func (_e *MockClusterPoliciesInterface_Expecter) GetPermissionsByClusterPolicyId(ctx any, clusterPolicyId any) *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call

GetPermissionsByClusterPolicyId is a helper method to define mock.On call

  • ctx context.Context
  • clusterPolicyId string

func (*MockClusterPoliciesInterface_Expecter) List 

func (_e *MockClusterPoliciesInterface_Expecter) List(ctx any, request any) *MockClusterPoliciesInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClusterPoliciesRequest

func (*MockClusterPoliciesInterface_Expecter) ListAll 

func (_e *MockClusterPoliciesInterface_Expecter) ListAll(ctx any, request any) *MockClusterPoliciesInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClusterPoliciesRequest

func (*MockClusterPoliciesInterface_Expecter) PolicyNameToPolicyIdMap 

func (_e *MockClusterPoliciesInterface_Expecter) PolicyNameToPolicyIdMap(ctx any, request any) *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call

PolicyNameToPolicyIdMap is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClusterPoliciesRequest

func (*MockClusterPoliciesInterface_Expecter) SetPermissions 

func (_e *MockClusterPoliciesInterface_Expecter) SetPermissions(ctx any, request any) *MockClusterPoliciesInterface_SetPermissions_Call

SetPermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ClusterPolicyPermissionsRequest

func (*MockClusterPoliciesInterface_Expecter) UpdatePermissions 

func (_e *MockClusterPoliciesInterface_Expecter) UpdatePermissions(ctx any, request any) *MockClusterPoliciesInterface_UpdatePermissions_Call

UpdatePermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ClusterPolicyPermissionsRequest

type MockClusterPoliciesInterface_GetByName_Call 

type MockClusterPoliciesInterface_GetByName_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_GetByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByName'

func (*MockClusterPoliciesInterface_GetByName_Call) Return 

func (_c *MockClusterPoliciesInterface_GetByName_Call) Return(policy *compute.Policy, err error) *MockClusterPoliciesInterface_GetByName_Call

func (*MockClusterPoliciesInterface_GetByName_Call) Run 

func (_c *MockClusterPoliciesInterface_GetByName_Call) Run(run func(ctx context.Context, name string)) *MockClusterPoliciesInterface_GetByName_Call

func (*MockClusterPoliciesInterface_GetByName_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_GetByName_Call) RunAndReturn(run func(ctx context.Context, name string) (*compute.Policy, error)) *MockClusterPoliciesInterface_GetByName_Call

type MockClusterPoliciesInterface_GetByPolicyId_Call 

type MockClusterPoliciesInterface_GetByPolicyId_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_GetByPolicyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByPolicyId'

func (*MockClusterPoliciesInterface_GetByPolicyId_Call) Return 

func (_c *MockClusterPoliciesInterface_GetByPolicyId_Call) Return(policy *compute.Policy, err error) *MockClusterPoliciesInterface_GetByPolicyId_Call

func (*MockClusterPoliciesInterface_GetByPolicyId_Call) Run 

func (_c *MockClusterPoliciesInterface_GetByPolicyId_Call) Run(run func(ctx context.Context, policyId string)) *MockClusterPoliciesInterface_GetByPolicyId_Call

func (*MockClusterPoliciesInterface_GetByPolicyId_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_GetByPolicyId_Call) RunAndReturn(run func(ctx context.Context, policyId string) (*compute.Policy, error)) *MockClusterPoliciesInterface_GetByPolicyId_Call

type MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call 

type MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevelsByClusterPolicyId'

func (*MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call) Return 

func (_c *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call) Return(getClusterPolicyPermissionLevelsResponse *compute.GetClusterPolicyPermissionLevelsResponse, err error) *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call

func (*MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call) Run 

func (_c *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call) Run(run func(ctx context.Context, clusterPolicyId string)) *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call

func (*MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call) RunAndReturn(run func(ctx context.Context, clusterPolicyId string) (*compute.GetClusterPolicyPermissionLevelsResponse, error)) *MockClusterPoliciesInterface_GetPermissionLevelsByClusterPolicyId_Call

type MockClusterPoliciesInterface_GetPermissionLevels_Call 

type MockClusterPoliciesInterface_GetPermissionLevels_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_GetPermissionLevels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevels'

func (*MockClusterPoliciesInterface_GetPermissionLevels_Call) Return 

func (_c *MockClusterPoliciesInterface_GetPermissionLevels_Call) Return(getClusterPolicyPermissionLevelsResponse *compute.GetClusterPolicyPermissionLevelsResponse, err error) *MockClusterPoliciesInterface_GetPermissionLevels_Call

func (*MockClusterPoliciesInterface_GetPermissionLevels_Call) Run 

func (_c *MockClusterPoliciesInterface_GetPermissionLevels_Call) Run(run func(ctx context.Context, request compute.GetClusterPolicyPermissionLevelsRequest)) *MockClusterPoliciesInterface_GetPermissionLevels_Call

func (*MockClusterPoliciesInterface_GetPermissionLevels_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_GetPermissionLevels_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterPolicyPermissionLevelsRequest) (*compute.GetClusterPolicyPermissionLevelsResponse, error)) *MockClusterPoliciesInterface_GetPermissionLevels_Call

type MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call 

type MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionsByClusterPolicyId'

func (*MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call) Return 

func (_c *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call) Return(clusterPolicyPermissions *compute.ClusterPolicyPermissions, err error) *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call

func (*MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call) Run 

func (_c *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call) Run(run func(ctx context.Context, clusterPolicyId string)) *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call

func (*MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call) RunAndReturn(run func(ctx context.Context, clusterPolicyId string) (*compute.ClusterPolicyPermissions, error)) *MockClusterPoliciesInterface_GetPermissionsByClusterPolicyId_Call

type MockClusterPoliciesInterface_GetPermissions_Call 

type MockClusterPoliciesInterface_GetPermissions_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_GetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissions'

func (*MockClusterPoliciesInterface_GetPermissions_Call) Return 

func (_c *MockClusterPoliciesInterface_GetPermissions_Call) Return(clusterPolicyPermissions *compute.ClusterPolicyPermissions, err error) *MockClusterPoliciesInterface_GetPermissions_Call

func (*MockClusterPoliciesInterface_GetPermissions_Call) Run 

func (_c *MockClusterPoliciesInterface_GetPermissions_Call) Run(run func(ctx context.Context, request compute.GetClusterPolicyPermissionsRequest)) *MockClusterPoliciesInterface_GetPermissions_Call

func (*MockClusterPoliciesInterface_GetPermissions_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_GetPermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterPolicyPermissionsRequest) (*compute.ClusterPolicyPermissions, error)) *MockClusterPoliciesInterface_GetPermissions_Call

type MockClusterPoliciesInterface_Get_Call 

type MockClusterPoliciesInterface_Get_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockClusterPoliciesInterface_Get_Call) Return 

func (_c *MockClusterPoliciesInterface_Get_Call) Return(policy *compute.Policy, err error) *MockClusterPoliciesInterface_Get_Call

func (*MockClusterPoliciesInterface_Get_Call) Run 

func (_c *MockClusterPoliciesInterface_Get_Call) Run(run func(ctx context.Context, request compute.GetClusterPolicyRequest)) *MockClusterPoliciesInterface_Get_Call

func (*MockClusterPoliciesInterface_Get_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_Get_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterPolicyRequest) (*compute.Policy, error)) *MockClusterPoliciesInterface_Get_Call

type MockClusterPoliciesInterface_ListAll_Call 

type MockClusterPoliciesInterface_ListAll_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockClusterPoliciesInterface_ListAll_Call) Return 

func (_c *MockClusterPoliciesInterface_ListAll_Call) Return(policys []compute.Policy, err error) *MockClusterPoliciesInterface_ListAll_Call

func (*MockClusterPoliciesInterface_ListAll_Call) Run 

func (_c *MockClusterPoliciesInterface_ListAll_Call) Run(run func(ctx context.Context, request compute.ListClusterPoliciesRequest)) *MockClusterPoliciesInterface_ListAll_Call

func (*MockClusterPoliciesInterface_ListAll_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClusterPoliciesRequest) ([]compute.Policy, error)) *MockClusterPoliciesInterface_ListAll_Call

type MockClusterPoliciesInterface_List_Call 

type MockClusterPoliciesInterface_List_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockClusterPoliciesInterface_List_Call) Return 

func (_c *MockClusterPoliciesInterface_List_Call) Return(iterator listing.Iterator[compute.Policy]) *MockClusterPoliciesInterface_List_Call

func (*MockClusterPoliciesInterface_List_Call) Run 

func (_c *MockClusterPoliciesInterface_List_Call) Run(run func(ctx context.Context, request compute.ListClusterPoliciesRequest)) *MockClusterPoliciesInterface_List_Call

func (*MockClusterPoliciesInterface_List_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_List_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClusterPoliciesRequest) listing.Iterator[compute.Policy]) *MockClusterPoliciesInterface_List_Call

type MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call 

type MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PolicyNameToPolicyIdMap'

func (*MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call) Return 

func (_c *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call) Return(stringToString map[string]string, err error) *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call

func (*MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call) Run 

func (_c *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call) Run(run func(ctx context.Context, request compute.ListClusterPoliciesRequest)) *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call

func (*MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClusterPoliciesRequest) (map[string]string, error)) *MockClusterPoliciesInterface_PolicyNameToPolicyIdMap_Call

type MockClusterPoliciesInterface_SetPermissions_Call 

type MockClusterPoliciesInterface_SetPermissions_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_SetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPermissions'

func (*MockClusterPoliciesInterface_SetPermissions_Call) Return 

func (_c *MockClusterPoliciesInterface_SetPermissions_Call) Return(clusterPolicyPermissions *compute.ClusterPolicyPermissions, err error) *MockClusterPoliciesInterface_SetPermissions_Call

func (*MockClusterPoliciesInterface_SetPermissions_Call) Run 

func (_c *MockClusterPoliciesInterface_SetPermissions_Call) Run(run func(ctx context.Context, request compute.ClusterPolicyPermissionsRequest)) *MockClusterPoliciesInterface_SetPermissions_Call

func (*MockClusterPoliciesInterface_SetPermissions_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_SetPermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.ClusterPolicyPermissionsRequest) (*compute.ClusterPolicyPermissions, error)) *MockClusterPoliciesInterface_SetPermissions_Call

type MockClusterPoliciesInterface_UpdatePermissions_Call 

type MockClusterPoliciesInterface_UpdatePermissions_Call struct {
	*mock.Call
}

MockClusterPoliciesInterface_UpdatePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePermissions'

func (*MockClusterPoliciesInterface_UpdatePermissions_Call) Return 

func (_c *MockClusterPoliciesInterface_UpdatePermissions_Call) Return(clusterPolicyPermissions *compute.ClusterPolicyPermissions, err error) *MockClusterPoliciesInterface_UpdatePermissions_Call

func (*MockClusterPoliciesInterface_UpdatePermissions_Call) Run 

func (_c *MockClusterPoliciesInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request compute.ClusterPolicyPermissionsRequest)) *MockClusterPoliciesInterface_UpdatePermissions_Call

func (*MockClusterPoliciesInterface_UpdatePermissions_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_UpdatePermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.ClusterPolicyPermissionsRequest) (*compute.ClusterPolicyPermissions, error)) *MockClusterPoliciesInterface_UpdatePermissions_Call

type MockClustersInterface 

type MockClustersInterface struct {
	mock.Mock
}

MockClustersInterface is an autogenerated mock type for the ClustersInterface type

func NewMockClustersInterface 

func NewMockClustersInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClustersInterface

NewMockClustersInterface creates a new instance of MockClustersInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockClustersInterface) ChangeOwner 

func (_mock *MockClustersInterface) ChangeOwner(ctx context.Context, request compute.ChangeClusterOwner) error

ChangeOwner provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) ClusterDetailsClusterNameToClusterIdMap 

func (_mock *MockClustersInterface) ClusterDetailsClusterNameToClusterIdMap(ctx context.Context, request compute.ListClustersRequest) (map[string]string, error)

ClusterDetailsClusterNameToClusterIdMap provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Create 

func (_mock *MockClustersInterface) Create(ctx context.Context, createCluster compute.CreateCluster) (*compute.WaitGetClusterRunning[compute.CreateClusterResponse], error)

Create provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) CreateAndWait 

func (_mock *MockClustersInterface) CreateAndWait(ctx context.Context, createCluster compute.CreateCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

CreateAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Delete 

func (_mock *MockClustersInterface) Delete(ctx context.Context, deleteCluster compute.DeleteCluster) (*compute.WaitGetClusterTerminated[struct{}], error)

Delete provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) DeleteAndWait 

func (_mock *MockClustersInterface) DeleteAndWait(ctx context.Context, deleteCluster compute.DeleteCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

DeleteAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) DeleteByClusterId 

func (_mock *MockClustersInterface) DeleteByClusterId(ctx context.Context, clusterId string) error

DeleteByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) DeleteByClusterIdAndWait 

func (_mock *MockClustersInterface) DeleteByClusterIdAndWait(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

DeleteByClusterIdAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) EXPECT 

func (_m *MockClustersInterface) EXPECT() *MockClustersInterface_Expecter

func (*MockClustersInterface) Edit 

func (_mock *MockClustersInterface) Edit(ctx context.Context, editCluster compute.EditCluster) (*compute.WaitGetClusterRunning[struct{}], error)

Edit provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) EditAndWait 

func (_mock *MockClustersInterface) EditAndWait(ctx context.Context, editCluster compute.EditCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

EditAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) EnsureClusterIsRunning 

func (_mock *MockClustersInterface) EnsureClusterIsRunning(ctx context.Context, clusterId string) error

EnsureClusterIsRunning provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Events 

func (_mock *MockClustersInterface) Events(ctx context.Context, request compute.GetEvents) listing.Iterator[compute.ClusterEvent]

Events provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) EventsAll 

func (_mock *MockClustersInterface) EventsAll(ctx context.Context, request compute.GetEvents) ([]compute.ClusterEvent, error)

EventsAll provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Get 

func (_mock *MockClustersInterface) Get(ctx context.Context, request compute.GetClusterRequest) (*compute.ClusterDetails, error)

Get provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetByClusterId 

func (_mock *MockClustersInterface) GetByClusterId(ctx context.Context, clusterId string) (*compute.ClusterDetails, error)

GetByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetByClusterName 

func (_mock *MockClustersInterface) GetByClusterName(ctx context.Context, name string) (*compute.ClusterDetails, error)

GetByClusterName provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetOrCreateRunningCluster 

func (_mock *MockClustersInterface) GetOrCreateRunningCluster(ctx context.Context, name string, custom ...compute.CreateCluster) (*compute.ClusterDetails, error)

GetOrCreateRunningCluster provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetPermissionLevels 

func (_mock *MockClustersInterface) GetPermissionLevels(ctx context.Context, request compute.GetClusterPermissionLevelsRequest) (*compute.GetClusterPermissionLevelsResponse, error)

GetPermissionLevels provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetPermissionLevelsByClusterId 

func (_mock *MockClustersInterface) GetPermissionLevelsByClusterId(ctx context.Context, clusterId string) (*compute.GetClusterPermissionLevelsResponse, error)

GetPermissionLevelsByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetPermissions 

func (_mock *MockClustersInterface) GetPermissions(ctx context.Context, request compute.GetClusterPermissionsRequest) (*compute.ClusterPermissions, error)

GetPermissions provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) GetPermissionsByClusterId 

func (_mock *MockClustersInterface) GetPermissionsByClusterId(ctx context.Context, clusterId string) (*compute.ClusterPermissions, error)

GetPermissionsByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) List 

func (_mock *MockClustersInterface) List(ctx context.Context, request compute.ListClustersRequest) listing.Iterator[compute.ClusterDetails]

List provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) ListAll 

func (_mock *MockClustersInterface) ListAll(ctx context.Context, request compute.ListClustersRequest) ([]compute.ClusterDetails, error)

ListAll provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) ListNodeTypes 

func (_mock *MockClustersInterface) ListNodeTypes(ctx context.Context) (*compute.ListNodeTypesResponse, error)

ListNodeTypes provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) ListZones 

func (_mock *MockClustersInterface) ListZones(ctx context.Context) (*compute.ListAvailableZonesResponse, error)

ListZones provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) PermanentDelete 

func (_mock *MockClustersInterface) PermanentDelete(ctx context.Context, request compute.PermanentDeleteCluster) error

PermanentDelete provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) PermanentDeleteByClusterId 

func (_mock *MockClustersInterface) PermanentDeleteByClusterId(ctx context.Context, clusterId string) error

PermanentDeleteByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Pin 

func (_mock *MockClustersInterface) Pin(ctx context.Context, request compute.PinCluster) error

Pin provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) PinByClusterId 

func (_mock *MockClustersInterface) PinByClusterId(ctx context.Context, clusterId string) error

PinByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Resize 

func (_mock *MockClustersInterface) Resize(ctx context.Context, resizeCluster compute.ResizeCluster) (*compute.WaitGetClusterRunning[struct{}], error)

Resize provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) ResizeAndWait 

func (_mock *MockClustersInterface) ResizeAndWait(ctx context.Context, resizeCluster compute.ResizeCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

ResizeAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Restart 

func (_mock *MockClustersInterface) Restart(ctx context.Context, restartCluster compute.RestartCluster) (*compute.WaitGetClusterRunning[struct{}], error)

Restart provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) RestartAndWait 

func (_mock *MockClustersInterface) RestartAndWait(ctx context.Context, restartCluster compute.RestartCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

RestartAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) SelectNodeType 

func (_mock *MockClustersInterface) SelectNodeType(ctx context.Context, r compute.NodeTypeRequest) (string, error)

SelectNodeType provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) SelectSparkVersion 

func (_mock *MockClustersInterface) SelectSparkVersion(ctx context.Context, r compute.SparkVersionRequest) (string, error)

SelectSparkVersion provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) SetPermissions 

func (_mock *MockClustersInterface) SetPermissions(ctx context.Context, request compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)

SetPermissions provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) SparkVersions 

func (_mock *MockClustersInterface) SparkVersions(ctx context.Context) (*compute.GetSparkVersionsResponse, error)

SparkVersions provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Start 

func (_mock *MockClustersInterface) Start(ctx context.Context, startCluster compute.StartCluster) (*compute.WaitGetClusterRunning[struct{}], error)

Start provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) StartAndWait 

func (_mock *MockClustersInterface) StartAndWait(ctx context.Context, startCluster compute.StartCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

StartAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) StartByClusterId 

func (_mock *MockClustersInterface) StartByClusterId(ctx context.Context, clusterId string) error

StartByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) StartByClusterIdAndWait 

func (_mock *MockClustersInterface) StartByClusterIdAndWait(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

StartByClusterIdAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Unpin 

func (_mock *MockClustersInterface) Unpin(ctx context.Context, request compute.UnpinCluster) error

Unpin provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) UnpinByClusterId 

func (_mock *MockClustersInterface) UnpinByClusterId(ctx context.Context, clusterId string) error

UnpinByClusterId provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) Update added in v0.44.0 

func (_mock *MockClustersInterface) Update(ctx context.Context, updateCluster compute.UpdateCluster) (*compute.WaitGetClusterRunning[struct{}], error)

Update provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) UpdateAndWait added in v0.44.0 

func (_mock *MockClustersInterface) UpdateAndWait(ctx context.Context, updateCluster compute.UpdateCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)

UpdateAndWait provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) UpdatePermissions 

func (_mock *MockClustersInterface) UpdatePermissions(ctx context.Context, request compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)

UpdatePermissions provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) WaitGetClusterRunning 

func (_mock *MockClustersInterface) WaitGetClusterRunning(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)

WaitGetClusterRunning provides a mock function for the type MockClustersInterface

func (*MockClustersInterface) WaitGetClusterTerminated 

func (_mock *MockClustersInterface) WaitGetClusterTerminated(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)

WaitGetClusterTerminated provides a mock function for the type MockClustersInterface

type MockClustersInterface_ChangeOwner_Call 

type MockClustersInterface_ChangeOwner_Call struct {
	*mock.Call
}

MockClustersInterface_ChangeOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeOwner'

func (*MockClustersInterface_ChangeOwner_Call) Return 

func (_c *MockClustersInterface_ChangeOwner_Call) Return(err error) *MockClustersInterface_ChangeOwner_Call

func (*MockClustersInterface_ChangeOwner_Call) Run 

func (_c *MockClustersInterface_ChangeOwner_Call) Run(run func(ctx context.Context, request compute.ChangeClusterOwner)) *MockClustersInterface_ChangeOwner_Call

func (*MockClustersInterface_ChangeOwner_Call) RunAndReturn 

func (_c *MockClustersInterface_ChangeOwner_Call) RunAndReturn(run func(ctx context.Context, request compute.ChangeClusterOwner) error) *MockClustersInterface_ChangeOwner_Call

type MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call 

type MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call struct {
	*mock.Call
}

MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterDetailsClusterNameToClusterIdMap'

func (*MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) Return 

func (_c *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) Return(stringToString map[string]string, err error) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call

func (*MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) Run 

func (_c *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) Run(run func(ctx context.Context, request compute.ListClustersRequest)) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call

func (*MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) RunAndReturn 

func (_c *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClustersRequest) (map[string]string, error)) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call

type MockClustersInterface_CreateAndWait_Call 

type MockClustersInterface_CreateAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_CreateAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAndWait'

func (*MockClustersInterface_CreateAndWait_Call) Return 

func (_c *MockClustersInterface_CreateAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_CreateAndWait_Call

func (*MockClustersInterface_CreateAndWait_Call) Run 

func (_c *MockClustersInterface_CreateAndWait_Call) Run(run func(ctx context.Context, createCluster compute.CreateCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_CreateAndWait_Call

func (*MockClustersInterface_CreateAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_CreateAndWait_Call) RunAndReturn(run func(ctx context.Context, createCluster compute.CreateCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_CreateAndWait_Call

type MockClustersInterface_Create_Call 

type MockClustersInterface_Create_Call struct {
	*mock.Call
}

MockClustersInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockClustersInterface_Create_Call) Return 

func (_c *MockClustersInterface_Create_Call) Return(waitGetClusterRunning *compute.WaitGetClusterRunning[compute.CreateClusterResponse], err error) *MockClustersInterface_Create_Call

func (*MockClustersInterface_Create_Call) Run 

func (_c *MockClustersInterface_Create_Call) Run(run func(ctx context.Context, createCluster compute.CreateCluster)) *MockClustersInterface_Create_Call

func (*MockClustersInterface_Create_Call) RunAndReturn 

func (_c *MockClustersInterface_Create_Call) RunAndReturn(run func(ctx context.Context, createCluster compute.CreateCluster) (*compute.WaitGetClusterRunning[compute.CreateClusterResponse], error)) *MockClustersInterface_Create_Call

type MockClustersInterface_DeleteAndWait_Call 

type MockClustersInterface_DeleteAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_DeleteAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAndWait'

func (*MockClustersInterface_DeleteAndWait_Call) Return 

func (_c *MockClustersInterface_DeleteAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_DeleteAndWait_Call

func (*MockClustersInterface_DeleteAndWait_Call) Run 

func (_c *MockClustersInterface_DeleteAndWait_Call) Run(run func(ctx context.Context, deleteCluster compute.DeleteCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_DeleteAndWait_Call

func (*MockClustersInterface_DeleteAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_DeleteAndWait_Call) RunAndReturn(run func(ctx context.Context, deleteCluster compute.DeleteCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_DeleteAndWait_Call

type MockClustersInterface_DeleteByClusterIdAndWait_Call 

type MockClustersInterface_DeleteByClusterIdAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_DeleteByClusterIdAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByClusterIdAndWait'

func (*MockClustersInterface_DeleteByClusterIdAndWait_Call) Return 

func (_c *MockClustersInterface_DeleteByClusterIdAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_DeleteByClusterIdAndWait_Call

func (*MockClustersInterface_DeleteByClusterIdAndWait_Call) Run 

func (_c *MockClustersInterface_DeleteByClusterIdAndWait_Call) Run(run func(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_DeleteByClusterIdAndWait_Call

func (*MockClustersInterface_DeleteByClusterIdAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_DeleteByClusterIdAndWait_Call) RunAndReturn(run func(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_DeleteByClusterIdAndWait_Call

type MockClustersInterface_DeleteByClusterId_Call 

type MockClustersInterface_DeleteByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_DeleteByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByClusterId'

func (*MockClustersInterface_DeleteByClusterId_Call) Return 

func (_c *MockClustersInterface_DeleteByClusterId_Call) Return(err error) *MockClustersInterface_DeleteByClusterId_Call

func (*MockClustersInterface_DeleteByClusterId_Call) Run 

func (_c *MockClustersInterface_DeleteByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_DeleteByClusterId_Call

func (*MockClustersInterface_DeleteByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_DeleteByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) error) *MockClustersInterface_DeleteByClusterId_Call

type MockClustersInterface_Delete_Call 

type MockClustersInterface_Delete_Call struct {
	*mock.Call
}

MockClustersInterface_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockClustersInterface_Delete_Call) Return 

func (_c *MockClustersInterface_Delete_Call) Return(waitGetClusterTerminated *compute.WaitGetClusterTerminated[struct{}], err error) *MockClustersInterface_Delete_Call

func (*MockClustersInterface_Delete_Call) Run 

func (_c *MockClustersInterface_Delete_Call) Run(run func(ctx context.Context, deleteCluster compute.DeleteCluster)) *MockClustersInterface_Delete_Call

func (*MockClustersInterface_Delete_Call) RunAndReturn 

func (_c *MockClustersInterface_Delete_Call) RunAndReturn(run func(ctx context.Context, deleteCluster compute.DeleteCluster) (*compute.WaitGetClusterTerminated[struct{}], error)) *MockClustersInterface_Delete_Call

type MockClustersInterface_EditAndWait_Call 

type MockClustersInterface_EditAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_EditAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EditAndWait'

func (*MockClustersInterface_EditAndWait_Call) Return 

func (_c *MockClustersInterface_EditAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_EditAndWait_Call

func (*MockClustersInterface_EditAndWait_Call) Run 

func (_c *MockClustersInterface_EditAndWait_Call) Run(run func(ctx context.Context, editCluster compute.EditCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_EditAndWait_Call

func (*MockClustersInterface_EditAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_EditAndWait_Call) RunAndReturn(run func(ctx context.Context, editCluster compute.EditCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_EditAndWait_Call

type MockClustersInterface_Edit_Call 

type MockClustersInterface_Edit_Call struct {
	*mock.Call
}

MockClustersInterface_Edit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Edit'

func (*MockClustersInterface_Edit_Call) Return 

func (_c *MockClustersInterface_Edit_Call) Return(waitGetClusterRunning *compute.WaitGetClusterRunning[struct{}], err error) *MockClustersInterface_Edit_Call

func (*MockClustersInterface_Edit_Call) Run 

func (_c *MockClustersInterface_Edit_Call) Run(run func(ctx context.Context, editCluster compute.EditCluster)) *MockClustersInterface_Edit_Call

func (*MockClustersInterface_Edit_Call) RunAndReturn 

func (_c *MockClustersInterface_Edit_Call) RunAndReturn(run func(ctx context.Context, editCluster compute.EditCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Edit_Call

type MockClustersInterface_EnsureClusterIsRunning_Call 

type MockClustersInterface_EnsureClusterIsRunning_Call struct {
	*mock.Call
}

MockClustersInterface_EnsureClusterIsRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnsureClusterIsRunning'

func (*MockClustersInterface_EnsureClusterIsRunning_Call) Return 

func (_c *MockClustersInterface_EnsureClusterIsRunning_Call) Return(err error) *MockClustersInterface_EnsureClusterIsRunning_Call

func (*MockClustersInterface_EnsureClusterIsRunning_Call) Run 

func (_c *MockClustersInterface_EnsureClusterIsRunning_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_EnsureClusterIsRunning_Call

func (*MockClustersInterface_EnsureClusterIsRunning_Call) RunAndReturn 

func (_c *MockClustersInterface_EnsureClusterIsRunning_Call) RunAndReturn(run func(ctx context.Context, clusterId string) error) *MockClustersInterface_EnsureClusterIsRunning_Call

type MockClustersInterface_EventsAll_Call 

type MockClustersInterface_EventsAll_Call struct {
	*mock.Call
}

MockClustersInterface_EventsAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EventsAll'

func (*MockClustersInterface_EventsAll_Call) Return 

func (_c *MockClustersInterface_EventsAll_Call) Return(clusterEvents []compute.ClusterEvent, err error) *MockClustersInterface_EventsAll_Call

func (*MockClustersInterface_EventsAll_Call) Run 

func (_c *MockClustersInterface_EventsAll_Call) Run(run func(ctx context.Context, request compute.GetEvents)) *MockClustersInterface_EventsAll_Call

func (*MockClustersInterface_EventsAll_Call) RunAndReturn 

func (_c *MockClustersInterface_EventsAll_Call) RunAndReturn(run func(ctx context.Context, request compute.GetEvents) ([]compute.ClusterEvent, error)) *MockClustersInterface_EventsAll_Call

type MockClustersInterface_Events_Call 

type MockClustersInterface_Events_Call struct {
	*mock.Call
}

MockClustersInterface_Events_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Events'

func (*MockClustersInterface_Events_Call) Return 

func (_c *MockClustersInterface_Events_Call) Return(iterator listing.Iterator[compute.ClusterEvent]) *MockClustersInterface_Events_Call

func (*MockClustersInterface_Events_Call) Run 

func (_c *MockClustersInterface_Events_Call) Run(run func(ctx context.Context, request compute.GetEvents)) *MockClustersInterface_Events_Call

func (*MockClustersInterface_Events_Call) RunAndReturn 

func (_c *MockClustersInterface_Events_Call) RunAndReturn(run func(ctx context.Context, request compute.GetEvents) listing.Iterator[compute.ClusterEvent]) *MockClustersInterface_Events_Call

type MockClustersInterface_Expecter 

type MockClustersInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockClustersInterface_Expecter) ChangeOwner 

func (_e *MockClustersInterface_Expecter) ChangeOwner(ctx any, request any) *MockClustersInterface_ChangeOwner_Call

ChangeOwner is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ChangeClusterOwner

func (*MockClustersInterface_Expecter) ClusterDetailsClusterNameToClusterIdMap 

func (_e *MockClustersInterface_Expecter) ClusterDetailsClusterNameToClusterIdMap(ctx any, request any) *MockClustersInterface_ClusterDetailsClusterNameToClusterIdMap_Call

ClusterDetailsClusterNameToClusterIdMap is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClustersRequest

func (*MockClustersInterface_Expecter) Create 

func (_e *MockClustersInterface_Expecter) Create(ctx any, createCluster any) *MockClustersInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • createCluster compute.CreateCluster

func (*MockClustersInterface_Expecter) CreateAndWait 

func (_e *MockClustersInterface_Expecter) CreateAndWait(ctx any, createCluster any, options ...any) *MockClustersInterface_CreateAndWait_Call

CreateAndWait is a helper method to define mock.On call

  • ctx context.Context
  • createCluster compute.CreateCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) Delete 

func (_e *MockClustersInterface_Expecter) Delete(ctx any, deleteCluster any) *MockClustersInterface_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • deleteCluster compute.DeleteCluster

func (*MockClustersInterface_Expecter) DeleteAndWait 

func (_e *MockClustersInterface_Expecter) DeleteAndWait(ctx any, deleteCluster any, options ...any) *MockClustersInterface_DeleteAndWait_Call

DeleteAndWait is a helper method to define mock.On call

  • ctx context.Context
  • deleteCluster compute.DeleteCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) DeleteByClusterId 

func (_e *MockClustersInterface_Expecter) DeleteByClusterId(ctx any, clusterId any) *MockClustersInterface_DeleteByClusterId_Call

DeleteByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) DeleteByClusterIdAndWait 

func (_e *MockClustersInterface_Expecter) DeleteByClusterIdAndWait(ctx any, clusterId any, options ...any) *MockClustersInterface_DeleteByClusterIdAndWait_Call

DeleteByClusterIdAndWait is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) Edit 

func (_e *MockClustersInterface_Expecter) Edit(ctx any, editCluster any) *MockClustersInterface_Edit_Call

Edit is a helper method to define mock.On call

  • ctx context.Context
  • editCluster compute.EditCluster

func (*MockClustersInterface_Expecter) EditAndWait 

func (_e *MockClustersInterface_Expecter) EditAndWait(ctx any, editCluster any, options ...any) *MockClustersInterface_EditAndWait_Call

EditAndWait is a helper method to define mock.On call

  • ctx context.Context
  • editCluster compute.EditCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) EnsureClusterIsRunning 

func (_e *MockClustersInterface_Expecter) EnsureClusterIsRunning(ctx any, clusterId any) *MockClustersInterface_EnsureClusterIsRunning_Call

EnsureClusterIsRunning is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) Events 

func (_e *MockClustersInterface_Expecter) Events(ctx any, request any) *MockClustersInterface_Events_Call

Events is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetEvents

func (*MockClustersInterface_Expecter) EventsAll 

func (_e *MockClustersInterface_Expecter) EventsAll(ctx any, request any) *MockClustersInterface_EventsAll_Call

EventsAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetEvents

func (*MockClustersInterface_Expecter) Get 

func (_e *MockClustersInterface_Expecter) Get(ctx any, request any) *MockClustersInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterRequest

func (*MockClustersInterface_Expecter) GetByClusterId 

func (_e *MockClustersInterface_Expecter) GetByClusterId(ctx any, clusterId any) *MockClustersInterface_GetByClusterId_Call

GetByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) GetByClusterName 

func (_e *MockClustersInterface_Expecter) GetByClusterName(ctx any, name any) *MockClustersInterface_GetByClusterName_Call

GetByClusterName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockClustersInterface_Expecter) GetOrCreateRunningCluster 

func (_e *MockClustersInterface_Expecter) GetOrCreateRunningCluster(ctx any, name any, custom ...any) *MockClustersInterface_GetOrCreateRunningCluster_Call

GetOrCreateRunningCluster is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • custom ...compute.CreateCluster

func (*MockClustersInterface_Expecter) GetPermissionLevels 

func (_e *MockClustersInterface_Expecter) GetPermissionLevels(ctx any, request any) *MockClustersInterface_GetPermissionLevels_Call

GetPermissionLevels is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterPermissionLevelsRequest

func (*MockClustersInterface_Expecter) GetPermissionLevelsByClusterId 

func (_e *MockClustersInterface_Expecter) GetPermissionLevelsByClusterId(ctx any, clusterId any) *MockClustersInterface_GetPermissionLevelsByClusterId_Call

GetPermissionLevelsByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) GetPermissions 

func (_e *MockClustersInterface_Expecter) GetPermissions(ctx any, request any) *MockClustersInterface_GetPermissions_Call

GetPermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterPermissionsRequest

func (*MockClustersInterface_Expecter) GetPermissionsByClusterId 

func (_e *MockClustersInterface_Expecter) GetPermissionsByClusterId(ctx any, clusterId any) *MockClustersInterface_GetPermissionsByClusterId_Call

GetPermissionsByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) List 

func (_e *MockClustersInterface_Expecter) List(ctx any, request any) *MockClustersInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClustersRequest

func (*MockClustersInterface_Expecter) ListAll 

func (_e *MockClustersInterface_Expecter) ListAll(ctx any, request any) *MockClustersInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClustersRequest

func (*MockClustersInterface_Expecter) ListNodeTypes 

func (_e *MockClustersInterface_Expecter) ListNodeTypes(ctx any) *MockClustersInterface_ListNodeTypes_Call

ListNodeTypes is a helper method to define mock.On call

  • ctx context.Context

func (*MockClustersInterface_Expecter) ListZones 

func (_e *MockClustersInterface_Expecter) ListZones(ctx any) *MockClustersInterface_ListZones_Call

ListZones is a helper method to define mock.On call

  • ctx context.Context

func (*MockClustersInterface_Expecter) PermanentDelete 

func (_e *MockClustersInterface_Expecter) PermanentDelete(ctx any, request any) *MockClustersInterface_PermanentDelete_Call

PermanentDelete is a helper method to define mock.On call

  • ctx context.Context
  • request compute.PermanentDeleteCluster

func (*MockClustersInterface_Expecter) PermanentDeleteByClusterId 

func (_e *MockClustersInterface_Expecter) PermanentDeleteByClusterId(ctx any, clusterId any) *MockClustersInterface_PermanentDeleteByClusterId_Call

PermanentDeleteByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) Pin 

func (_e *MockClustersInterface_Expecter) Pin(ctx any, request any) *MockClustersInterface_Pin_Call

Pin is a helper method to define mock.On call

  • ctx context.Context
  • request compute.PinCluster

func (*MockClustersInterface_Expecter) PinByClusterId 

func (_e *MockClustersInterface_Expecter) PinByClusterId(ctx any, clusterId any) *MockClustersInterface_PinByClusterId_Call

PinByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) Resize 

func (_e *MockClustersInterface_Expecter) Resize(ctx any, resizeCluster any) *MockClustersInterface_Resize_Call

Resize is a helper method to define mock.On call

  • ctx context.Context
  • resizeCluster compute.ResizeCluster

func (*MockClustersInterface_Expecter) ResizeAndWait 

func (_e *MockClustersInterface_Expecter) ResizeAndWait(ctx any, resizeCluster any, options ...any) *MockClustersInterface_ResizeAndWait_Call

ResizeAndWait is a helper method to define mock.On call

  • ctx context.Context
  • resizeCluster compute.ResizeCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) Restart 

func (_e *MockClustersInterface_Expecter) Restart(ctx any, restartCluster any) *MockClustersInterface_Restart_Call

Restart is a helper method to define mock.On call

  • ctx context.Context
  • restartCluster compute.RestartCluster

func (*MockClustersInterface_Expecter) RestartAndWait 

func (_e *MockClustersInterface_Expecter) RestartAndWait(ctx any, restartCluster any, options ...any) *MockClustersInterface_RestartAndWait_Call

RestartAndWait is a helper method to define mock.On call

  • ctx context.Context
  • restartCluster compute.RestartCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) SelectNodeType 

func (_e *MockClustersInterface_Expecter) SelectNodeType(ctx any, r any) *MockClustersInterface_SelectNodeType_Call

SelectNodeType is a helper method to define mock.On call

  • ctx context.Context
  • r compute.NodeTypeRequest

func (*MockClustersInterface_Expecter) SelectSparkVersion 

func (_e *MockClustersInterface_Expecter) SelectSparkVersion(ctx any, r any) *MockClustersInterface_SelectSparkVersion_Call

SelectSparkVersion is a helper method to define mock.On call

  • ctx context.Context
  • r compute.SparkVersionRequest

func (*MockClustersInterface_Expecter) SetPermissions 

func (_e *MockClustersInterface_Expecter) SetPermissions(ctx any, request any) *MockClustersInterface_SetPermissions_Call

SetPermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ClusterPermissionsRequest

func (*MockClustersInterface_Expecter) SparkVersions 

func (_e *MockClustersInterface_Expecter) SparkVersions(ctx any) *MockClustersInterface_SparkVersions_Call

SparkVersions is a helper method to define mock.On call

  • ctx context.Context

func (*MockClustersInterface_Expecter) Start 

func (_e *MockClustersInterface_Expecter) Start(ctx any, startCluster any) *MockClustersInterface_Start_Call

Start is a helper method to define mock.On call

  • ctx context.Context
  • startCluster compute.StartCluster

func (*MockClustersInterface_Expecter) StartAndWait 

func (_e *MockClustersInterface_Expecter) StartAndWait(ctx any, startCluster any, options ...any) *MockClustersInterface_StartAndWait_Call

StartAndWait is a helper method to define mock.On call

  • ctx context.Context
  • startCluster compute.StartCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) StartByClusterId 

func (_e *MockClustersInterface_Expecter) StartByClusterId(ctx any, clusterId any) *MockClustersInterface_StartByClusterId_Call

StartByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) StartByClusterIdAndWait 

func (_e *MockClustersInterface_Expecter) StartByClusterIdAndWait(ctx any, clusterId any, options ...any) *MockClustersInterface_StartByClusterIdAndWait_Call

StartByClusterIdAndWait is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) Unpin 

func (_e *MockClustersInterface_Expecter) Unpin(ctx any, request any) *MockClustersInterface_Unpin_Call

Unpin is a helper method to define mock.On call

  • ctx context.Context
  • request compute.UnpinCluster

func (*MockClustersInterface_Expecter) UnpinByClusterId 

func (_e *MockClustersInterface_Expecter) UnpinByClusterId(ctx any, clusterId any) *MockClustersInterface_UnpinByClusterId_Call

UnpinByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockClustersInterface_Expecter) Update added in v0.44.0 

func (_e *MockClustersInterface_Expecter) Update(ctx any, updateCluster any) *MockClustersInterface_Update_Call

Update is a helper method to define mock.On call

  • ctx context.Context
  • updateCluster compute.UpdateCluster

func (*MockClustersInterface_Expecter) UpdateAndWait added in v0.44.0 

func (_e *MockClustersInterface_Expecter) UpdateAndWait(ctx any, updateCluster any, options ...any) *MockClustersInterface_UpdateAndWait_Call

UpdateAndWait is a helper method to define mock.On call

  • ctx context.Context
  • updateCluster compute.UpdateCluster
  • options ...retries.Option[compute.ClusterDetails]

func (*MockClustersInterface_Expecter) UpdatePermissions 

func (_e *MockClustersInterface_Expecter) UpdatePermissions(ctx any, request any) *MockClustersInterface_UpdatePermissions_Call

UpdatePermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ClusterPermissionsRequest

func (*MockClustersInterface_Expecter) WaitGetClusterRunning 

func (_e *MockClustersInterface_Expecter) WaitGetClusterRunning(ctx any, clusterId any, timeout any, callback any) *MockClustersInterface_WaitGetClusterRunning_Call

WaitGetClusterRunning is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • timeout time.Duration
  • callback func(*compute.ClusterDetails)

func (*MockClustersInterface_Expecter) WaitGetClusterTerminated 

func (_e *MockClustersInterface_Expecter) WaitGetClusterTerminated(ctx any, clusterId any, timeout any, callback any) *MockClustersInterface_WaitGetClusterTerminated_Call

WaitGetClusterTerminated is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • timeout time.Duration
  • callback func(*compute.ClusterDetails)

type MockClustersInterface_GetByClusterId_Call 

type MockClustersInterface_GetByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_GetByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByClusterId'

func (*MockClustersInterface_GetByClusterId_Call) Return 

func (_c *MockClustersInterface_GetByClusterId_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_GetByClusterId_Call

func (*MockClustersInterface_GetByClusterId_Call) Run 

func (_c *MockClustersInterface_GetByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_GetByClusterId_Call

func (*MockClustersInterface_GetByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_GetByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) (*compute.ClusterDetails, error)) *MockClustersInterface_GetByClusterId_Call

type MockClustersInterface_GetByClusterName_Call 

type MockClustersInterface_GetByClusterName_Call struct {
	*mock.Call
}

MockClustersInterface_GetByClusterName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByClusterName'

func (*MockClustersInterface_GetByClusterName_Call) Return 

func (_c *MockClustersInterface_GetByClusterName_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_GetByClusterName_Call

func (*MockClustersInterface_GetByClusterName_Call) Run 

func (_c *MockClustersInterface_GetByClusterName_Call) Run(run func(ctx context.Context, name string)) *MockClustersInterface_GetByClusterName_Call

func (*MockClustersInterface_GetByClusterName_Call) RunAndReturn 

func (_c *MockClustersInterface_GetByClusterName_Call) RunAndReturn(run func(ctx context.Context, name string) (*compute.ClusterDetails, error)) *MockClustersInterface_GetByClusterName_Call

type MockClustersInterface_GetOrCreateRunningCluster_Call 

type MockClustersInterface_GetOrCreateRunningCluster_Call struct {
	*mock.Call
}

MockClustersInterface_GetOrCreateRunningCluster_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrCreateRunningCluster'

func (*MockClustersInterface_GetOrCreateRunningCluster_Call) Return 

func (_c *MockClustersInterface_GetOrCreateRunningCluster_Call) Return(c *compute.ClusterDetails, err error) *MockClustersInterface_GetOrCreateRunningCluster_Call

func (*MockClustersInterface_GetOrCreateRunningCluster_Call) Run 

func (_c *MockClustersInterface_GetOrCreateRunningCluster_Call) Run(run func(ctx context.Context, name string, custom ...compute.CreateCluster)) *MockClustersInterface_GetOrCreateRunningCluster_Call

func (*MockClustersInterface_GetOrCreateRunningCluster_Call) RunAndReturn 

func (_c *MockClustersInterface_GetOrCreateRunningCluster_Call) RunAndReturn(run func(ctx context.Context, name string, custom ...compute.CreateCluster) (*compute.ClusterDetails, error)) *MockClustersInterface_GetOrCreateRunningCluster_Call

type MockClustersInterface_GetPermissionLevelsByClusterId_Call 

type MockClustersInterface_GetPermissionLevelsByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_GetPermissionLevelsByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevelsByClusterId'

func (*MockClustersInterface_GetPermissionLevelsByClusterId_Call) Return 

func (_c *MockClustersInterface_GetPermissionLevelsByClusterId_Call) Return(getClusterPermissionLevelsResponse *compute.GetClusterPermissionLevelsResponse, err error) *MockClustersInterface_GetPermissionLevelsByClusterId_Call

func (*MockClustersInterface_GetPermissionLevelsByClusterId_Call) Run 

func (_c *MockClustersInterface_GetPermissionLevelsByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_GetPermissionLevelsByClusterId_Call

func (*MockClustersInterface_GetPermissionLevelsByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_GetPermissionLevelsByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) (*compute.GetClusterPermissionLevelsResponse, error)) *MockClustersInterface_GetPermissionLevelsByClusterId_Call

type MockClustersInterface_GetPermissionLevels_Call 

type MockClustersInterface_GetPermissionLevels_Call struct {
	*mock.Call
}

MockClustersInterface_GetPermissionLevels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevels'

func (*MockClustersInterface_GetPermissionLevels_Call) Return 

func (_c *MockClustersInterface_GetPermissionLevels_Call) Return(getClusterPermissionLevelsResponse *compute.GetClusterPermissionLevelsResponse, err error) *MockClustersInterface_GetPermissionLevels_Call

func (*MockClustersInterface_GetPermissionLevels_Call) Run 

func (_c *MockClustersInterface_GetPermissionLevels_Call) Run(run func(ctx context.Context, request compute.GetClusterPermissionLevelsRequest)) *MockClustersInterface_GetPermissionLevels_Call

func (*MockClustersInterface_GetPermissionLevels_Call) RunAndReturn 

func (_c *MockClustersInterface_GetPermissionLevels_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterPermissionLevelsRequest) (*compute.GetClusterPermissionLevelsResponse, error)) *MockClustersInterface_GetPermissionLevels_Call

type MockClustersInterface_GetPermissionsByClusterId_Call 

type MockClustersInterface_GetPermissionsByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_GetPermissionsByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionsByClusterId'

func (*MockClustersInterface_GetPermissionsByClusterId_Call) Return 

func (_c *MockClustersInterface_GetPermissionsByClusterId_Call) Return(clusterPermissions *compute.ClusterPermissions, err error) *MockClustersInterface_GetPermissionsByClusterId_Call

func (*MockClustersInterface_GetPermissionsByClusterId_Call) Run 

func (_c *MockClustersInterface_GetPermissionsByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_GetPermissionsByClusterId_Call

func (*MockClustersInterface_GetPermissionsByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_GetPermissionsByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) (*compute.ClusterPermissions, error)) *MockClustersInterface_GetPermissionsByClusterId_Call

type MockClustersInterface_GetPermissions_Call 

type MockClustersInterface_GetPermissions_Call struct {
	*mock.Call
}

MockClustersInterface_GetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissions'

func (*MockClustersInterface_GetPermissions_Call) Return 

func (_c *MockClustersInterface_GetPermissions_Call) Return(clusterPermissions *compute.ClusterPermissions, err error) *MockClustersInterface_GetPermissions_Call

func (*MockClustersInterface_GetPermissions_Call) Run 

func (_c *MockClustersInterface_GetPermissions_Call) Run(run func(ctx context.Context, request compute.GetClusterPermissionsRequest)) *MockClustersInterface_GetPermissions_Call

func (*MockClustersInterface_GetPermissions_Call) RunAndReturn 

func (_c *MockClustersInterface_GetPermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterPermissionsRequest) (*compute.ClusterPermissions, error)) *MockClustersInterface_GetPermissions_Call

type MockClustersInterface_Get_Call 

type MockClustersInterface_Get_Call struct {
	*mock.Call
}

MockClustersInterface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockClustersInterface_Get_Call) Return 

func (_c *MockClustersInterface_Get_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_Get_Call

func (*MockClustersInterface_Get_Call) Run 

func (_c *MockClustersInterface_Get_Call) Run(run func(ctx context.Context, request compute.GetClusterRequest)) *MockClustersInterface_Get_Call

func (*MockClustersInterface_Get_Call) RunAndReturn 

func (_c *MockClustersInterface_Get_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterRequest) (*compute.ClusterDetails, error)) *MockClustersInterface_Get_Call

type MockClustersInterface_ListAll_Call 

type MockClustersInterface_ListAll_Call struct {
	*mock.Call
}

MockClustersInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockClustersInterface_ListAll_Call) Return 

func (_c *MockClustersInterface_ListAll_Call) Return(clusterDetailss []compute.ClusterDetails, err error) *MockClustersInterface_ListAll_Call

func (*MockClustersInterface_ListAll_Call) Run 

func (_c *MockClustersInterface_ListAll_Call) Run(run func(ctx context.Context, request compute.ListClustersRequest)) *MockClustersInterface_ListAll_Call

func (*MockClustersInterface_ListAll_Call) RunAndReturn 

func (_c *MockClustersInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClustersRequest) ([]compute.ClusterDetails, error)) *MockClustersInterface_ListAll_Call

type MockClustersInterface_ListNodeTypes_Call 

type MockClustersInterface_ListNodeTypes_Call struct {
	*mock.Call
}

MockClustersInterface_ListNodeTypes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListNodeTypes'

func (*MockClustersInterface_ListNodeTypes_Call) Return 

func (_c *MockClustersInterface_ListNodeTypes_Call) Return(listNodeTypesResponse *compute.ListNodeTypesResponse, err error) *MockClustersInterface_ListNodeTypes_Call

func (*MockClustersInterface_ListNodeTypes_Call) Run 

func (_c *MockClustersInterface_ListNodeTypes_Call) Run(run func(ctx context.Context)) *MockClustersInterface_ListNodeTypes_Call

func (*MockClustersInterface_ListNodeTypes_Call) RunAndReturn 

func (_c *MockClustersInterface_ListNodeTypes_Call) RunAndReturn(run func(ctx context.Context) (*compute.ListNodeTypesResponse, error)) *MockClustersInterface_ListNodeTypes_Call

type MockClustersInterface_ListZones_Call 

type MockClustersInterface_ListZones_Call struct {
	*mock.Call
}

MockClustersInterface_ListZones_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListZones'

func (*MockClustersInterface_ListZones_Call) Return 

func (_c *MockClustersInterface_ListZones_Call) Return(listAvailableZonesResponse *compute.ListAvailableZonesResponse, err error) *MockClustersInterface_ListZones_Call

func (*MockClustersInterface_ListZones_Call) Run 

func (_c *MockClustersInterface_ListZones_Call) Run(run func(ctx context.Context)) *MockClustersInterface_ListZones_Call

func (*MockClustersInterface_ListZones_Call) RunAndReturn 

func (_c *MockClustersInterface_ListZones_Call) RunAndReturn(run func(ctx context.Context) (*compute.ListAvailableZonesResponse, error)) *MockClustersInterface_ListZones_Call

type MockClustersInterface_List_Call 

type MockClustersInterface_List_Call struct {
	*mock.Call
}

MockClustersInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockClustersInterface_List_Call) Return 

func (_c *MockClustersInterface_List_Call) Return(iterator listing.Iterator[compute.ClusterDetails]) *MockClustersInterface_List_Call

func (*MockClustersInterface_List_Call) Run 

func (_c *MockClustersInterface_List_Call) Run(run func(ctx context.Context, request compute.ListClustersRequest)) *MockClustersInterface_List_Call

func (*MockClustersInterface_List_Call) RunAndReturn 

func (_c *MockClustersInterface_List_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClustersRequest) listing.Iterator[compute.ClusterDetails]) *MockClustersInterface_List_Call

type MockClustersInterface_PermanentDeleteByClusterId_Call 

type MockClustersInterface_PermanentDeleteByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_PermanentDeleteByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PermanentDeleteByClusterId'

func (*MockClustersInterface_PermanentDeleteByClusterId_Call) Return 

func (_c *MockClustersInterface_PermanentDeleteByClusterId_Call) Return(err error) *MockClustersInterface_PermanentDeleteByClusterId_Call

func (*MockClustersInterface_PermanentDeleteByClusterId_Call) Run 

func (_c *MockClustersInterface_PermanentDeleteByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_PermanentDeleteByClusterId_Call

func (*MockClustersInterface_PermanentDeleteByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_PermanentDeleteByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) error) *MockClustersInterface_PermanentDeleteByClusterId_Call

type MockClustersInterface_PermanentDelete_Call 

type MockClustersInterface_PermanentDelete_Call struct {
	*mock.Call
}

MockClustersInterface_PermanentDelete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PermanentDelete'

func (*MockClustersInterface_PermanentDelete_Call) Return 

func (_c *MockClustersInterface_PermanentDelete_Call) Return(err error) *MockClustersInterface_PermanentDelete_Call

func (*MockClustersInterface_PermanentDelete_Call) Run 

func (_c *MockClustersInterface_PermanentDelete_Call) Run(run func(ctx context.Context, request compute.PermanentDeleteCluster)) *MockClustersInterface_PermanentDelete_Call

func (*MockClustersInterface_PermanentDelete_Call) RunAndReturn 

func (_c *MockClustersInterface_PermanentDelete_Call) RunAndReturn(run func(ctx context.Context, request compute.PermanentDeleteCluster) error) *MockClustersInterface_PermanentDelete_Call

type MockClustersInterface_PinByClusterId_Call 

type MockClustersInterface_PinByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_PinByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PinByClusterId'

func (*MockClustersInterface_PinByClusterId_Call) Return 

func (_c *MockClustersInterface_PinByClusterId_Call) Return(err error) *MockClustersInterface_PinByClusterId_Call

func (*MockClustersInterface_PinByClusterId_Call) Run 

func (_c *MockClustersInterface_PinByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_PinByClusterId_Call

func (*MockClustersInterface_PinByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_PinByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) error) *MockClustersInterface_PinByClusterId_Call

type MockClustersInterface_Pin_Call 

type MockClustersInterface_Pin_Call struct {
	*mock.Call
}

MockClustersInterface_Pin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pin'

func (*MockClustersInterface_Pin_Call) Return 

func (_c *MockClustersInterface_Pin_Call) Return(err error) *MockClustersInterface_Pin_Call

func (*MockClustersInterface_Pin_Call) Run 

func (_c *MockClustersInterface_Pin_Call) Run(run func(ctx context.Context, request compute.PinCluster)) *MockClustersInterface_Pin_Call

func (*MockClustersInterface_Pin_Call) RunAndReturn 

func (_c *MockClustersInterface_Pin_Call) RunAndReturn(run func(ctx context.Context, request compute.PinCluster) error) *MockClustersInterface_Pin_Call

type MockClustersInterface_ResizeAndWait_Call 

type MockClustersInterface_ResizeAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_ResizeAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResizeAndWait'

func (*MockClustersInterface_ResizeAndWait_Call) Return 

func (_c *MockClustersInterface_ResizeAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_ResizeAndWait_Call

func (*MockClustersInterface_ResizeAndWait_Call) Run 

func (_c *MockClustersInterface_ResizeAndWait_Call) Run(run func(ctx context.Context, resizeCluster compute.ResizeCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_ResizeAndWait_Call

func (*MockClustersInterface_ResizeAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_ResizeAndWait_Call) RunAndReturn(run func(ctx context.Context, resizeCluster compute.ResizeCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_ResizeAndWait_Call

type MockClustersInterface_Resize_Call 

type MockClustersInterface_Resize_Call struct {
	*mock.Call
}

MockClustersInterface_Resize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resize'

func (*MockClustersInterface_Resize_Call) Return 

func (_c *MockClustersInterface_Resize_Call) Return(waitGetClusterRunning *compute.WaitGetClusterRunning[struct{}], err error) *MockClustersInterface_Resize_Call

func (*MockClustersInterface_Resize_Call) Run 

func (_c *MockClustersInterface_Resize_Call) Run(run func(ctx context.Context, resizeCluster compute.ResizeCluster)) *MockClustersInterface_Resize_Call

func (*MockClustersInterface_Resize_Call) RunAndReturn 

func (_c *MockClustersInterface_Resize_Call) RunAndReturn(run func(ctx context.Context, resizeCluster compute.ResizeCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Resize_Call

type MockClustersInterface_RestartAndWait_Call 

type MockClustersInterface_RestartAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_RestartAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestartAndWait'

func (*MockClustersInterface_RestartAndWait_Call) Return 

func (_c *MockClustersInterface_RestartAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_RestartAndWait_Call

func (*MockClustersInterface_RestartAndWait_Call) Run 

func (_c *MockClustersInterface_RestartAndWait_Call) Run(run func(ctx context.Context, restartCluster compute.RestartCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_RestartAndWait_Call

func (*MockClustersInterface_RestartAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_RestartAndWait_Call) RunAndReturn(run func(ctx context.Context, restartCluster compute.RestartCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_RestartAndWait_Call

type MockClustersInterface_Restart_Call 

type MockClustersInterface_Restart_Call struct {
	*mock.Call
}

MockClustersInterface_Restart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Restart'

func (*MockClustersInterface_Restart_Call) Return 

func (_c *MockClustersInterface_Restart_Call) Return(waitGetClusterRunning *compute.WaitGetClusterRunning[struct{}], err error) *MockClustersInterface_Restart_Call

func (*MockClustersInterface_Restart_Call) Run 

func (_c *MockClustersInterface_Restart_Call) Run(run func(ctx context.Context, restartCluster compute.RestartCluster)) *MockClustersInterface_Restart_Call

func (*MockClustersInterface_Restart_Call) RunAndReturn 

func (_c *MockClustersInterface_Restart_Call) RunAndReturn(run func(ctx context.Context, restartCluster compute.RestartCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Restart_Call

type MockClustersInterface_SelectNodeType_Call 

type MockClustersInterface_SelectNodeType_Call struct {
	*mock.Call
}

MockClustersInterface_SelectNodeType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectNodeType'

func (*MockClustersInterface_SelectNodeType_Call) Return 

func (_c *MockClustersInterface_SelectNodeType_Call) Return(s string, err error) *MockClustersInterface_SelectNodeType_Call

func (*MockClustersInterface_SelectNodeType_Call) Run 

func (_c *MockClustersInterface_SelectNodeType_Call) Run(run func(ctx context.Context, r compute.NodeTypeRequest)) *MockClustersInterface_SelectNodeType_Call

func (*MockClustersInterface_SelectNodeType_Call) RunAndReturn 

func (_c *MockClustersInterface_SelectNodeType_Call) RunAndReturn(run func(ctx context.Context, r compute.NodeTypeRequest) (string, error)) *MockClustersInterface_SelectNodeType_Call

type MockClustersInterface_SelectSparkVersion_Call 

type MockClustersInterface_SelectSparkVersion_Call struct {
	*mock.Call
}

MockClustersInterface_SelectSparkVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectSparkVersion'

func (*MockClustersInterface_SelectSparkVersion_Call) Return 

func (_c *MockClustersInterface_SelectSparkVersion_Call) Return(s string, err error) *MockClustersInterface_SelectSparkVersion_Call

func (*MockClustersInterface_SelectSparkVersion_Call) Run 

func (_c *MockClustersInterface_SelectSparkVersion_Call) Run(run func(ctx context.Context, r compute.SparkVersionRequest)) *MockClustersInterface_SelectSparkVersion_Call

func (*MockClustersInterface_SelectSparkVersion_Call) RunAndReturn 

func (_c *MockClustersInterface_SelectSparkVersion_Call) RunAndReturn(run func(ctx context.Context, r compute.SparkVersionRequest) (string, error)) *MockClustersInterface_SelectSparkVersion_Call

type MockClustersInterface_SetPermissions_Call 

type MockClustersInterface_SetPermissions_Call struct {
	*mock.Call
}

MockClustersInterface_SetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPermissions'

func (*MockClustersInterface_SetPermissions_Call) Return 

func (_c *MockClustersInterface_SetPermissions_Call) Return(clusterPermissions *compute.ClusterPermissions, err error) *MockClustersInterface_SetPermissions_Call

func (*MockClustersInterface_SetPermissions_Call) Run 

func (_c *MockClustersInterface_SetPermissions_Call) Run(run func(ctx context.Context, request compute.ClusterPermissionsRequest)) *MockClustersInterface_SetPermissions_Call

func (*MockClustersInterface_SetPermissions_Call) RunAndReturn 

func (_c *MockClustersInterface_SetPermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)) *MockClustersInterface_SetPermissions_Call

type MockClustersInterface_SparkVersions_Call 

type MockClustersInterface_SparkVersions_Call struct {
	*mock.Call
}

MockClustersInterface_SparkVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SparkVersions'

func (*MockClustersInterface_SparkVersions_Call) Return 

func (_c *MockClustersInterface_SparkVersions_Call) Return(getSparkVersionsResponse *compute.GetSparkVersionsResponse, err error) *MockClustersInterface_SparkVersions_Call

func (*MockClustersInterface_SparkVersions_Call) Run 

func (_c *MockClustersInterface_SparkVersions_Call) Run(run func(ctx context.Context)) *MockClustersInterface_SparkVersions_Call

func (*MockClustersInterface_SparkVersions_Call) RunAndReturn 

func (_c *MockClustersInterface_SparkVersions_Call) RunAndReturn(run func(ctx context.Context) (*compute.GetSparkVersionsResponse, error)) *MockClustersInterface_SparkVersions_Call

type MockClustersInterface_StartAndWait_Call 

type MockClustersInterface_StartAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_StartAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartAndWait'

func (*MockClustersInterface_StartAndWait_Call) Return 

func (_c *MockClustersInterface_StartAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_StartAndWait_Call

func (*MockClustersInterface_StartAndWait_Call) Run 

func (_c *MockClustersInterface_StartAndWait_Call) Run(run func(ctx context.Context, startCluster compute.StartCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_StartAndWait_Call

func (*MockClustersInterface_StartAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_StartAndWait_Call) RunAndReturn(run func(ctx context.Context, startCluster compute.StartCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_StartAndWait_Call

type MockClustersInterface_StartByClusterIdAndWait_Call 

type MockClustersInterface_StartByClusterIdAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_StartByClusterIdAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartByClusterIdAndWait'

func (*MockClustersInterface_StartByClusterIdAndWait_Call) Return 

func (_c *MockClustersInterface_StartByClusterIdAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_StartByClusterIdAndWait_Call

func (*MockClustersInterface_StartByClusterIdAndWait_Call) Run 

func (_c *MockClustersInterface_StartByClusterIdAndWait_Call) Run(run func(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_StartByClusterIdAndWait_Call

func (*MockClustersInterface_StartByClusterIdAndWait_Call) RunAndReturn 

func (_c *MockClustersInterface_StartByClusterIdAndWait_Call) RunAndReturn(run func(ctx context.Context, clusterId string, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_StartByClusterIdAndWait_Call

type MockClustersInterface_StartByClusterId_Call 

type MockClustersInterface_StartByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_StartByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartByClusterId'

func (*MockClustersInterface_StartByClusterId_Call) Return 

func (_c *MockClustersInterface_StartByClusterId_Call) Return(err error) *MockClustersInterface_StartByClusterId_Call

func (*MockClustersInterface_StartByClusterId_Call) Run 

func (_c *MockClustersInterface_StartByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_StartByClusterId_Call

func (*MockClustersInterface_StartByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_StartByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) error) *MockClustersInterface_StartByClusterId_Call

type MockClustersInterface_Start_Call 

type MockClustersInterface_Start_Call struct {
	*mock.Call
}

MockClustersInterface_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'

func (*MockClustersInterface_Start_Call) Return 

func (_c *MockClustersInterface_Start_Call) Return(waitGetClusterRunning *compute.WaitGetClusterRunning[struct{}], err error) *MockClustersInterface_Start_Call

func (*MockClustersInterface_Start_Call) Run 

func (_c *MockClustersInterface_Start_Call) Run(run func(ctx context.Context, startCluster compute.StartCluster)) *MockClustersInterface_Start_Call

func (*MockClustersInterface_Start_Call) RunAndReturn 

func (_c *MockClustersInterface_Start_Call) RunAndReturn(run func(ctx context.Context, startCluster compute.StartCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Start_Call

type MockClustersInterface_UnpinByClusterId_Call 

type MockClustersInterface_UnpinByClusterId_Call struct {
	*mock.Call
}

MockClustersInterface_UnpinByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnpinByClusterId'

func (*MockClustersInterface_UnpinByClusterId_Call) Return 

func (_c *MockClustersInterface_UnpinByClusterId_Call) Return(err error) *MockClustersInterface_UnpinByClusterId_Call

func (*MockClustersInterface_UnpinByClusterId_Call) Run 

func (_c *MockClustersInterface_UnpinByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockClustersInterface_UnpinByClusterId_Call

func (*MockClustersInterface_UnpinByClusterId_Call) RunAndReturn 

func (_c *MockClustersInterface_UnpinByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) error) *MockClustersInterface_UnpinByClusterId_Call

type MockClustersInterface_Unpin_Call 

type MockClustersInterface_Unpin_Call struct {
	*mock.Call
}

MockClustersInterface_Unpin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unpin'

func (*MockClustersInterface_Unpin_Call) Return 

func (_c *MockClustersInterface_Unpin_Call) Return(err error) *MockClustersInterface_Unpin_Call

func (*MockClustersInterface_Unpin_Call) Run 

func (_c *MockClustersInterface_Unpin_Call) Run(run func(ctx context.Context, request compute.UnpinCluster)) *MockClustersInterface_Unpin_Call

func (*MockClustersInterface_Unpin_Call) RunAndReturn 

func (_c *MockClustersInterface_Unpin_Call) RunAndReturn(run func(ctx context.Context, request compute.UnpinCluster) error) *MockClustersInterface_Unpin_Call

type MockClustersInterface_UpdateAndWait_Call added in v0.44.0 

type MockClustersInterface_UpdateAndWait_Call struct {
	*mock.Call
}

MockClustersInterface_UpdateAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAndWait'

func (*MockClustersInterface_UpdateAndWait_Call) Return added in v0.44.0 

func (_c *MockClustersInterface_UpdateAndWait_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_UpdateAndWait_Call

func (*MockClustersInterface_UpdateAndWait_Call) Run added in v0.44.0 

func (_c *MockClustersInterface_UpdateAndWait_Call) Run(run func(ctx context.Context, updateCluster compute.UpdateCluster, options ...retries.Option[compute.ClusterDetails])) *MockClustersInterface_UpdateAndWait_Call

func (*MockClustersInterface_UpdateAndWait_Call) RunAndReturn added in v0.44.0 

func (_c *MockClustersInterface_UpdateAndWait_Call) RunAndReturn(run func(ctx context.Context, updateCluster compute.UpdateCluster, options ...retries.Option[compute.ClusterDetails]) (*compute.ClusterDetails, error)) *MockClustersInterface_UpdateAndWait_Call

type MockClustersInterface_UpdatePermissions_Call 

type MockClustersInterface_UpdatePermissions_Call struct {
	*mock.Call
}

MockClustersInterface_UpdatePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePermissions'

func (*MockClustersInterface_UpdatePermissions_Call) Return 

func (_c *MockClustersInterface_UpdatePermissions_Call) Return(clusterPermissions *compute.ClusterPermissions, err error) *MockClustersInterface_UpdatePermissions_Call

func (*MockClustersInterface_UpdatePermissions_Call) Run 

func (_c *MockClustersInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request compute.ClusterPermissionsRequest)) *MockClustersInterface_UpdatePermissions_Call

func (*MockClustersInterface_UpdatePermissions_Call) RunAndReturn 

func (_c *MockClustersInterface_UpdatePermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.ClusterPermissionsRequest) (*compute.ClusterPermissions, error)) *MockClustersInterface_UpdatePermissions_Call

type MockClustersInterface_Update_Call added in v0.44.0 

type MockClustersInterface_Update_Call struct {
	*mock.Call
}

MockClustersInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockClustersInterface_Update_Call) Return added in v0.44.0 

func (_c *MockClustersInterface_Update_Call) Return(waitGetClusterRunning *compute.WaitGetClusterRunning[struct{}], err error) *MockClustersInterface_Update_Call

func (*MockClustersInterface_Update_Call) Run added in v0.44.0 

func (_c *MockClustersInterface_Update_Call) Run(run func(ctx context.Context, updateCluster compute.UpdateCluster)) *MockClustersInterface_Update_Call

func (*MockClustersInterface_Update_Call) RunAndReturn added in v0.44.0 

func (_c *MockClustersInterface_Update_Call) RunAndReturn(run func(ctx context.Context, updateCluster compute.UpdateCluster) (*compute.WaitGetClusterRunning[struct{}], error)) *MockClustersInterface_Update_Call

type MockClustersInterface_WaitGetClusterRunning_Call 

type MockClustersInterface_WaitGetClusterRunning_Call struct {
	*mock.Call
}

MockClustersInterface_WaitGetClusterRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitGetClusterRunning'

func (*MockClustersInterface_WaitGetClusterRunning_Call) Return 

func (_c *MockClustersInterface_WaitGetClusterRunning_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_WaitGetClusterRunning_Call

func (*MockClustersInterface_WaitGetClusterRunning_Call) Run 

func (_c *MockClustersInterface_WaitGetClusterRunning_Call) Run(run func(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails))) *MockClustersInterface_WaitGetClusterRunning_Call

func (*MockClustersInterface_WaitGetClusterRunning_Call) RunAndReturn 

func (_c *MockClustersInterface_WaitGetClusterRunning_Call) RunAndReturn(run func(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)) *MockClustersInterface_WaitGetClusterRunning_Call

type MockClustersInterface_WaitGetClusterTerminated_Call 

type MockClustersInterface_WaitGetClusterTerminated_Call struct {
	*mock.Call
}

MockClustersInterface_WaitGetClusterTerminated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitGetClusterTerminated'

func (*MockClustersInterface_WaitGetClusterTerminated_Call) Return 

func (_c *MockClustersInterface_WaitGetClusterTerminated_Call) Return(clusterDetails *compute.ClusterDetails, err error) *MockClustersInterface_WaitGetClusterTerminated_Call

func (*MockClustersInterface_WaitGetClusterTerminated_Call) Run 

func (_c *MockClustersInterface_WaitGetClusterTerminated_Call) Run(run func(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails))) *MockClustersInterface_WaitGetClusterTerminated_Call

func (*MockClustersInterface_WaitGetClusterTerminated_Call) RunAndReturn 

func (_c *MockClustersInterface_WaitGetClusterTerminated_Call) RunAndReturn(run func(ctx context.Context, clusterId string, timeout time.Duration, callback func(*compute.ClusterDetails)) (*compute.ClusterDetails, error)) *MockClustersInterface_WaitGetClusterTerminated_Call

type MockCommandExecutionInterface 

type MockCommandExecutionInterface struct {
	mock.Mock
}

MockCommandExecutionInterface is an autogenerated mock type for the CommandExecutionInterface type

func NewMockCommandExecutionInterface 

func NewMockCommandExecutionInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCommandExecutionInterface

NewMockCommandExecutionInterface creates a new instance of MockCommandExecutionInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockCommandExecutionInterface) Cancel 

func (_mock *MockCommandExecutionInterface) Cancel(ctx context.Context, cancelCommand compute.CancelCommand) (*compute.WaitCommandStatusCommandExecutionCancelled[struct{}], error)

Cancel provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) CancelAndWait 

func (_mock *MockCommandExecutionInterface) CancelAndWait(ctx context.Context, cancelCommand compute.CancelCommand, options ...retries.Option[compute.CommandStatusResponse]) (*compute.CommandStatusResponse, error)

CancelAndWait provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) CommandStatus 

func (_mock *MockCommandExecutionInterface) CommandStatus(ctx context.Context, request compute.CommandStatusRequest) (*compute.CommandStatusResponse, error)

CommandStatus provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) ContextStatus 

func (_mock *MockCommandExecutionInterface) ContextStatus(ctx context.Context, request compute.ContextStatusRequest) (*compute.ContextStatusResponse, error)

ContextStatus provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) Create 

func (_mock *MockCommandExecutionInterface) Create(ctx context.Context, createContext compute.CreateContext) (*compute.WaitContextStatusCommandExecutionRunning[compute.Created], error)

Create provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) CreateAndWait 

func (_mock *MockCommandExecutionInterface) CreateAndWait(ctx context.Context, createContext compute.CreateContext, options ...retries.Option[compute.ContextStatusResponse]) (*compute.ContextStatusResponse, error)

CreateAndWait provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) Destroy 

func (_mock *MockCommandExecutionInterface) Destroy(ctx context.Context, request compute.DestroyContext) error

Destroy provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) EXPECT 

func (_m *MockCommandExecutionInterface) EXPECT() *MockCommandExecutionInterface_Expecter

func (*MockCommandExecutionInterface) Execute 

func (_mock *MockCommandExecutionInterface) Execute(ctx context.Context, command compute.Command) (*compute.WaitCommandStatusCommandExecutionFinishedOrError[compute.Created], error)

Execute provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) ExecuteAndWait 

func (_mock *MockCommandExecutionInterface) ExecuteAndWait(ctx context.Context, command compute.Command, options ...retries.Option[compute.CommandStatusResponse]) (*compute.CommandStatusResponse, error)

ExecuteAndWait provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) Start 

func (_mock *MockCommandExecutionInterface) Start(ctx context.Context, clusterID string, language compute.Language) (*compute.CommandExecutorV2, error)

Start provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) WaitCommandStatusCommandExecutionCancelled 

func (_mock *MockCommandExecutionInterface) WaitCommandStatusCommandExecutionCancelled(ctx context.Context, clusterId string, commandId string, contextId string, timeout time.Duration, callback func(*compute.CommandStatusResponse)) (*compute.CommandStatusResponse, error)

WaitCommandStatusCommandExecutionCancelled provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) WaitCommandStatusCommandExecutionFinishedOrError 

func (_mock *MockCommandExecutionInterface) WaitCommandStatusCommandExecutionFinishedOrError(ctx context.Context, clusterId string, commandId string, contextId string, timeout time.Duration, callback func(*compute.CommandStatusResponse)) (*compute.CommandStatusResponse, error)

WaitCommandStatusCommandExecutionFinishedOrError provides a mock function for the type MockCommandExecutionInterface

func (*MockCommandExecutionInterface) WaitContextStatusCommandExecutionRunning 

func (_mock *MockCommandExecutionInterface) WaitContextStatusCommandExecutionRunning(ctx context.Context, clusterId string, contextId string, timeout time.Duration, callback func(*compute.ContextStatusResponse)) (*compute.ContextStatusResponse, error)

WaitContextStatusCommandExecutionRunning provides a mock function for the type MockCommandExecutionInterface

type MockCommandExecutionInterface_CancelAndWait_Call 

type MockCommandExecutionInterface_CancelAndWait_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_CancelAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelAndWait'

func (*MockCommandExecutionInterface_CancelAndWait_Call) Return 

func (_c *MockCommandExecutionInterface_CancelAndWait_Call) Return(commandStatusResponse *compute.CommandStatusResponse, err error) *MockCommandExecutionInterface_CancelAndWait_Call

func (*MockCommandExecutionInterface_CancelAndWait_Call) Run 

func (_c *MockCommandExecutionInterface_CancelAndWait_Call) Run(run func(ctx context.Context, cancelCommand compute.CancelCommand, options ...retries.Option[compute.CommandStatusResponse])) *MockCommandExecutionInterface_CancelAndWait_Call

func (*MockCommandExecutionInterface_CancelAndWait_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_CancelAndWait_Call) RunAndReturn(run func(ctx context.Context, cancelCommand compute.CancelCommand, options ...retries.Option[compute.CommandStatusResponse]) (*compute.CommandStatusResponse, error)) *MockCommandExecutionInterface_CancelAndWait_Call

type MockCommandExecutionInterface_Cancel_Call 

type MockCommandExecutionInterface_Cancel_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_Cancel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Cancel'

func (*MockCommandExecutionInterface_Cancel_Call) Return 

func (_c *MockCommandExecutionInterface_Cancel_Call) Return(waitCommandStatusCommandExecutionCancelled *compute.WaitCommandStatusCommandExecutionCancelled[struct{}], err error) *MockCommandExecutionInterface_Cancel_Call

func (*MockCommandExecutionInterface_Cancel_Call) Run 

func (_c *MockCommandExecutionInterface_Cancel_Call) Run(run func(ctx context.Context, cancelCommand compute.CancelCommand)) *MockCommandExecutionInterface_Cancel_Call

func (*MockCommandExecutionInterface_Cancel_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_Cancel_Call) RunAndReturn(run func(ctx context.Context, cancelCommand compute.CancelCommand) (*compute.WaitCommandStatusCommandExecutionCancelled[struct{}], error)) *MockCommandExecutionInterface_Cancel_Call

type MockCommandExecutionInterface_CommandStatus_Call 

type MockCommandExecutionInterface_CommandStatus_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_CommandStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandStatus'

func (*MockCommandExecutionInterface_CommandStatus_Call) Return 

func (_c *MockCommandExecutionInterface_CommandStatus_Call) Return(commandStatusResponse *compute.CommandStatusResponse, err error) *MockCommandExecutionInterface_CommandStatus_Call

func (*MockCommandExecutionInterface_CommandStatus_Call) Run 

func (_c *MockCommandExecutionInterface_CommandStatus_Call) Run(run func(ctx context.Context, request compute.CommandStatusRequest)) *MockCommandExecutionInterface_CommandStatus_Call

func (*MockCommandExecutionInterface_CommandStatus_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_CommandStatus_Call) RunAndReturn(run func(ctx context.Context, request compute.CommandStatusRequest) (*compute.CommandStatusResponse, error)) *MockCommandExecutionInterface_CommandStatus_Call

type MockCommandExecutionInterface_ContextStatus_Call 

type MockCommandExecutionInterface_ContextStatus_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_ContextStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContextStatus'

func (*MockCommandExecutionInterface_ContextStatus_Call) Return 

func (_c *MockCommandExecutionInterface_ContextStatus_Call) Return(contextStatusResponse *compute.ContextStatusResponse, err error) *MockCommandExecutionInterface_ContextStatus_Call

func (*MockCommandExecutionInterface_ContextStatus_Call) Run 

func (_c *MockCommandExecutionInterface_ContextStatus_Call) Run(run func(ctx context.Context, request compute.ContextStatusRequest)) *MockCommandExecutionInterface_ContextStatus_Call

func (*MockCommandExecutionInterface_ContextStatus_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_ContextStatus_Call) RunAndReturn(run func(ctx context.Context, request compute.ContextStatusRequest) (*compute.ContextStatusResponse, error)) *MockCommandExecutionInterface_ContextStatus_Call

type MockCommandExecutionInterface_CreateAndWait_Call 

type MockCommandExecutionInterface_CreateAndWait_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_CreateAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAndWait'

func (*MockCommandExecutionInterface_CreateAndWait_Call) Return 

func (_c *MockCommandExecutionInterface_CreateAndWait_Call) Return(contextStatusResponse *compute.ContextStatusResponse, err error) *MockCommandExecutionInterface_CreateAndWait_Call

func (*MockCommandExecutionInterface_CreateAndWait_Call) Run 

func (_c *MockCommandExecutionInterface_CreateAndWait_Call) Run(run func(ctx context.Context, createContext compute.CreateContext, options ...retries.Option[compute.ContextStatusResponse])) *MockCommandExecutionInterface_CreateAndWait_Call

func (*MockCommandExecutionInterface_CreateAndWait_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_CreateAndWait_Call) RunAndReturn(run func(ctx context.Context, createContext compute.CreateContext, options ...retries.Option[compute.ContextStatusResponse]) (*compute.ContextStatusResponse, error)) *MockCommandExecutionInterface_CreateAndWait_Call

type MockCommandExecutionInterface_Create_Call 

type MockCommandExecutionInterface_Create_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockCommandExecutionInterface_Create_Call) Return 

func (_c *MockCommandExecutionInterface_Create_Call) Return(waitContextStatusCommandExecutionRunning *compute.WaitContextStatusCommandExecutionRunning[compute.Created], err error) *MockCommandExecutionInterface_Create_Call

func (*MockCommandExecutionInterface_Create_Call) Run 

func (_c *MockCommandExecutionInterface_Create_Call) Run(run func(ctx context.Context, createContext compute.CreateContext)) *MockCommandExecutionInterface_Create_Call

func (*MockCommandExecutionInterface_Create_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_Create_Call) RunAndReturn(run func(ctx context.Context, createContext compute.CreateContext) (*compute.WaitContextStatusCommandExecutionRunning[compute.Created], error)) *MockCommandExecutionInterface_Create_Call

type MockCommandExecutionInterface_Destroy_Call 

type MockCommandExecutionInterface_Destroy_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_Destroy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Destroy'

func (*MockCommandExecutionInterface_Destroy_Call) Return 

func (_c *MockCommandExecutionInterface_Destroy_Call) Return(err error) *MockCommandExecutionInterface_Destroy_Call

func (*MockCommandExecutionInterface_Destroy_Call) Run 

func (_c *MockCommandExecutionInterface_Destroy_Call) Run(run func(ctx context.Context, request compute.DestroyContext)) *MockCommandExecutionInterface_Destroy_Call

func (*MockCommandExecutionInterface_Destroy_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_Destroy_Call) RunAndReturn(run func(ctx context.Context, request compute.DestroyContext) error) *MockCommandExecutionInterface_Destroy_Call

type MockCommandExecutionInterface_ExecuteAndWait_Call 

type MockCommandExecutionInterface_ExecuteAndWait_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_ExecuteAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExecuteAndWait'

func (*MockCommandExecutionInterface_ExecuteAndWait_Call) Return 

func (_c *MockCommandExecutionInterface_ExecuteAndWait_Call) Return(commandStatusResponse *compute.CommandStatusResponse, err error) *MockCommandExecutionInterface_ExecuteAndWait_Call

func (*MockCommandExecutionInterface_ExecuteAndWait_Call) Run 

func (_c *MockCommandExecutionInterface_ExecuteAndWait_Call) Run(run func(ctx context.Context, command compute.Command, options ...retries.Option[compute.CommandStatusResponse])) *MockCommandExecutionInterface_ExecuteAndWait_Call

func (*MockCommandExecutionInterface_ExecuteAndWait_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_ExecuteAndWait_Call) RunAndReturn(run func(ctx context.Context, command compute.Command, options ...retries.Option[compute.CommandStatusResponse]) (*compute.CommandStatusResponse, error)) *MockCommandExecutionInterface_ExecuteAndWait_Call

type MockCommandExecutionInterface_Execute_Call 

type MockCommandExecutionInterface_Execute_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*MockCommandExecutionInterface_Execute_Call) Return 

func (_c *MockCommandExecutionInterface_Execute_Call) Return(waitCommandStatusCommandExecutionFinishedOrError *compute.WaitCommandStatusCommandExecutionFinishedOrError[compute.Created], err error) *MockCommandExecutionInterface_Execute_Call

func (*MockCommandExecutionInterface_Execute_Call) Run 

func (_c *MockCommandExecutionInterface_Execute_Call) Run(run func(ctx context.Context, command compute.Command)) *MockCommandExecutionInterface_Execute_Call

func (*MockCommandExecutionInterface_Execute_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_Execute_Call) RunAndReturn(run func(ctx context.Context, command compute.Command) (*compute.WaitCommandStatusCommandExecutionFinishedOrError[compute.Created], error)) *MockCommandExecutionInterface_Execute_Call

type MockCommandExecutionInterface_Expecter 

type MockCommandExecutionInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockCommandExecutionInterface_Expecter) Cancel 

func (_e *MockCommandExecutionInterface_Expecter) Cancel(ctx any, cancelCommand any) *MockCommandExecutionInterface_Cancel_Call

Cancel is a helper method to define mock.On call

  • ctx context.Context
  • cancelCommand compute.CancelCommand

func (*MockCommandExecutionInterface_Expecter) CancelAndWait 

func (_e *MockCommandExecutionInterface_Expecter) CancelAndWait(ctx any, cancelCommand any, options ...any) *MockCommandExecutionInterface_CancelAndWait_Call

CancelAndWait is a helper method to define mock.On call

  • ctx context.Context
  • cancelCommand compute.CancelCommand
  • options ...retries.Option[compute.CommandStatusResponse]

func (*MockCommandExecutionInterface_Expecter) CommandStatus 

func (_e *MockCommandExecutionInterface_Expecter) CommandStatus(ctx any, request any) *MockCommandExecutionInterface_CommandStatus_Call

CommandStatus is a helper method to define mock.On call

  • ctx context.Context
  • request compute.CommandStatusRequest

func (*MockCommandExecutionInterface_Expecter) ContextStatus 

func (_e *MockCommandExecutionInterface_Expecter) ContextStatus(ctx any, request any) *MockCommandExecutionInterface_ContextStatus_Call

ContextStatus is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ContextStatusRequest

func (*MockCommandExecutionInterface_Expecter) Create 

func (_e *MockCommandExecutionInterface_Expecter) Create(ctx any, createContext any) *MockCommandExecutionInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • createContext compute.CreateContext

func (*MockCommandExecutionInterface_Expecter) CreateAndWait 

func (_e *MockCommandExecutionInterface_Expecter) CreateAndWait(ctx any, createContext any, options ...any) *MockCommandExecutionInterface_CreateAndWait_Call

CreateAndWait is a helper method to define mock.On call

  • ctx context.Context
  • createContext compute.CreateContext
  • options ...retries.Option[compute.ContextStatusResponse]

func (*MockCommandExecutionInterface_Expecter) Destroy 

func (_e *MockCommandExecutionInterface_Expecter) Destroy(ctx any, request any) *MockCommandExecutionInterface_Destroy_Call

Destroy is a helper method to define mock.On call

  • ctx context.Context
  • request compute.DestroyContext

func (*MockCommandExecutionInterface_Expecter) Execute 

func (_e *MockCommandExecutionInterface_Expecter) Execute(ctx any, command any) *MockCommandExecutionInterface_Execute_Call

Execute is a helper method to define mock.On call

  • ctx context.Context
  • command compute.Command

func (*MockCommandExecutionInterface_Expecter) ExecuteAndWait 

func (_e *MockCommandExecutionInterface_Expecter) ExecuteAndWait(ctx any, command any, options ...any) *MockCommandExecutionInterface_ExecuteAndWait_Call

ExecuteAndWait is a helper method to define mock.On call

  • ctx context.Context
  • command compute.Command
  • options ...retries.Option[compute.CommandStatusResponse]

func (*MockCommandExecutionInterface_Expecter) Start 

func (_e *MockCommandExecutionInterface_Expecter) Start(ctx any, clusterID any, language any) *MockCommandExecutionInterface_Start_Call

Start is a helper method to define mock.On call

  • ctx context.Context
  • clusterID string
  • language compute.Language

func (*MockCommandExecutionInterface_Expecter) WaitCommandStatusCommandExecutionCancelled 

func (_e *MockCommandExecutionInterface_Expecter) WaitCommandStatusCommandExecutionCancelled(ctx any, clusterId any, commandId any, contextId any, timeout any, callback any) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call

WaitCommandStatusCommandExecutionCancelled is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • commandId string
  • contextId string
  • timeout time.Duration
  • callback func(*compute.CommandStatusResponse)

func (*MockCommandExecutionInterface_Expecter) WaitCommandStatusCommandExecutionFinishedOrError 

func (_e *MockCommandExecutionInterface_Expecter) WaitCommandStatusCommandExecutionFinishedOrError(ctx any, clusterId any, commandId any, contextId any, timeout any, callback any) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call

WaitCommandStatusCommandExecutionFinishedOrError is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • commandId string
  • contextId string
  • timeout time.Duration
  • callback func(*compute.CommandStatusResponse)

func (*MockCommandExecutionInterface_Expecter) WaitContextStatusCommandExecutionRunning 

func (_e *MockCommandExecutionInterface_Expecter) WaitContextStatusCommandExecutionRunning(ctx any, clusterId any, contextId any, timeout any, callback any) *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call

WaitContextStatusCommandExecutionRunning is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string
  • contextId string
  • timeout time.Duration
  • callback func(*compute.ContextStatusResponse)

type MockCommandExecutionInterface_Start_Call 

type MockCommandExecutionInterface_Start_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'

func (*MockCommandExecutionInterface_Start_Call) Return 

func (_c *MockCommandExecutionInterface_Start_Call) Return(commandExecutorV2 *compute.CommandExecutorV2, err error) *MockCommandExecutionInterface_Start_Call

func (*MockCommandExecutionInterface_Start_Call) Run 

func (_c *MockCommandExecutionInterface_Start_Call) Run(run func(ctx context.Context, clusterID string, language compute.Language)) *MockCommandExecutionInterface_Start_Call

func (*MockCommandExecutionInterface_Start_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_Start_Call) RunAndReturn(run func(ctx context.Context, clusterID string, language compute.Language) (*compute.CommandExecutorV2, error)) *MockCommandExecutionInterface_Start_Call

type MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call 

type MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitCommandStatusCommandExecutionCancelled'

func (*MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call) Return 

func (_c *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call) Return(commandStatusResponse *compute.CommandStatusResponse, err error) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call

func (*MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call) Run 

func (_c *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call) Run(run func(ctx context.Context, clusterId string, commandId string, contextId string, timeout time.Duration, callback func(*compute.CommandStatusResponse))) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call

func (*MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call) RunAndReturn(run func(ctx context.Context, clusterId string, commandId string, contextId string, timeout time.Duration, callback func(*compute.CommandStatusResponse)) (*compute.CommandStatusResponse, error)) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionCancelled_Call

type MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call 

type MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitCommandStatusCommandExecutionFinishedOrError'

func (*MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call) Return 

func (_c *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call) Return(commandStatusResponse *compute.CommandStatusResponse, err error) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call

func (*MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call) Run 

func (_c *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call) Run(run func(ctx context.Context, clusterId string, commandId string, contextId string, timeout time.Duration, callback func(*compute.CommandStatusResponse))) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call

func (*MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call) RunAndReturn(run func(ctx context.Context, clusterId string, commandId string, contextId string, timeout time.Duration, callback func(*compute.CommandStatusResponse)) (*compute.CommandStatusResponse, error)) *MockCommandExecutionInterface_WaitCommandStatusCommandExecutionFinishedOrError_Call

type MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call 

type MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call struct {
	*mock.Call
}

MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitContextStatusCommandExecutionRunning'

func (*MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call) Return 

func (_c *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call) Return(contextStatusResponse *compute.ContextStatusResponse, err error) *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call

func (*MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call) Run 

func (_c *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call) Run(run func(ctx context.Context, clusterId string, contextId string, timeout time.Duration, callback func(*compute.ContextStatusResponse))) *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call

func (*MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call) RunAndReturn(run func(ctx context.Context, clusterId string, contextId string, timeout time.Duration, callback func(*compute.ContextStatusResponse)) (*compute.ContextStatusResponse, error)) *MockCommandExecutionInterface_WaitContextStatusCommandExecutionRunning_Call

type MockGlobalInitScriptsInterface 

type MockGlobalInitScriptsInterface struct {
	mock.Mock
}

MockGlobalInitScriptsInterface is an autogenerated mock type for the GlobalInitScriptsInterface type

func NewMockGlobalInitScriptsInterface 

func NewMockGlobalInitScriptsInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGlobalInitScriptsInterface

NewMockGlobalInitScriptsInterface creates a new instance of MockGlobalInitScriptsInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockGlobalInitScriptsInterface) Create 

func (_mock *MockGlobalInitScriptsInterface) Create(ctx context.Context, request compute.GlobalInitScriptCreateRequest) (*compute.CreateResponse, error)

Create provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) Delete 

func (_mock *MockGlobalInitScriptsInterface) Delete(ctx context.Context, request compute.DeleteGlobalInitScriptRequest) error

Delete provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) DeleteByScriptId 

func (_mock *MockGlobalInitScriptsInterface) DeleteByScriptId(ctx context.Context, scriptId string) error

DeleteByScriptId provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) EXPECT 

func (_m *MockGlobalInitScriptsInterface) EXPECT() *MockGlobalInitScriptsInterface_Expecter

func (*MockGlobalInitScriptsInterface) Get 

func (_mock *MockGlobalInitScriptsInterface) Get(ctx context.Context, request compute.GetGlobalInitScriptRequest) (*compute.GlobalInitScriptDetailsWithContent, error)

Get provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) GetByName 

func (_mock *MockGlobalInitScriptsInterface) GetByName(ctx context.Context, name string) (*compute.GlobalInitScriptDetails, error)

GetByName provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) GetByScriptId 

func (_mock *MockGlobalInitScriptsInterface) GetByScriptId(ctx context.Context, scriptId string) (*compute.GlobalInitScriptDetailsWithContent, error)

GetByScriptId provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) GlobalInitScriptDetailsNameToScriptIdMap 

func (_mock *MockGlobalInitScriptsInterface) GlobalInitScriptDetailsNameToScriptIdMap(ctx context.Context) (map[string]string, error)

GlobalInitScriptDetailsNameToScriptIdMap provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) List 

func (_mock *MockGlobalInitScriptsInterface) List(ctx context.Context) listing.Iterator[compute.GlobalInitScriptDetails]

List provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) ListAll 

func (_mock *MockGlobalInitScriptsInterface) ListAll(ctx context.Context) ([]compute.GlobalInitScriptDetails, error)

ListAll provides a mock function for the type MockGlobalInitScriptsInterface

func (*MockGlobalInitScriptsInterface) Update 

func (_mock *MockGlobalInitScriptsInterface) Update(ctx context.Context, request compute.GlobalInitScriptUpdateRequest) error

Update provides a mock function for the type MockGlobalInitScriptsInterface

type MockGlobalInitScriptsInterface_Create_Call 

type MockGlobalInitScriptsInterface_Create_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockGlobalInitScriptsInterface_Create_Call) Return 

func (_c *MockGlobalInitScriptsInterface_Create_Call) Return(createResponse *compute.CreateResponse, err error) *MockGlobalInitScriptsInterface_Create_Call

func (*MockGlobalInitScriptsInterface_Create_Call) Run 

func (_c *MockGlobalInitScriptsInterface_Create_Call) Run(run func(ctx context.Context, request compute.GlobalInitScriptCreateRequest)) *MockGlobalInitScriptsInterface_Create_Call

func (*MockGlobalInitScriptsInterface_Create_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_Create_Call) RunAndReturn(run func(ctx context.Context, request compute.GlobalInitScriptCreateRequest) (*compute.CreateResponse, error)) *MockGlobalInitScriptsInterface_Create_Call

type MockGlobalInitScriptsInterface_DeleteByScriptId_Call 

type MockGlobalInitScriptsInterface_DeleteByScriptId_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_DeleteByScriptId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByScriptId'

func (*MockGlobalInitScriptsInterface_DeleteByScriptId_Call) Return 

func (_c *MockGlobalInitScriptsInterface_DeleteByScriptId_Call) Return(err error) *MockGlobalInitScriptsInterface_DeleteByScriptId_Call

func (*MockGlobalInitScriptsInterface_DeleteByScriptId_Call) Run 

func (_c *MockGlobalInitScriptsInterface_DeleteByScriptId_Call) Run(run func(ctx context.Context, scriptId string)) *MockGlobalInitScriptsInterface_DeleteByScriptId_Call

func (*MockGlobalInitScriptsInterface_DeleteByScriptId_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_DeleteByScriptId_Call) RunAndReturn(run func(ctx context.Context, scriptId string) error) *MockGlobalInitScriptsInterface_DeleteByScriptId_Call

type MockGlobalInitScriptsInterface_Delete_Call 

type MockGlobalInitScriptsInterface_Delete_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockGlobalInitScriptsInterface_Delete_Call) Return 

func (_c *MockGlobalInitScriptsInterface_Delete_Call) Return(err error) *MockGlobalInitScriptsInterface_Delete_Call

func (*MockGlobalInitScriptsInterface_Delete_Call) Run 

func (_c *MockGlobalInitScriptsInterface_Delete_Call) Run(run func(ctx context.Context, request compute.DeleteGlobalInitScriptRequest)) *MockGlobalInitScriptsInterface_Delete_Call

func (*MockGlobalInitScriptsInterface_Delete_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_Delete_Call) RunAndReturn(run func(ctx context.Context, request compute.DeleteGlobalInitScriptRequest) error) *MockGlobalInitScriptsInterface_Delete_Call

type MockGlobalInitScriptsInterface_Expecter 

type MockGlobalInitScriptsInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockGlobalInitScriptsInterface_Expecter) Create 

func (_e *MockGlobalInitScriptsInterface_Expecter) Create(ctx any, request any) *MockGlobalInitScriptsInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GlobalInitScriptCreateRequest

func (*MockGlobalInitScriptsInterface_Expecter) Delete 

func (_e *MockGlobalInitScriptsInterface_Expecter) Delete(ctx any, request any) *MockGlobalInitScriptsInterface_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • request compute.DeleteGlobalInitScriptRequest

func (*MockGlobalInitScriptsInterface_Expecter) DeleteByScriptId 

func (_e *MockGlobalInitScriptsInterface_Expecter) DeleteByScriptId(ctx any, scriptId any) *MockGlobalInitScriptsInterface_DeleteByScriptId_Call

DeleteByScriptId is a helper method to define mock.On call

  • ctx context.Context
  • scriptId string

func (*MockGlobalInitScriptsInterface_Expecter) Get 

func (_e *MockGlobalInitScriptsInterface_Expecter) Get(ctx any, request any) *MockGlobalInitScriptsInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetGlobalInitScriptRequest

func (*MockGlobalInitScriptsInterface_Expecter) GetByName 

func (_e *MockGlobalInitScriptsInterface_Expecter) GetByName(ctx any, name any) *MockGlobalInitScriptsInterface_GetByName_Call

GetByName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockGlobalInitScriptsInterface_Expecter) GetByScriptId 

func (_e *MockGlobalInitScriptsInterface_Expecter) GetByScriptId(ctx any, scriptId any) *MockGlobalInitScriptsInterface_GetByScriptId_Call

GetByScriptId is a helper method to define mock.On call

  • ctx context.Context
  • scriptId string

func (*MockGlobalInitScriptsInterface_Expecter) GlobalInitScriptDetailsNameToScriptIdMap 

func (_e *MockGlobalInitScriptsInterface_Expecter) GlobalInitScriptDetailsNameToScriptIdMap(ctx any) *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call

GlobalInitScriptDetailsNameToScriptIdMap is a helper method to define mock.On call

  • ctx context.Context

func (*MockGlobalInitScriptsInterface_Expecter) List 

func (_e *MockGlobalInitScriptsInterface_Expecter) List(ctx any) *MockGlobalInitScriptsInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context

func (*MockGlobalInitScriptsInterface_Expecter) ListAll 

func (_e *MockGlobalInitScriptsInterface_Expecter) ListAll(ctx any) *MockGlobalInitScriptsInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context

func (*MockGlobalInitScriptsInterface_Expecter) Update 

func (_e *MockGlobalInitScriptsInterface_Expecter) Update(ctx any, request any) *MockGlobalInitScriptsInterface_Update_Call

Update is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GlobalInitScriptUpdateRequest

type MockGlobalInitScriptsInterface_GetByName_Call 

type MockGlobalInitScriptsInterface_GetByName_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_GetByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByName'

func (*MockGlobalInitScriptsInterface_GetByName_Call) Return 

func (_c *MockGlobalInitScriptsInterface_GetByName_Call) Return(globalInitScriptDetails *compute.GlobalInitScriptDetails, err error) *MockGlobalInitScriptsInterface_GetByName_Call

func (*MockGlobalInitScriptsInterface_GetByName_Call) Run 

func (_c *MockGlobalInitScriptsInterface_GetByName_Call) Run(run func(ctx context.Context, name string)) *MockGlobalInitScriptsInterface_GetByName_Call

func (*MockGlobalInitScriptsInterface_GetByName_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_GetByName_Call) RunAndReturn(run func(ctx context.Context, name string) (*compute.GlobalInitScriptDetails, error)) *MockGlobalInitScriptsInterface_GetByName_Call

type MockGlobalInitScriptsInterface_GetByScriptId_Call 

type MockGlobalInitScriptsInterface_GetByScriptId_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_GetByScriptId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByScriptId'

func (*MockGlobalInitScriptsInterface_GetByScriptId_Call) Return 

func (_c *MockGlobalInitScriptsInterface_GetByScriptId_Call) Return(globalInitScriptDetailsWithContent *compute.GlobalInitScriptDetailsWithContent, err error) *MockGlobalInitScriptsInterface_GetByScriptId_Call

func (*MockGlobalInitScriptsInterface_GetByScriptId_Call) Run 

func (_c *MockGlobalInitScriptsInterface_GetByScriptId_Call) Run(run func(ctx context.Context, scriptId string)) *MockGlobalInitScriptsInterface_GetByScriptId_Call

func (*MockGlobalInitScriptsInterface_GetByScriptId_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_GetByScriptId_Call) RunAndReturn(run func(ctx context.Context, scriptId string) (*compute.GlobalInitScriptDetailsWithContent, error)) *MockGlobalInitScriptsInterface_GetByScriptId_Call

type MockGlobalInitScriptsInterface_Get_Call 

type MockGlobalInitScriptsInterface_Get_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockGlobalInitScriptsInterface_Get_Call) Return 

func (_c *MockGlobalInitScriptsInterface_Get_Call) Return(globalInitScriptDetailsWithContent *compute.GlobalInitScriptDetailsWithContent, err error) *MockGlobalInitScriptsInterface_Get_Call

func (*MockGlobalInitScriptsInterface_Get_Call) Run 

func (_c *MockGlobalInitScriptsInterface_Get_Call) Run(run func(ctx context.Context, request compute.GetGlobalInitScriptRequest)) *MockGlobalInitScriptsInterface_Get_Call

func (*MockGlobalInitScriptsInterface_Get_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_Get_Call) RunAndReturn(run func(ctx context.Context, request compute.GetGlobalInitScriptRequest) (*compute.GlobalInitScriptDetailsWithContent, error)) *MockGlobalInitScriptsInterface_Get_Call

type MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call 

type MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GlobalInitScriptDetailsNameToScriptIdMap'

func (*MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call) Return 

func (_c *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call) Return(stringToString map[string]string, err error) *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call

func (*MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call) Run 

func (_c *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call) Run(run func(ctx context.Context)) *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call

func (*MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call) RunAndReturn(run func(ctx context.Context) (map[string]string, error)) *MockGlobalInitScriptsInterface_GlobalInitScriptDetailsNameToScriptIdMap_Call

type MockGlobalInitScriptsInterface_ListAll_Call 

type MockGlobalInitScriptsInterface_ListAll_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockGlobalInitScriptsInterface_ListAll_Call) Return 

func (_c *MockGlobalInitScriptsInterface_ListAll_Call) Return(globalInitScriptDetailss []compute.GlobalInitScriptDetails, err error) *MockGlobalInitScriptsInterface_ListAll_Call

func (*MockGlobalInitScriptsInterface_ListAll_Call) Run 

func (_c *MockGlobalInitScriptsInterface_ListAll_Call) Run(run func(ctx context.Context)) *MockGlobalInitScriptsInterface_ListAll_Call

func (*MockGlobalInitScriptsInterface_ListAll_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context) ([]compute.GlobalInitScriptDetails, error)) *MockGlobalInitScriptsInterface_ListAll_Call

type MockGlobalInitScriptsInterface_List_Call 

type MockGlobalInitScriptsInterface_List_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockGlobalInitScriptsInterface_List_Call) Return 

func (_c *MockGlobalInitScriptsInterface_List_Call) Return(iterator listing.Iterator[compute.GlobalInitScriptDetails]) *MockGlobalInitScriptsInterface_List_Call

func (*MockGlobalInitScriptsInterface_List_Call) Run 

func (_c *MockGlobalInitScriptsInterface_List_Call) Run(run func(ctx context.Context)) *MockGlobalInitScriptsInterface_List_Call

func (*MockGlobalInitScriptsInterface_List_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_List_Call) RunAndReturn(run func(ctx context.Context) listing.Iterator[compute.GlobalInitScriptDetails]) *MockGlobalInitScriptsInterface_List_Call

type MockGlobalInitScriptsInterface_Update_Call 

type MockGlobalInitScriptsInterface_Update_Call struct {
	*mock.Call
}

MockGlobalInitScriptsInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'

func (*MockGlobalInitScriptsInterface_Update_Call) Return 

func (_c *MockGlobalInitScriptsInterface_Update_Call) Return(err error) *MockGlobalInitScriptsInterface_Update_Call

func (*MockGlobalInitScriptsInterface_Update_Call) Run 

func (_c *MockGlobalInitScriptsInterface_Update_Call) Run(run func(ctx context.Context, request compute.GlobalInitScriptUpdateRequest)) *MockGlobalInitScriptsInterface_Update_Call

func (*MockGlobalInitScriptsInterface_Update_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_Update_Call) RunAndReturn(run func(ctx context.Context, request compute.GlobalInitScriptUpdateRequest) error) *MockGlobalInitScriptsInterface_Update_Call

type MockInstancePoolsInterface 

type MockInstancePoolsInterface struct {
	mock.Mock
}

MockInstancePoolsInterface is an autogenerated mock type for the InstancePoolsInterface type

func NewMockInstancePoolsInterface 

func NewMockInstancePoolsInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInstancePoolsInterface

NewMockInstancePoolsInterface creates a new instance of MockInstancePoolsInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInstancePoolsInterface) Create 

func (_mock *MockInstancePoolsInterface) Create(ctx context.Context, request compute.CreateInstancePool) (*compute.CreateInstancePoolResponse, error)

Create provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) Delete 

func (_mock *MockInstancePoolsInterface) Delete(ctx context.Context, request compute.DeleteInstancePool) error

Delete provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) DeleteByInstancePoolId 

func (_mock *MockInstancePoolsInterface) DeleteByInstancePoolId(ctx context.Context, instancePoolId string) error

DeleteByInstancePoolId provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) EXPECT 

func (_m *MockInstancePoolsInterface) EXPECT() *MockInstancePoolsInterface_Expecter

func (*MockInstancePoolsInterface) Edit 

func (_mock *MockInstancePoolsInterface) Edit(ctx context.Context, request compute.EditInstancePool) error

Edit provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) Get 

func (_mock *MockInstancePoolsInterface) Get(ctx context.Context, request compute.GetInstancePoolRequest) (*compute.GetInstancePool, error)

Get provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) GetByInstancePoolId 

func (_mock *MockInstancePoolsInterface) GetByInstancePoolId(ctx context.Context, instancePoolId string) (*compute.GetInstancePool, error)

GetByInstancePoolId provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) GetByInstancePoolName 

func (_mock *MockInstancePoolsInterface) GetByInstancePoolName(ctx context.Context, name string) (*compute.InstancePoolAndStats, error)

GetByInstancePoolName provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) GetPermissionLevels 

func (_mock *MockInstancePoolsInterface) GetPermissionLevels(ctx context.Context, request compute.GetInstancePoolPermissionLevelsRequest) (*compute.GetInstancePoolPermissionLevelsResponse, error)

GetPermissionLevels provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) GetPermissionLevelsByInstancePoolId 

func (_mock *MockInstancePoolsInterface) GetPermissionLevelsByInstancePoolId(ctx context.Context, instancePoolId string) (*compute.GetInstancePoolPermissionLevelsResponse, error)

GetPermissionLevelsByInstancePoolId provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) GetPermissions 

func (_mock *MockInstancePoolsInterface) GetPermissions(ctx context.Context, request compute.GetInstancePoolPermissionsRequest) (*compute.InstancePoolPermissions, error)

GetPermissions provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) GetPermissionsByInstancePoolId 

func (_mock *MockInstancePoolsInterface) GetPermissionsByInstancePoolId(ctx context.Context, instancePoolId string) (*compute.InstancePoolPermissions, error)

GetPermissionsByInstancePoolId provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap 

func (_mock *MockInstancePoolsInterface) InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap(ctx context.Context) (map[string]string, error)

InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) List 

func (_mock *MockInstancePoolsInterface) List(ctx context.Context) listing.Iterator[compute.InstancePoolAndStats]

List provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) ListAll 

func (_mock *MockInstancePoolsInterface) ListAll(ctx context.Context) ([]compute.InstancePoolAndStats, error)

ListAll provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) SetPermissions 

func (_mock *MockInstancePoolsInterface) SetPermissions(ctx context.Context, request compute.InstancePoolPermissionsRequest) (*compute.InstancePoolPermissions, error)

SetPermissions provides a mock function for the type MockInstancePoolsInterface

func (*MockInstancePoolsInterface) UpdatePermissions 

func (_mock *MockInstancePoolsInterface) UpdatePermissions(ctx context.Context, request compute.InstancePoolPermissionsRequest) (*compute.InstancePoolPermissions, error)

UpdatePermissions provides a mock function for the type MockInstancePoolsInterface

type MockInstancePoolsInterface_Create_Call 

type MockInstancePoolsInterface_Create_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockInstancePoolsInterface_Create_Call) Return 

func (_c *MockInstancePoolsInterface_Create_Call) Return(createInstancePoolResponse *compute.CreateInstancePoolResponse, err error) *MockInstancePoolsInterface_Create_Call

func (*MockInstancePoolsInterface_Create_Call) Run 

func (_c *MockInstancePoolsInterface_Create_Call) Run(run func(ctx context.Context, request compute.CreateInstancePool)) *MockInstancePoolsInterface_Create_Call

func (*MockInstancePoolsInterface_Create_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_Create_Call) RunAndReturn(run func(ctx context.Context, request compute.CreateInstancePool) (*compute.CreateInstancePoolResponse, error)) *MockInstancePoolsInterface_Create_Call

type MockInstancePoolsInterface_DeleteByInstancePoolId_Call 

type MockInstancePoolsInterface_DeleteByInstancePoolId_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_DeleteByInstancePoolId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteByInstancePoolId'

func (*MockInstancePoolsInterface_DeleteByInstancePoolId_Call) Return 

func (_c *MockInstancePoolsInterface_DeleteByInstancePoolId_Call) Return(err error) *MockInstancePoolsInterface_DeleteByInstancePoolId_Call

func (*MockInstancePoolsInterface_DeleteByInstancePoolId_Call) Run 

func (_c *MockInstancePoolsInterface_DeleteByInstancePoolId_Call) Run(run func(ctx context.Context, instancePoolId string)) *MockInstancePoolsInterface_DeleteByInstancePoolId_Call

func (*MockInstancePoolsInterface_DeleteByInstancePoolId_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_DeleteByInstancePoolId_Call) RunAndReturn(run func(ctx context.Context, instancePoolId string) error) *MockInstancePoolsInterface_DeleteByInstancePoolId_Call

type MockInstancePoolsInterface_Delete_Call 

type MockInstancePoolsInterface_Delete_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'

func (*MockInstancePoolsInterface_Delete_Call) Return 

func (_c *MockInstancePoolsInterface_Delete_Call) Return(err error) *MockInstancePoolsInterface_Delete_Call

func (*MockInstancePoolsInterface_Delete_Call) Run 

func (_c *MockInstancePoolsInterface_Delete_Call) Run(run func(ctx context.Context, request compute.DeleteInstancePool)) *MockInstancePoolsInterface_Delete_Call

func (*MockInstancePoolsInterface_Delete_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_Delete_Call) RunAndReturn(run func(ctx context.Context, request compute.DeleteInstancePool) error) *MockInstancePoolsInterface_Delete_Call

type MockInstancePoolsInterface_Edit_Call 

type MockInstancePoolsInterface_Edit_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_Edit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Edit'

func (*MockInstancePoolsInterface_Edit_Call) Return 

func (_c *MockInstancePoolsInterface_Edit_Call) Return(err error) *MockInstancePoolsInterface_Edit_Call

func (*MockInstancePoolsInterface_Edit_Call) Run 

func (_c *MockInstancePoolsInterface_Edit_Call) Run(run func(ctx context.Context, request compute.EditInstancePool)) *MockInstancePoolsInterface_Edit_Call

func (*MockInstancePoolsInterface_Edit_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_Edit_Call) RunAndReturn(run func(ctx context.Context, request compute.EditInstancePool) error) *MockInstancePoolsInterface_Edit_Call

type MockInstancePoolsInterface_Expecter 

type MockInstancePoolsInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInstancePoolsInterface_Expecter) Create 

func (_e *MockInstancePoolsInterface_Expecter) Create(ctx any, request any) *MockInstancePoolsInterface_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • request compute.CreateInstancePool

func (*MockInstancePoolsInterface_Expecter) Delete 

func (_e *MockInstancePoolsInterface_Expecter) Delete(ctx any, request any) *MockInstancePoolsInterface_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • request compute.DeleteInstancePool

func (*MockInstancePoolsInterface_Expecter) DeleteByInstancePoolId 

func (_e *MockInstancePoolsInterface_Expecter) DeleteByInstancePoolId(ctx any, instancePoolId any) *MockInstancePoolsInterface_DeleteByInstancePoolId_Call

DeleteByInstancePoolId is a helper method to define mock.On call

  • ctx context.Context
  • instancePoolId string

func (*MockInstancePoolsInterface_Expecter) Edit 

func (_e *MockInstancePoolsInterface_Expecter) Edit(ctx any, request any) *MockInstancePoolsInterface_Edit_Call

Edit is a helper method to define mock.On call

  • ctx context.Context
  • request compute.EditInstancePool

func (*MockInstancePoolsInterface_Expecter) Get 

func (_e *MockInstancePoolsInterface_Expecter) Get(ctx any, request any) *MockInstancePoolsInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetInstancePoolRequest

func (*MockInstancePoolsInterface_Expecter) GetByInstancePoolId 

func (_e *MockInstancePoolsInterface_Expecter) GetByInstancePoolId(ctx any, instancePoolId any) *MockInstancePoolsInterface_GetByInstancePoolId_Call

GetByInstancePoolId is a helper method to define mock.On call

  • ctx context.Context
  • instancePoolId string

func (*MockInstancePoolsInterface_Expecter) GetByInstancePoolName 

func (_e *MockInstancePoolsInterface_Expecter) GetByInstancePoolName(ctx any, name any) *MockInstancePoolsInterface_GetByInstancePoolName_Call

GetByInstancePoolName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockInstancePoolsInterface_Expecter) GetPermissionLevels 

func (_e *MockInstancePoolsInterface_Expecter) GetPermissionLevels(ctx any, request any) *MockInstancePoolsInterface_GetPermissionLevels_Call

GetPermissionLevels is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetInstancePoolPermissionLevelsRequest

func (*MockInstancePoolsInterface_Expecter) GetPermissionLevelsByInstancePoolId 

func (_e *MockInstancePoolsInterface_Expecter) GetPermissionLevelsByInstancePoolId(ctx any, instancePoolId any) *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call

GetPermissionLevelsByInstancePoolId is a helper method to define mock.On call

  • ctx context.Context
  • instancePoolId string

func (*MockInstancePoolsInterface_Expecter) GetPermissions 

func (_e *MockInstancePoolsInterface_Expecter) GetPermissions(ctx any, request any) *MockInstancePoolsInterface_GetPermissions_Call

GetPermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetInstancePoolPermissionsRequest

func (*MockInstancePoolsInterface_Expecter) GetPermissionsByInstancePoolId 

func (_e *MockInstancePoolsInterface_Expecter) GetPermissionsByInstancePoolId(ctx any, instancePoolId any) *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call

GetPermissionsByInstancePoolId is a helper method to define mock.On call

  • ctx context.Context
  • instancePoolId string

func (*MockInstancePoolsInterface_Expecter) InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap 

func (_e *MockInstancePoolsInterface_Expecter) InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap(ctx any) *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call

InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap is a helper method to define mock.On call

  • ctx context.Context

func (*MockInstancePoolsInterface_Expecter) List 

func (_e *MockInstancePoolsInterface_Expecter) List(ctx any) *MockInstancePoolsInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context

func (*MockInstancePoolsInterface_Expecter) ListAll 

func (_e *MockInstancePoolsInterface_Expecter) ListAll(ctx any) *MockInstancePoolsInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context

func (*MockInstancePoolsInterface_Expecter) SetPermissions 

func (_e *MockInstancePoolsInterface_Expecter) SetPermissions(ctx any, request any) *MockInstancePoolsInterface_SetPermissions_Call

SetPermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.InstancePoolPermissionsRequest

func (*MockInstancePoolsInterface_Expecter) UpdatePermissions 

func (_e *MockInstancePoolsInterface_Expecter) UpdatePermissions(ctx any, request any) *MockInstancePoolsInterface_UpdatePermissions_Call

UpdatePermissions is a helper method to define mock.On call

  • ctx context.Context
  • request compute.InstancePoolPermissionsRequest

type MockInstancePoolsInterface_GetByInstancePoolId_Call 

type MockInstancePoolsInterface_GetByInstancePoolId_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_GetByInstancePoolId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByInstancePoolId'

func (*MockInstancePoolsInterface_GetByInstancePoolId_Call) Return 

func (_c *MockInstancePoolsInterface_GetByInstancePoolId_Call) Return(getInstancePool *compute.GetInstancePool, err error) *MockInstancePoolsInterface_GetByInstancePoolId_Call

func (*MockInstancePoolsInterface_GetByInstancePoolId_Call) Run 

func (_c *MockInstancePoolsInterface_GetByInstancePoolId_Call) Run(run func(ctx context.Context, instancePoolId string)) *MockInstancePoolsInterface_GetByInstancePoolId_Call

func (*MockInstancePoolsInterface_GetByInstancePoolId_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_GetByInstancePoolId_Call) RunAndReturn(run func(ctx context.Context, instancePoolId string) (*compute.GetInstancePool, error)) *MockInstancePoolsInterface_GetByInstancePoolId_Call

type MockInstancePoolsInterface_GetByInstancePoolName_Call 

type MockInstancePoolsInterface_GetByInstancePoolName_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_GetByInstancePoolName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByInstancePoolName'

func (*MockInstancePoolsInterface_GetByInstancePoolName_Call) Return 

func (_c *MockInstancePoolsInterface_GetByInstancePoolName_Call) Return(instancePoolAndStats *compute.InstancePoolAndStats, err error) *MockInstancePoolsInterface_GetByInstancePoolName_Call

func (*MockInstancePoolsInterface_GetByInstancePoolName_Call) Run 

func (_c *MockInstancePoolsInterface_GetByInstancePoolName_Call) Run(run func(ctx context.Context, name string)) *MockInstancePoolsInterface_GetByInstancePoolName_Call

func (*MockInstancePoolsInterface_GetByInstancePoolName_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_GetByInstancePoolName_Call) RunAndReturn(run func(ctx context.Context, name string) (*compute.InstancePoolAndStats, error)) *MockInstancePoolsInterface_GetByInstancePoolName_Call

type MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call 

type MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevelsByInstancePoolId'

func (*MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call) Return 

func (_c *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call) Return(getInstancePoolPermissionLevelsResponse *compute.GetInstancePoolPermissionLevelsResponse, err error) *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call

func (*MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call) Run 

func (_c *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call) Run(run func(ctx context.Context, instancePoolId string)) *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call

func (*MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call) RunAndReturn(run func(ctx context.Context, instancePoolId string) (*compute.GetInstancePoolPermissionLevelsResponse, error)) *MockInstancePoolsInterface_GetPermissionLevelsByInstancePoolId_Call

type MockInstancePoolsInterface_GetPermissionLevels_Call 

type MockInstancePoolsInterface_GetPermissionLevels_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_GetPermissionLevels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionLevels'

func (*MockInstancePoolsInterface_GetPermissionLevels_Call) Return 

func (_c *MockInstancePoolsInterface_GetPermissionLevels_Call) Return(getInstancePoolPermissionLevelsResponse *compute.GetInstancePoolPermissionLevelsResponse, err error) *MockInstancePoolsInterface_GetPermissionLevels_Call

func (*MockInstancePoolsInterface_GetPermissionLevels_Call) Run 

func (_c *MockInstancePoolsInterface_GetPermissionLevels_Call) Run(run func(ctx context.Context, request compute.GetInstancePoolPermissionLevelsRequest)) *MockInstancePoolsInterface_GetPermissionLevels_Call

func (*MockInstancePoolsInterface_GetPermissionLevels_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_GetPermissionLevels_Call) RunAndReturn(run func(ctx context.Context, request compute.GetInstancePoolPermissionLevelsRequest) (*compute.GetInstancePoolPermissionLevelsResponse, error)) *MockInstancePoolsInterface_GetPermissionLevels_Call

type MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call 

type MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissionsByInstancePoolId'

func (*MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call) Return 

func (_c *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call) Return(instancePoolPermissions *compute.InstancePoolPermissions, err error) *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call

func (*MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call) Run 

func (_c *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call) Run(run func(ctx context.Context, instancePoolId string)) *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call

func (*MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call) RunAndReturn(run func(ctx context.Context, instancePoolId string) (*compute.InstancePoolPermissions, error)) *MockInstancePoolsInterface_GetPermissionsByInstancePoolId_Call

type MockInstancePoolsInterface_GetPermissions_Call 

type MockInstancePoolsInterface_GetPermissions_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_GetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPermissions'

func (*MockInstancePoolsInterface_GetPermissions_Call) Return 

func (_c *MockInstancePoolsInterface_GetPermissions_Call) Return(instancePoolPermissions *compute.InstancePoolPermissions, err error) *MockInstancePoolsInterface_GetPermissions_Call

func (*MockInstancePoolsInterface_GetPermissions_Call) Run 

func (_c *MockInstancePoolsInterface_GetPermissions_Call) Run(run func(ctx context.Context, request compute.GetInstancePoolPermissionsRequest)) *MockInstancePoolsInterface_GetPermissions_Call

func (*MockInstancePoolsInterface_GetPermissions_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_GetPermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.GetInstancePoolPermissionsRequest) (*compute.InstancePoolPermissions, error)) *MockInstancePoolsInterface_GetPermissions_Call

type MockInstancePoolsInterface_Get_Call 

type MockInstancePoolsInterface_Get_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockInstancePoolsInterface_Get_Call) Return 

func (_c *MockInstancePoolsInterface_Get_Call) Return(getInstancePool *compute.GetInstancePool, err error) *MockInstancePoolsInterface_Get_Call

func (*MockInstancePoolsInterface_Get_Call) Run 

func (_c *MockInstancePoolsInterface_Get_Call) Run(run func(ctx context.Context, request compute.GetInstancePoolRequest)) *MockInstancePoolsInterface_Get_Call

func (*MockInstancePoolsInterface_Get_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_Get_Call) RunAndReturn(run func(ctx context.Context, request compute.GetInstancePoolRequest) (*compute.GetInstancePool, error)) *MockInstancePoolsInterface_Get_Call

type MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call 

type MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap'

func (*MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call) Return 

func (_c *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call) Return(stringToString map[string]string, err error) *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call

func (*MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call) Run 

func (_c *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call) Run(run func(ctx context.Context)) *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call

func (*MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call) RunAndReturn(run func(ctx context.Context) (map[string]string, error)) *MockInstancePoolsInterface_InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap_Call

type MockInstancePoolsInterface_ListAll_Call 

type MockInstancePoolsInterface_ListAll_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockInstancePoolsInterface_ListAll_Call) Return 

func (_c *MockInstancePoolsInterface_ListAll_Call) Return(instancePoolAndStatss []compute.InstancePoolAndStats, err error) *MockInstancePoolsInterface_ListAll_Call

func (*MockInstancePoolsInterface_ListAll_Call) Run 

func (_c *MockInstancePoolsInterface_ListAll_Call) Run(run func(ctx context.Context)) *MockInstancePoolsInterface_ListAll_Call

func (*MockInstancePoolsInterface_ListAll_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context) ([]compute.InstancePoolAndStats, error)) *MockInstancePoolsInterface_ListAll_Call

type MockInstancePoolsInterface_List_Call 

type MockInstancePoolsInterface_List_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockInstancePoolsInterface_List_Call) Return 

func (_c *MockInstancePoolsInterface_List_Call) Return(iterator listing.Iterator[compute.InstancePoolAndStats]) *MockInstancePoolsInterface_List_Call

func (*MockInstancePoolsInterface_List_Call) Run 

func (_c *MockInstancePoolsInterface_List_Call) Run(run func(ctx context.Context)) *MockInstancePoolsInterface_List_Call

func (*MockInstancePoolsInterface_List_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_List_Call) RunAndReturn(run func(ctx context.Context) listing.Iterator[compute.InstancePoolAndStats]) *MockInstancePoolsInterface_List_Call

type MockInstancePoolsInterface_SetPermissions_Call 

type MockInstancePoolsInterface_SetPermissions_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_SetPermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPermissions'

func (*MockInstancePoolsInterface_SetPermissions_Call) Return 

func (_c *MockInstancePoolsInterface_SetPermissions_Call) Return(instancePoolPermissions *compute.InstancePoolPermissions, err error) *MockInstancePoolsInterface_SetPermissions_Call

func (*MockInstancePoolsInterface_SetPermissions_Call) Run 

func (_c *MockInstancePoolsInterface_SetPermissions_Call) Run(run func(ctx context.Context, request compute.InstancePoolPermissionsRequest)) *MockInstancePoolsInterface_SetPermissions_Call

func (*MockInstancePoolsInterface_SetPermissions_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_SetPermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.InstancePoolPermissionsRequest) (*compute.InstancePoolPermissions, error)) *MockInstancePoolsInterface_SetPermissions_Call

type MockInstancePoolsInterface_UpdatePermissions_Call 

type MockInstancePoolsInterface_UpdatePermissions_Call struct {
	*mock.Call
}

MockInstancePoolsInterface_UpdatePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePermissions'

func (*MockInstancePoolsInterface_UpdatePermissions_Call) Return 

func (_c *MockInstancePoolsInterface_UpdatePermissions_Call) Return(instancePoolPermissions *compute.InstancePoolPermissions, err error) *MockInstancePoolsInterface_UpdatePermissions_Call

func (*MockInstancePoolsInterface_UpdatePermissions_Call) Run 

func (_c *MockInstancePoolsInterface_UpdatePermissions_Call) Run(run func(ctx context.Context, request compute.InstancePoolPermissionsRequest)) *MockInstancePoolsInterface_UpdatePermissions_Call

func (*MockInstancePoolsInterface_UpdatePermissions_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_UpdatePermissions_Call) RunAndReturn(run func(ctx context.Context, request compute.InstancePoolPermissionsRequest) (*compute.InstancePoolPermissions, error)) *MockInstancePoolsInterface_UpdatePermissions_Call

type MockInstanceProfilesInterface 

type MockInstanceProfilesInterface struct {
	mock.Mock
}

MockInstanceProfilesInterface is an autogenerated mock type for the InstanceProfilesInterface type

func NewMockInstanceProfilesInterface 

func NewMockInstanceProfilesInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInstanceProfilesInterface

NewMockInstanceProfilesInterface creates a new instance of MockInstanceProfilesInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockInstanceProfilesInterface) Add 

func (_mock *MockInstanceProfilesInterface) Add(ctx context.Context, request compute.AddInstanceProfile) error

Add provides a mock function for the type MockInstanceProfilesInterface

func (*MockInstanceProfilesInterface) EXPECT 

func (_m *MockInstanceProfilesInterface) EXPECT() *MockInstanceProfilesInterface_Expecter

func (*MockInstanceProfilesInterface) Edit 

func (_mock *MockInstanceProfilesInterface) Edit(ctx context.Context, request compute.InstanceProfile) error

Edit provides a mock function for the type MockInstanceProfilesInterface

func (*MockInstanceProfilesInterface) List 

func (_mock *MockInstanceProfilesInterface) List(ctx context.Context) listing.Iterator[compute.InstanceProfile]

List provides a mock function for the type MockInstanceProfilesInterface

func (*MockInstanceProfilesInterface) ListAll 

func (_mock *MockInstanceProfilesInterface) ListAll(ctx context.Context) ([]compute.InstanceProfile, error)

ListAll provides a mock function for the type MockInstanceProfilesInterface

func (*MockInstanceProfilesInterface) Remove 

func (_mock *MockInstanceProfilesInterface) Remove(ctx context.Context, request compute.RemoveInstanceProfile) error

Remove provides a mock function for the type MockInstanceProfilesInterface

func (*MockInstanceProfilesInterface) RemoveByInstanceProfileArn 

func (_mock *MockInstanceProfilesInterface) RemoveByInstanceProfileArn(ctx context.Context, instanceProfileArn string) error

RemoveByInstanceProfileArn provides a mock function for the type MockInstanceProfilesInterface

type MockInstanceProfilesInterface_Add_Call 

type MockInstanceProfilesInterface_Add_Call struct {
	*mock.Call
}

MockInstanceProfilesInterface_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'

func (*MockInstanceProfilesInterface_Add_Call) Return 

func (_c *MockInstanceProfilesInterface_Add_Call) Return(err error) *MockInstanceProfilesInterface_Add_Call

func (*MockInstanceProfilesInterface_Add_Call) Run 

func (_c *MockInstanceProfilesInterface_Add_Call) Run(run func(ctx context.Context, request compute.AddInstanceProfile)) *MockInstanceProfilesInterface_Add_Call

func (*MockInstanceProfilesInterface_Add_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_Add_Call) RunAndReturn(run func(ctx context.Context, request compute.AddInstanceProfile) error) *MockInstanceProfilesInterface_Add_Call

type MockInstanceProfilesInterface_Edit_Call 

type MockInstanceProfilesInterface_Edit_Call struct {
	*mock.Call
}

MockInstanceProfilesInterface_Edit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Edit'

func (*MockInstanceProfilesInterface_Edit_Call) Return 

func (_c *MockInstanceProfilesInterface_Edit_Call) Return(err error) *MockInstanceProfilesInterface_Edit_Call

func (*MockInstanceProfilesInterface_Edit_Call) Run 

func (_c *MockInstanceProfilesInterface_Edit_Call) Run(run func(ctx context.Context, request compute.InstanceProfile)) *MockInstanceProfilesInterface_Edit_Call

func (*MockInstanceProfilesInterface_Edit_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_Edit_Call) RunAndReturn(run func(ctx context.Context, request compute.InstanceProfile) error) *MockInstanceProfilesInterface_Edit_Call

type MockInstanceProfilesInterface_Expecter 

type MockInstanceProfilesInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInstanceProfilesInterface_Expecter) Add 

func (_e *MockInstanceProfilesInterface_Expecter) Add(ctx any, request any) *MockInstanceProfilesInterface_Add_Call

Add is a helper method to define mock.On call

  • ctx context.Context
  • request compute.AddInstanceProfile

func (*MockInstanceProfilesInterface_Expecter) Edit 

func (_e *MockInstanceProfilesInterface_Expecter) Edit(ctx any, request any) *MockInstanceProfilesInterface_Edit_Call

Edit is a helper method to define mock.On call

  • ctx context.Context
  • request compute.InstanceProfile

func (*MockInstanceProfilesInterface_Expecter) List 

func (_e *MockInstanceProfilesInterface_Expecter) List(ctx any) *MockInstanceProfilesInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context

func (*MockInstanceProfilesInterface_Expecter) ListAll 

func (_e *MockInstanceProfilesInterface_Expecter) ListAll(ctx any) *MockInstanceProfilesInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context

func (*MockInstanceProfilesInterface_Expecter) Remove 

func (_e *MockInstanceProfilesInterface_Expecter) Remove(ctx any, request any) *MockInstanceProfilesInterface_Remove_Call

Remove is a helper method to define mock.On call

  • ctx context.Context
  • request compute.RemoveInstanceProfile

func (*MockInstanceProfilesInterface_Expecter) RemoveByInstanceProfileArn 

func (_e *MockInstanceProfilesInterface_Expecter) RemoveByInstanceProfileArn(ctx any, instanceProfileArn any) *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call

RemoveByInstanceProfileArn is a helper method to define mock.On call

  • ctx context.Context
  • instanceProfileArn string

type MockInstanceProfilesInterface_ListAll_Call 

type MockInstanceProfilesInterface_ListAll_Call struct {
	*mock.Call
}

MockInstanceProfilesInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockInstanceProfilesInterface_ListAll_Call) Return 

func (_c *MockInstanceProfilesInterface_ListAll_Call) Return(instanceProfiles []compute.InstanceProfile, err error) *MockInstanceProfilesInterface_ListAll_Call

func (*MockInstanceProfilesInterface_ListAll_Call) Run 

func (_c *MockInstanceProfilesInterface_ListAll_Call) Run(run func(ctx context.Context)) *MockInstanceProfilesInterface_ListAll_Call

func (*MockInstanceProfilesInterface_ListAll_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context) ([]compute.InstanceProfile, error)) *MockInstanceProfilesInterface_ListAll_Call

type MockInstanceProfilesInterface_List_Call 

type MockInstanceProfilesInterface_List_Call struct {
	*mock.Call
}

MockInstanceProfilesInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockInstanceProfilesInterface_List_Call) Return 

func (_c *MockInstanceProfilesInterface_List_Call) Return(iterator listing.Iterator[compute.InstanceProfile]) *MockInstanceProfilesInterface_List_Call

func (*MockInstanceProfilesInterface_List_Call) Run 

func (_c *MockInstanceProfilesInterface_List_Call) Run(run func(ctx context.Context)) *MockInstanceProfilesInterface_List_Call

func (*MockInstanceProfilesInterface_List_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_List_Call) RunAndReturn(run func(ctx context.Context) listing.Iterator[compute.InstanceProfile]) *MockInstanceProfilesInterface_List_Call

type MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call 

type MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call struct {
	*mock.Call
}

MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveByInstanceProfileArn'

func (*MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call) Return 

func (_c *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call) Return(err error) *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call

func (*MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call) Run 

func (_c *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call) Run(run func(ctx context.Context, instanceProfileArn string)) *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call

func (*MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call) RunAndReturn(run func(ctx context.Context, instanceProfileArn string) error) *MockInstanceProfilesInterface_RemoveByInstanceProfileArn_Call

type MockInstanceProfilesInterface_Remove_Call 

type MockInstanceProfilesInterface_Remove_Call struct {
	*mock.Call
}

MockInstanceProfilesInterface_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'

func (*MockInstanceProfilesInterface_Remove_Call) Return 

func (_c *MockInstanceProfilesInterface_Remove_Call) Return(err error) *MockInstanceProfilesInterface_Remove_Call

func (*MockInstanceProfilesInterface_Remove_Call) Run 

func (_c *MockInstanceProfilesInterface_Remove_Call) Run(run func(ctx context.Context, request compute.RemoveInstanceProfile)) *MockInstanceProfilesInterface_Remove_Call

func (*MockInstanceProfilesInterface_Remove_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_Remove_Call) RunAndReturn(run func(ctx context.Context, request compute.RemoveInstanceProfile) error) *MockInstanceProfilesInterface_Remove_Call

type MockLibrariesInterface 

type MockLibrariesInterface struct {
	mock.Mock
}

MockLibrariesInterface is an autogenerated mock type for the LibrariesInterface type

func NewMockLibrariesInterface 

func NewMockLibrariesInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockLibrariesInterface

NewMockLibrariesInterface creates a new instance of MockLibrariesInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockLibrariesInterface) AllClusterStatuses 

func (_mock *MockLibrariesInterface) AllClusterStatuses(ctx context.Context) listing.Iterator[compute.ClusterLibraryStatuses]

AllClusterStatuses provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) AllClusterStatusesAll added in v0.41.0 

func (_mock *MockLibrariesInterface) AllClusterStatusesAll(ctx context.Context) ([]compute.ClusterLibraryStatuses, error)

AllClusterStatusesAll provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) ClusterStatus 

func (_mock *MockLibrariesInterface) ClusterStatus(ctx context.Context, request compute.ClusterStatus) listing.Iterator[compute.LibraryFullStatus]

ClusterStatus provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) ClusterStatusAll 

func (_mock *MockLibrariesInterface) ClusterStatusAll(ctx context.Context, request compute.ClusterStatus) ([]compute.LibraryFullStatus, error)

ClusterStatusAll provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) ClusterStatusByClusterId 

func (_mock *MockLibrariesInterface) ClusterStatusByClusterId(ctx context.Context, clusterId string) (*compute.ClusterLibraryStatuses, error)

ClusterStatusByClusterId provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) EXPECT 

func (_m *MockLibrariesInterface) EXPECT() *MockLibrariesInterface_Expecter

func (*MockLibrariesInterface) Install 

func (_mock *MockLibrariesInterface) Install(ctx context.Context, request compute.InstallLibraries) error

Install provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) Uninstall 

func (_mock *MockLibrariesInterface) Uninstall(ctx context.Context, request compute.UninstallLibraries) error

Uninstall provides a mock function for the type MockLibrariesInterface

func (*MockLibrariesInterface) UpdateAndWait 

func (_mock *MockLibrariesInterface) UpdateAndWait(ctx context.Context, update compute.Update, options ...retries.Option[compute.ClusterLibraryStatuses]) error

UpdateAndWait provides a mock function for the type MockLibrariesInterface

type MockLibrariesInterface_AllClusterStatusesAll_Call added in v0.41.0 

type MockLibrariesInterface_AllClusterStatusesAll_Call struct {
	*mock.Call
}

MockLibrariesInterface_AllClusterStatusesAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllClusterStatusesAll'

func (*MockLibrariesInterface_AllClusterStatusesAll_Call) Return added in v0.41.0 

func (_c *MockLibrariesInterface_AllClusterStatusesAll_Call) Return(clusterLibraryStatusess []compute.ClusterLibraryStatuses, err error) *MockLibrariesInterface_AllClusterStatusesAll_Call

func (*MockLibrariesInterface_AllClusterStatusesAll_Call) Run added in v0.41.0 

func (_c *MockLibrariesInterface_AllClusterStatusesAll_Call) Run(run func(ctx context.Context)) *MockLibrariesInterface_AllClusterStatusesAll_Call

func (*MockLibrariesInterface_AllClusterStatusesAll_Call) RunAndReturn added in v0.41.0 

func (_c *MockLibrariesInterface_AllClusterStatusesAll_Call) RunAndReturn(run func(ctx context.Context) ([]compute.ClusterLibraryStatuses, error)) *MockLibrariesInterface_AllClusterStatusesAll_Call

type MockLibrariesInterface_AllClusterStatuses_Call 

type MockLibrariesInterface_AllClusterStatuses_Call struct {
	*mock.Call
}

MockLibrariesInterface_AllClusterStatuses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AllClusterStatuses'

func (*MockLibrariesInterface_AllClusterStatuses_Call) Return 

func (_c *MockLibrariesInterface_AllClusterStatuses_Call) Return(iterator listing.Iterator[compute.ClusterLibraryStatuses]) *MockLibrariesInterface_AllClusterStatuses_Call

func (*MockLibrariesInterface_AllClusterStatuses_Call) Run 

func (_c *MockLibrariesInterface_AllClusterStatuses_Call) Run(run func(ctx context.Context)) *MockLibrariesInterface_AllClusterStatuses_Call

func (*MockLibrariesInterface_AllClusterStatuses_Call) RunAndReturn 

func (_c *MockLibrariesInterface_AllClusterStatuses_Call) RunAndReturn(run func(ctx context.Context) listing.Iterator[compute.ClusterLibraryStatuses]) *MockLibrariesInterface_AllClusterStatuses_Call

type MockLibrariesInterface_ClusterStatusAll_Call 

type MockLibrariesInterface_ClusterStatusAll_Call struct {
	*mock.Call
}

MockLibrariesInterface_ClusterStatusAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterStatusAll'

func (*MockLibrariesInterface_ClusterStatusAll_Call) Return 

func (_c *MockLibrariesInterface_ClusterStatusAll_Call) Return(libraryFullStatuss []compute.LibraryFullStatus, err error) *MockLibrariesInterface_ClusterStatusAll_Call

func (*MockLibrariesInterface_ClusterStatusAll_Call) Run 

func (_c *MockLibrariesInterface_ClusterStatusAll_Call) Run(run func(ctx context.Context, request compute.ClusterStatus)) *MockLibrariesInterface_ClusterStatusAll_Call

func (*MockLibrariesInterface_ClusterStatusAll_Call) RunAndReturn 

func (_c *MockLibrariesInterface_ClusterStatusAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ClusterStatus) ([]compute.LibraryFullStatus, error)) *MockLibrariesInterface_ClusterStatusAll_Call

type MockLibrariesInterface_ClusterStatusByClusterId_Call 

type MockLibrariesInterface_ClusterStatusByClusterId_Call struct {
	*mock.Call
}

MockLibrariesInterface_ClusterStatusByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterStatusByClusterId'

func (*MockLibrariesInterface_ClusterStatusByClusterId_Call) Return 

func (_c *MockLibrariesInterface_ClusterStatusByClusterId_Call) Return(clusterLibraryStatuses *compute.ClusterLibraryStatuses, err error) *MockLibrariesInterface_ClusterStatusByClusterId_Call

func (*MockLibrariesInterface_ClusterStatusByClusterId_Call) Run 

func (_c *MockLibrariesInterface_ClusterStatusByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockLibrariesInterface_ClusterStatusByClusterId_Call

func (*MockLibrariesInterface_ClusterStatusByClusterId_Call) RunAndReturn 

func (_c *MockLibrariesInterface_ClusterStatusByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) (*compute.ClusterLibraryStatuses, error)) *MockLibrariesInterface_ClusterStatusByClusterId_Call

type MockLibrariesInterface_ClusterStatus_Call 

type MockLibrariesInterface_ClusterStatus_Call struct {
	*mock.Call
}

MockLibrariesInterface_ClusterStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClusterStatus'

func (*MockLibrariesInterface_ClusterStatus_Call) Return 

func (_c *MockLibrariesInterface_ClusterStatus_Call) Return(iterator listing.Iterator[compute.LibraryFullStatus]) *MockLibrariesInterface_ClusterStatus_Call

func (*MockLibrariesInterface_ClusterStatus_Call) Run 

func (_c *MockLibrariesInterface_ClusterStatus_Call) Run(run func(ctx context.Context, request compute.ClusterStatus)) *MockLibrariesInterface_ClusterStatus_Call

func (*MockLibrariesInterface_ClusterStatus_Call) RunAndReturn 

func (_c *MockLibrariesInterface_ClusterStatus_Call) RunAndReturn(run func(ctx context.Context, request compute.ClusterStatus) listing.Iterator[compute.LibraryFullStatus]) *MockLibrariesInterface_ClusterStatus_Call

type MockLibrariesInterface_Expecter 

type MockLibrariesInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockLibrariesInterface_Expecter) AllClusterStatuses 

func (_e *MockLibrariesInterface_Expecter) AllClusterStatuses(ctx any) *MockLibrariesInterface_AllClusterStatuses_Call

AllClusterStatuses is a helper method to define mock.On call

  • ctx context.Context

func (*MockLibrariesInterface_Expecter) AllClusterStatusesAll added in v0.41.0 

func (_e *MockLibrariesInterface_Expecter) AllClusterStatusesAll(ctx any) *MockLibrariesInterface_AllClusterStatusesAll_Call

AllClusterStatusesAll is a helper method to define mock.On call

  • ctx context.Context

func (*MockLibrariesInterface_Expecter) ClusterStatus 

func (_e *MockLibrariesInterface_Expecter) ClusterStatus(ctx any, request any) *MockLibrariesInterface_ClusterStatus_Call

ClusterStatus is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ClusterStatus

func (*MockLibrariesInterface_Expecter) ClusterStatusAll 

func (_e *MockLibrariesInterface_Expecter) ClusterStatusAll(ctx any, request any) *MockLibrariesInterface_ClusterStatusAll_Call

ClusterStatusAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ClusterStatus

func (*MockLibrariesInterface_Expecter) ClusterStatusByClusterId 

func (_e *MockLibrariesInterface_Expecter) ClusterStatusByClusterId(ctx any, clusterId any) *MockLibrariesInterface_ClusterStatusByClusterId_Call

ClusterStatusByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockLibrariesInterface_Expecter) Install 

func (_e *MockLibrariesInterface_Expecter) Install(ctx any, request any) *MockLibrariesInterface_Install_Call

Install is a helper method to define mock.On call

  • ctx context.Context
  • request compute.InstallLibraries

func (*MockLibrariesInterface_Expecter) Uninstall 

func (_e *MockLibrariesInterface_Expecter) Uninstall(ctx any, request any) *MockLibrariesInterface_Uninstall_Call

Uninstall is a helper method to define mock.On call

  • ctx context.Context
  • request compute.UninstallLibraries

func (*MockLibrariesInterface_Expecter) UpdateAndWait 

func (_e *MockLibrariesInterface_Expecter) UpdateAndWait(ctx any, update any, options ...any) *MockLibrariesInterface_UpdateAndWait_Call

UpdateAndWait is a helper method to define mock.On call

  • ctx context.Context
  • update compute.Update
  • options ...retries.Option[compute.ClusterLibraryStatuses]

type MockLibrariesInterface_Install_Call 

type MockLibrariesInterface_Install_Call struct {
	*mock.Call
}

MockLibrariesInterface_Install_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Install'

func (*MockLibrariesInterface_Install_Call) Return 

func (_c *MockLibrariesInterface_Install_Call) Return(err error) *MockLibrariesInterface_Install_Call

func (*MockLibrariesInterface_Install_Call) Run 

func (_c *MockLibrariesInterface_Install_Call) Run(run func(ctx context.Context, request compute.InstallLibraries)) *MockLibrariesInterface_Install_Call

func (*MockLibrariesInterface_Install_Call) RunAndReturn 

func (_c *MockLibrariesInterface_Install_Call) RunAndReturn(run func(ctx context.Context, request compute.InstallLibraries) error) *MockLibrariesInterface_Install_Call

type MockLibrariesInterface_Uninstall_Call 

type MockLibrariesInterface_Uninstall_Call struct {
	*mock.Call
}

MockLibrariesInterface_Uninstall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Uninstall'

func (*MockLibrariesInterface_Uninstall_Call) Return 

func (_c *MockLibrariesInterface_Uninstall_Call) Return(err error) *MockLibrariesInterface_Uninstall_Call

func (*MockLibrariesInterface_Uninstall_Call) Run 

func (_c *MockLibrariesInterface_Uninstall_Call) Run(run func(ctx context.Context, request compute.UninstallLibraries)) *MockLibrariesInterface_Uninstall_Call

func (*MockLibrariesInterface_Uninstall_Call) RunAndReturn 

func (_c *MockLibrariesInterface_Uninstall_Call) RunAndReturn(run func(ctx context.Context, request compute.UninstallLibraries) error) *MockLibrariesInterface_Uninstall_Call

type MockLibrariesInterface_UpdateAndWait_Call 

type MockLibrariesInterface_UpdateAndWait_Call struct {
	*mock.Call
}

MockLibrariesInterface_UpdateAndWait_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAndWait'

func (*MockLibrariesInterface_UpdateAndWait_Call) Return 

func (_c *MockLibrariesInterface_UpdateAndWait_Call) Return(err error) *MockLibrariesInterface_UpdateAndWait_Call

func (*MockLibrariesInterface_UpdateAndWait_Call) Run 

func (_c *MockLibrariesInterface_UpdateAndWait_Call) Run(run func(ctx context.Context, update compute.Update, options ...retries.Option[compute.ClusterLibraryStatuses])) *MockLibrariesInterface_UpdateAndWait_Call

func (*MockLibrariesInterface_UpdateAndWait_Call) RunAndReturn 

func (_c *MockLibrariesInterface_UpdateAndWait_Call) RunAndReturn(run func(ctx context.Context, update compute.Update, options ...retries.Option[compute.ClusterLibraryStatuses]) error) *MockLibrariesInterface_UpdateAndWait_Call

type MockPolicyComplianceForClustersInterface added in v0.45.0 

type MockPolicyComplianceForClustersInterface struct {
	mock.Mock
}

MockPolicyComplianceForClustersInterface is an autogenerated mock type for the PolicyComplianceForClustersInterface type

func NewMockPolicyComplianceForClustersInterface added in v0.45.0 

func NewMockPolicyComplianceForClustersInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPolicyComplianceForClustersInterface

NewMockPolicyComplianceForClustersInterface creates a new instance of MockPolicyComplianceForClustersInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPolicyComplianceForClustersInterface) CancelPendingClusterEnforcement added in v0.150.0 

func (_mock *MockPolicyComplianceForClustersInterface) CancelPendingClusterEnforcement(ctx context.Context, request compute.CancelPendingClusterEnforcementRequest) (*compute.CancelPendingClusterEnforcementResponse, error)

CancelPendingClusterEnforcement provides a mock function for the type MockPolicyComplianceForClustersInterface

func (*MockPolicyComplianceForClustersInterface) EXPECT added in v0.45.0 

func (_m *MockPolicyComplianceForClustersInterface) EXPECT() *MockPolicyComplianceForClustersInterface_Expecter

func (*MockPolicyComplianceForClustersInterface) EnforceCompliance added in v0.45.0 

func (_mock *MockPolicyComplianceForClustersInterface) EnforceCompliance(ctx context.Context, request compute.EnforceClusterComplianceRequest) (*compute.EnforceClusterComplianceResponse, error)

EnforceCompliance provides a mock function for the type MockPolicyComplianceForClustersInterface

func (*MockPolicyComplianceForClustersInterface) GetCompliance added in v0.45.0 

func (_mock *MockPolicyComplianceForClustersInterface) GetCompliance(ctx context.Context, request compute.GetClusterComplianceRequest) (*compute.GetClusterComplianceResponse, error)

GetCompliance provides a mock function for the type MockPolicyComplianceForClustersInterface

func (*MockPolicyComplianceForClustersInterface) GetComplianceByClusterId added in v0.45.0 

func (_mock *MockPolicyComplianceForClustersInterface) GetComplianceByClusterId(ctx context.Context, clusterId string) (*compute.GetClusterComplianceResponse, error)

GetComplianceByClusterId provides a mock function for the type MockPolicyComplianceForClustersInterface

func (*MockPolicyComplianceForClustersInterface) ListCompliance added in v0.45.0 

func (_mock *MockPolicyComplianceForClustersInterface) ListCompliance(ctx context.Context, request compute.ListClusterCompliancesRequest) listing.Iterator[compute.ClusterCompliance]

ListCompliance provides a mock function for the type MockPolicyComplianceForClustersInterface

func (*MockPolicyComplianceForClustersInterface) ListComplianceAll added in v0.45.0 

func (_mock *MockPolicyComplianceForClustersInterface) ListComplianceAll(ctx context.Context, request compute.ListClusterCompliancesRequest) ([]compute.ClusterCompliance, error)

ListComplianceAll provides a mock function for the type MockPolicyComplianceForClustersInterface

type MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call added in v0.150.0 

type MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call struct {
	*mock.Call
}

MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelPendingClusterEnforcement'

func (*MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call) Return added in v0.150.0 

func (_c *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call) Return(cancelPendingClusterEnforcementResponse *compute.CancelPendingClusterEnforcementResponse, err error) *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call

func (*MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call) Run added in v0.150.0 

func (_c *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call) Run(run func(ctx context.Context, request compute.CancelPendingClusterEnforcementRequest)) *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call

func (*MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call) RunAndReturn added in v0.150.0 

func (_c *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call) RunAndReturn(run func(ctx context.Context, request compute.CancelPendingClusterEnforcementRequest) (*compute.CancelPendingClusterEnforcementResponse, error)) *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call

type MockPolicyComplianceForClustersInterface_EnforceCompliance_Call added in v0.45.0 

type MockPolicyComplianceForClustersInterface_EnforceCompliance_Call struct {
	*mock.Call
}

MockPolicyComplianceForClustersInterface_EnforceCompliance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnforceCompliance'

func (*MockPolicyComplianceForClustersInterface_EnforceCompliance_Call) Return added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call) Return(enforceClusterComplianceResponse *compute.EnforceClusterComplianceResponse, err error) *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call

func (*MockPolicyComplianceForClustersInterface_EnforceCompliance_Call) Run added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call) Run(run func(ctx context.Context, request compute.EnforceClusterComplianceRequest)) *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call

func (*MockPolicyComplianceForClustersInterface_EnforceCompliance_Call) RunAndReturn added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call) RunAndReturn(run func(ctx context.Context, request compute.EnforceClusterComplianceRequest) (*compute.EnforceClusterComplianceResponse, error)) *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call

type MockPolicyComplianceForClustersInterface_Expecter added in v0.45.0 

type MockPolicyComplianceForClustersInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockPolicyComplianceForClustersInterface_Expecter) CancelPendingClusterEnforcement added in v0.150.0 

func (_e *MockPolicyComplianceForClustersInterface_Expecter) CancelPendingClusterEnforcement(ctx any, request any) *MockPolicyComplianceForClustersInterface_CancelPendingClusterEnforcement_Call

CancelPendingClusterEnforcement is a helper method to define mock.On call

  • ctx context.Context
  • request compute.CancelPendingClusterEnforcementRequest

func (*MockPolicyComplianceForClustersInterface_Expecter) EnforceCompliance added in v0.45.0 

func (_e *MockPolicyComplianceForClustersInterface_Expecter) EnforceCompliance(ctx any, request any) *MockPolicyComplianceForClustersInterface_EnforceCompliance_Call

EnforceCompliance is a helper method to define mock.On call

  • ctx context.Context
  • request compute.EnforceClusterComplianceRequest

func (*MockPolicyComplianceForClustersInterface_Expecter) GetCompliance added in v0.45.0 

func (_e *MockPolicyComplianceForClustersInterface_Expecter) GetCompliance(ctx any, request any) *MockPolicyComplianceForClustersInterface_GetCompliance_Call

GetCompliance is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetClusterComplianceRequest

func (*MockPolicyComplianceForClustersInterface_Expecter) GetComplianceByClusterId added in v0.45.0 

func (_e *MockPolicyComplianceForClustersInterface_Expecter) GetComplianceByClusterId(ctx any, clusterId any) *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call

GetComplianceByClusterId is a helper method to define mock.On call

  • ctx context.Context
  • clusterId string

func (*MockPolicyComplianceForClustersInterface_Expecter) ListCompliance added in v0.45.0 

func (_e *MockPolicyComplianceForClustersInterface_Expecter) ListCompliance(ctx any, request any) *MockPolicyComplianceForClustersInterface_ListCompliance_Call

ListCompliance is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClusterCompliancesRequest

func (*MockPolicyComplianceForClustersInterface_Expecter) ListComplianceAll added in v0.45.0 

func (_e *MockPolicyComplianceForClustersInterface_Expecter) ListComplianceAll(ctx any, request any) *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call

ListComplianceAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListClusterCompliancesRequest

type MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call added in v0.45.0 

type MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call struct {
	*mock.Call
}

MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetComplianceByClusterId'

func (*MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call) Return added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call) Return(getClusterComplianceResponse *compute.GetClusterComplianceResponse, err error) *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call

func (*MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call) Run added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call) Run(run func(ctx context.Context, clusterId string)) *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call

func (*MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call) RunAndReturn added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call) RunAndReturn(run func(ctx context.Context, clusterId string) (*compute.GetClusterComplianceResponse, error)) *MockPolicyComplianceForClustersInterface_GetComplianceByClusterId_Call

type MockPolicyComplianceForClustersInterface_GetCompliance_Call added in v0.45.0 

type MockPolicyComplianceForClustersInterface_GetCompliance_Call struct {
	*mock.Call
}

MockPolicyComplianceForClustersInterface_GetCompliance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCompliance'

func (*MockPolicyComplianceForClustersInterface_GetCompliance_Call) Return added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_GetCompliance_Call) Return(getClusterComplianceResponse *compute.GetClusterComplianceResponse, err error) *MockPolicyComplianceForClustersInterface_GetCompliance_Call

func (*MockPolicyComplianceForClustersInterface_GetCompliance_Call) Run added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_GetCompliance_Call) Run(run func(ctx context.Context, request compute.GetClusterComplianceRequest)) *MockPolicyComplianceForClustersInterface_GetCompliance_Call

func (*MockPolicyComplianceForClustersInterface_GetCompliance_Call) RunAndReturn added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_GetCompliance_Call) RunAndReturn(run func(ctx context.Context, request compute.GetClusterComplianceRequest) (*compute.GetClusterComplianceResponse, error)) *MockPolicyComplianceForClustersInterface_GetCompliance_Call

type MockPolicyComplianceForClustersInterface_ListComplianceAll_Call added in v0.45.0 

type MockPolicyComplianceForClustersInterface_ListComplianceAll_Call struct {
	*mock.Call
}

MockPolicyComplianceForClustersInterface_ListComplianceAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListComplianceAll'

func (*MockPolicyComplianceForClustersInterface_ListComplianceAll_Call) Return added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call) Return(clusterCompliances []compute.ClusterCompliance, err error) *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call

func (*MockPolicyComplianceForClustersInterface_ListComplianceAll_Call) Run added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call) Run(run func(ctx context.Context, request compute.ListClusterCompliancesRequest)) *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call

func (*MockPolicyComplianceForClustersInterface_ListComplianceAll_Call) RunAndReturn added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClusterCompliancesRequest) ([]compute.ClusterCompliance, error)) *MockPolicyComplianceForClustersInterface_ListComplianceAll_Call

type MockPolicyComplianceForClustersInterface_ListCompliance_Call added in v0.45.0 

type MockPolicyComplianceForClustersInterface_ListCompliance_Call struct {
	*mock.Call
}

MockPolicyComplianceForClustersInterface_ListCompliance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCompliance'

func (*MockPolicyComplianceForClustersInterface_ListCompliance_Call) Return added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_ListCompliance_Call) Return(iterator listing.Iterator[compute.ClusterCompliance]) *MockPolicyComplianceForClustersInterface_ListCompliance_Call

func (*MockPolicyComplianceForClustersInterface_ListCompliance_Call) Run added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_ListCompliance_Call) Run(run func(ctx context.Context, request compute.ListClusterCompliancesRequest)) *MockPolicyComplianceForClustersInterface_ListCompliance_Call

func (*MockPolicyComplianceForClustersInterface_ListCompliance_Call) RunAndReturn added in v0.45.0 

func (_c *MockPolicyComplianceForClustersInterface_ListCompliance_Call) RunAndReturn(run func(ctx context.Context, request compute.ListClusterCompliancesRequest) listing.Iterator[compute.ClusterCompliance]) *MockPolicyComplianceForClustersInterface_ListCompliance_Call

type MockPolicyFamiliesInterface 

type MockPolicyFamiliesInterface struct {
	mock.Mock
}

MockPolicyFamiliesInterface is an autogenerated mock type for the PolicyFamiliesInterface type

func NewMockPolicyFamiliesInterface 

func NewMockPolicyFamiliesInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPolicyFamiliesInterface

NewMockPolicyFamiliesInterface creates a new instance of MockPolicyFamiliesInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockPolicyFamiliesInterface) EXPECT 

func (_m *MockPolicyFamiliesInterface) EXPECT() *MockPolicyFamiliesInterface_Expecter

func (*MockPolicyFamiliesInterface) Get 

func (_mock *MockPolicyFamiliesInterface) Get(ctx context.Context, request compute.GetPolicyFamilyRequest) (*compute.PolicyFamily, error)

Get provides a mock function for the type MockPolicyFamiliesInterface

func (*MockPolicyFamiliesInterface) GetByPolicyFamilyId 

func (_mock *MockPolicyFamiliesInterface) GetByPolicyFamilyId(ctx context.Context, policyFamilyId string) (*compute.PolicyFamily, error)

GetByPolicyFamilyId provides a mock function for the type MockPolicyFamiliesInterface

func (*MockPolicyFamiliesInterface) List 

func (_mock *MockPolicyFamiliesInterface) List(ctx context.Context, request compute.ListPolicyFamiliesRequest) listing.Iterator[compute.PolicyFamily]

List provides a mock function for the type MockPolicyFamiliesInterface

func (*MockPolicyFamiliesInterface) ListAll 

func (_mock *MockPolicyFamiliesInterface) ListAll(ctx context.Context, request compute.ListPolicyFamiliesRequest) ([]compute.PolicyFamily, error)

ListAll provides a mock function for the type MockPolicyFamiliesInterface

type MockPolicyFamiliesInterface_Expecter 

type MockPolicyFamiliesInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockPolicyFamiliesInterface_Expecter) Get 

func (_e *MockPolicyFamiliesInterface_Expecter) Get(ctx any, request any) *MockPolicyFamiliesInterface_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • request compute.GetPolicyFamilyRequest

func (*MockPolicyFamiliesInterface_Expecter) GetByPolicyFamilyId 

func (_e *MockPolicyFamiliesInterface_Expecter) GetByPolicyFamilyId(ctx any, policyFamilyId any) *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call

GetByPolicyFamilyId is a helper method to define mock.On call

  • ctx context.Context
  • policyFamilyId string

func (*MockPolicyFamiliesInterface_Expecter) List 

func (_e *MockPolicyFamiliesInterface_Expecter) List(ctx any, request any) *MockPolicyFamiliesInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListPolicyFamiliesRequest

func (*MockPolicyFamiliesInterface_Expecter) ListAll 

func (_e *MockPolicyFamiliesInterface_Expecter) ListAll(ctx any, request any) *MockPolicyFamiliesInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListPolicyFamiliesRequest

type MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call 

type MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call struct {
	*mock.Call
}

MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetByPolicyFamilyId'

func (*MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call) Return 

func (_c *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call) Return(policyFamily *compute.PolicyFamily, err error) *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call

func (*MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call) Run 

func (_c *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call) Run(run func(ctx context.Context, policyFamilyId string)) *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call

func (*MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call) RunAndReturn 

func (_c *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call) RunAndReturn(run func(ctx context.Context, policyFamilyId string) (*compute.PolicyFamily, error)) *MockPolicyFamiliesInterface_GetByPolicyFamilyId_Call

type MockPolicyFamiliesInterface_Get_Call 

type MockPolicyFamiliesInterface_Get_Call struct {
	*mock.Call
}

MockPolicyFamiliesInterface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockPolicyFamiliesInterface_Get_Call) Return 

func (_c *MockPolicyFamiliesInterface_Get_Call) Return(policyFamily *compute.PolicyFamily, err error) *MockPolicyFamiliesInterface_Get_Call

func (*MockPolicyFamiliesInterface_Get_Call) Run 

func (_c *MockPolicyFamiliesInterface_Get_Call) Run(run func(ctx context.Context, request compute.GetPolicyFamilyRequest)) *MockPolicyFamiliesInterface_Get_Call

func (*MockPolicyFamiliesInterface_Get_Call) RunAndReturn 

func (_c *MockPolicyFamiliesInterface_Get_Call) RunAndReturn(run func(ctx context.Context, request compute.GetPolicyFamilyRequest) (*compute.PolicyFamily, error)) *MockPolicyFamiliesInterface_Get_Call

type MockPolicyFamiliesInterface_ListAll_Call 

type MockPolicyFamiliesInterface_ListAll_Call struct {
	*mock.Call
}

MockPolicyFamiliesInterface_ListAll_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAll'

func (*MockPolicyFamiliesInterface_ListAll_Call) Return 

func (_c *MockPolicyFamiliesInterface_ListAll_Call) Return(policyFamilys []compute.PolicyFamily, err error) *MockPolicyFamiliesInterface_ListAll_Call

func (*MockPolicyFamiliesInterface_ListAll_Call) Run 

func (_c *MockPolicyFamiliesInterface_ListAll_Call) Run(run func(ctx context.Context, request compute.ListPolicyFamiliesRequest)) *MockPolicyFamiliesInterface_ListAll_Call

func (*MockPolicyFamiliesInterface_ListAll_Call) RunAndReturn 

func (_c *MockPolicyFamiliesInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ListPolicyFamiliesRequest) ([]compute.PolicyFamily, error)) *MockPolicyFamiliesInterface_ListAll_Call

type MockPolicyFamiliesInterface_List_Call 

type MockPolicyFamiliesInterface_List_Call struct {
	*mock.Call
}

MockPolicyFamiliesInterface_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

func (*MockPolicyFamiliesInterface_List_Call) Return 

func (_c *MockPolicyFamiliesInterface_List_Call) Return(iterator listing.Iterator[compute.PolicyFamily]) *MockPolicyFamiliesInterface_List_Call

func (*MockPolicyFamiliesInterface_List_Call) Run 

func (_c *MockPolicyFamiliesInterface_List_Call) Run(run func(ctx context.Context, request compute.ListPolicyFamiliesRequest)) *MockPolicyFamiliesInterface_List_Call

func (*MockPolicyFamiliesInterface_List_Call) RunAndReturn 

func (_c *MockPolicyFamiliesInterface_List_Call) RunAndReturn(run func(ctx context.Context, request compute.ListPolicyFamiliesRequest) listing.Iterator[compute.PolicyFamily]) *MockPolicyFamiliesInterface_List_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.