compute

package
v0.196.0 Latest Latest
Warning

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

 Go to latest Published: Nov 9, 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

type MockServerlessComputeServiceInterface 

type MockServerlessComputeServiceInterface struct {
	mock.Mock
}

MockServerlessComputeServiceInterface is an autogenerated mock type for the ServerlessComputeServiceInterface type

func NewMockServerlessComputeServiceInterface 

func NewMockServerlessComputeServiceInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockServerlessComputeServiceInterface

NewMockServerlessComputeServiceInterface creates a new instance of MockServerlessComputeServiceInterface. 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 (*MockServerlessComputeServiceInterface) EXPECT 

func (_m *MockServerlessComputeServiceInterface) EXPECT() *MockServerlessComputeServiceInterface_Expecter

func (*MockServerlessComputeServiceInterface) List 

func (_mock *MockServerlessComputeServiceInterface) List(ctx context.Context, request compute.ListServerlessComputesRequest) listing.Iterator[compute.ServerlessCompute]

List provides a mock function for the type MockServerlessComputeServiceInterface

func (*MockServerlessComputeServiceInterface) ListAll 

func (_mock *MockServerlessComputeServiceInterface) ListAll(ctx context.Context, request compute.ListServerlessComputesRequest) ([]compute.ServerlessCompute, error)

ListAll provides a mock function for the type MockServerlessComputeServiceInterface

func (*MockServerlessComputeServiceInterface) ListComputePolicies 

func (_mock *MockServerlessComputeServiceInterface) ListComputePolicies(ctx context.Context, request compute.ListComputePoliciesRequest) listing.Iterator[compute.ComputePolicy]

ListComputePolicies provides a mock function for the type MockServerlessComputeServiceInterface

func (*MockServerlessComputeServiceInterface) ListComputePoliciesAll 

func (_mock *MockServerlessComputeServiceInterface) ListComputePoliciesAll(ctx context.Context, request compute.ListComputePoliciesRequest) ([]compute.ComputePolicy, error)

ListComputePoliciesAll provides a mock function for the type MockServerlessComputeServiceInterface

type MockServerlessComputeServiceInterface_Expecter 

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

func (*MockServerlessComputeServiceInterface_Expecter) List 

func (_e *MockServerlessComputeServiceInterface_Expecter) List(ctx any, request any) *MockServerlessComputeServiceInterface_List_Call

List is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListServerlessComputesRequest

func (*MockServerlessComputeServiceInterface_Expecter) ListAll 

func (_e *MockServerlessComputeServiceInterface_Expecter) ListAll(ctx any, request any) *MockServerlessComputeServiceInterface_ListAll_Call

ListAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListServerlessComputesRequest

func (*MockServerlessComputeServiceInterface_Expecter) ListComputePolicies 

func (_e *MockServerlessComputeServiceInterface_Expecter) ListComputePolicies(ctx any, request any) *MockServerlessComputeServiceInterface_ListComputePolicies_Call

ListComputePolicies is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListComputePoliciesRequest

func (*MockServerlessComputeServiceInterface_Expecter) ListComputePoliciesAll 

func (_e *MockServerlessComputeServiceInterface_Expecter) ListComputePoliciesAll(ctx any, request any) *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call

ListComputePoliciesAll is a helper method to define mock.On call

  • ctx context.Context
  • request compute.ListComputePoliciesRequest

type MockServerlessComputeServiceInterface_ListAll_Call 

type MockServerlessComputeServiceInterface_ListAll_Call struct {
	*mock.Call
}

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

func (*MockServerlessComputeServiceInterface_ListAll_Call) Return 

func (_c *MockServerlessComputeServiceInterface_ListAll_Call) Return(serverlessComputes []compute.ServerlessCompute, err error) *MockServerlessComputeServiceInterface_ListAll_Call

func (*MockServerlessComputeServiceInterface_ListAll_Call) Run 

func (_c *MockServerlessComputeServiceInterface_ListAll_Call) Run(run func(ctx context.Context, request compute.ListServerlessComputesRequest)) *MockServerlessComputeServiceInterface_ListAll_Call

func (*MockServerlessComputeServiceInterface_ListAll_Call) RunAndReturn 

func (_c *MockServerlessComputeServiceInterface_ListAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ListServerlessComputesRequest) ([]compute.ServerlessCompute, error)) *MockServerlessComputeServiceInterface_ListAll_Call

type MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call 

type MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call struct {
	*mock.Call
}

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

func (*MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call) Return 

func (_c *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call) Return(computePolicys []compute.ComputePolicy, err error) *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call

func (*MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call) Run 

func (_c *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call) Run(run func(ctx context.Context, request compute.ListComputePoliciesRequest)) *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call

func (*MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call) RunAndReturn 

func (_c *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call) RunAndReturn(run func(ctx context.Context, request compute.ListComputePoliciesRequest) ([]compute.ComputePolicy, error)) *MockServerlessComputeServiceInterface_ListComputePoliciesAll_Call

type MockServerlessComputeServiceInterface_ListComputePolicies_Call 

type MockServerlessComputeServiceInterface_ListComputePolicies_Call struct {
	*mock.Call
}

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

func (*MockServerlessComputeServiceInterface_ListComputePolicies_Call) Return 

func (_c *MockServerlessComputeServiceInterface_ListComputePolicies_Call) Return(iterator listing.Iterator[compute.ComputePolicy]) *MockServerlessComputeServiceInterface_ListComputePolicies_Call

func (*MockServerlessComputeServiceInterface_ListComputePolicies_Call) Run 

func (_c *MockServerlessComputeServiceInterface_ListComputePolicies_Call) Run(run func(ctx context.Context, request compute.ListComputePoliciesRequest)) *MockServerlessComputeServiceInterface_ListComputePolicies_Call

func (*MockServerlessComputeServiceInterface_ListComputePolicies_Call) RunAndReturn 

func (_c *MockServerlessComputeServiceInterface_ListComputePolicies_Call) RunAndReturn(run func(ctx context.Context, request compute.ListComputePoliciesRequest) listing.Iterator[compute.ComputePolicy]) *MockServerlessComputeServiceInterface_ListComputePolicies_Call

type MockServerlessComputeServiceInterface_List_Call 

type MockServerlessComputeServiceInterface_List_Call struct {
	*mock.Call
}

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

func (*MockServerlessComputeServiceInterface_List_Call) Return 

func (_c *MockServerlessComputeServiceInterface_List_Call) Return(iterator listing.Iterator[compute.ServerlessCompute]) *MockServerlessComputeServiceInterface_List_Call

func (*MockServerlessComputeServiceInterface_List_Call) Run 

func (_c *MockServerlessComputeServiceInterface_List_Call) Run(run func(ctx context.Context, request compute.ListServerlessComputesRequest)) *MockServerlessComputeServiceInterface_List_Call

func (*MockServerlessComputeServiceInterface_List_Call) RunAndReturn 

func (_c *MockServerlessComputeServiceInterface_List_Call) RunAndReturn(run func(ctx context.Context, request compute.ListServerlessComputesRequest) listing.Iterator[compute.ServerlessCompute]) *MockServerlessComputeServiceInterface_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.