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

compute

package
v0.167.0 Latest Latest
Warning

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

 Go to latest Published: Jul 30, 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 (_m *MockClusterPoliciesInterface) Create(ctx context.Context, request compute.CreatePolicy) (*compute.CreatePolicyResponse, error)

Create provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) Delete 

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

Delete provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) DeleteByPolicyId 

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

DeleteByPolicyId provides a mock function with given fields: ctx, policyId

func (*MockClusterPoliciesInterface) EXPECT 

func (_m *MockClusterPoliciesInterface) EXPECT() *MockClusterPoliciesInterface_Expecter

func (*MockClusterPoliciesInterface) Edit 

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

Edit provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) Get 

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

Get provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) GetByName 

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

GetByName provides a mock function with given fields: ctx, name

func (*MockClusterPoliciesInterface) GetByPolicyId 

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

GetByPolicyId provides a mock function with given fields: ctx, policyId

func (*MockClusterPoliciesInterface) GetPermissionLevels 

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

GetPermissionLevels provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) GetPermissionLevelsByClusterPolicyId 

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

GetPermissionLevelsByClusterPolicyId provides a mock function with given fields: ctx, clusterPolicyId

func (*MockClusterPoliciesInterface) GetPermissions 

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

GetPermissions provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) GetPermissionsByClusterPolicyId 

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

GetPermissionsByClusterPolicyId provides a mock function with given fields: ctx, clusterPolicyId

func (*MockClusterPoliciesInterface) List 

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

List provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) ListAll 

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

ListAll provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) PolicyNameToPolicyIdMap 

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

PolicyNameToPolicyIdMap provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) SetPermissions 

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

SetPermissions provides a mock function with given fields: ctx, request

func (*MockClusterPoliciesInterface) UpdatePermissions 

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

UpdatePermissions provides a mock function with given fields: ctx, request

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(_a0 *compute.CreatePolicyResponse, _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, policyId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, name interface{}) *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 interface{}, policyId interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterPolicyId interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterPolicyId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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(_a0 *compute.Policy, _a1 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(context.Context, 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(_a0 *compute.Policy, _a1 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(context.Context, 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(_a0 *compute.GetClusterPolicyPermissionLevelsResponse, _a1 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(context.Context, 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(_a0 *compute.GetClusterPolicyPermissionLevelsResponse, _a1 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(context.Context, 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(_a0 *compute.ClusterPolicyPermissions, _a1 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(context.Context, 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(_a0 *compute.ClusterPolicyPermissions, _a1 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(context.Context, 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(_a0 *compute.Policy, _a1 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(context.Context, 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(_a0 []compute.Policy, _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 map[string]string, _a1 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(context.Context, 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(_a0 *compute.ClusterPolicyPermissions, _a1 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(context.Context, 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(_a0 *compute.ClusterPolicyPermissions, _a1 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(context.Context, 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 (_m *MockClustersInterface) ChangeOwner(ctx context.Context, request compute.ChangeClusterOwner) error

ChangeOwner provides a mock function with given fields: ctx, request

func (*MockClustersInterface) ClusterDetailsClusterNameToClusterIdMap 

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

ClusterDetailsClusterNameToClusterIdMap provides a mock function with given fields: ctx, request

func (*MockClustersInterface) Create 

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

Create provides a mock function with given fields: ctx, createCluster

func (*MockClustersInterface) CreateAndWait 

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

CreateAndWait provides a mock function with given fields: ctx, createCluster, options

func (*MockClustersInterface) Delete 

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

Delete provides a mock function with given fields: ctx, deleteCluster

func (*MockClustersInterface) DeleteAndWait 

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

DeleteAndWait provides a mock function with given fields: ctx, deleteCluster, options

func (*MockClustersInterface) DeleteByClusterId 

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

DeleteByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) DeleteByClusterIdAndWait 

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

DeleteByClusterIdAndWait provides a mock function with given fields: ctx, clusterId, options

func (*MockClustersInterface) EXPECT 

func (_m *MockClustersInterface) EXPECT() *MockClustersInterface_Expecter

func (*MockClustersInterface) Edit 

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

Edit provides a mock function with given fields: ctx, editCluster

func (*MockClustersInterface) EditAndWait 

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

EditAndWait provides a mock function with given fields: ctx, editCluster, options

func (*MockClustersInterface) EnsureClusterIsRunning 

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

EnsureClusterIsRunning provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) Events 

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

Events provides a mock function with given fields: ctx, request

func (*MockClustersInterface) EventsAll 

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

EventsAll provides a mock function with given fields: ctx, request

func (*MockClustersInterface) Get 

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

Get provides a mock function with given fields: ctx, request

func (*MockClustersInterface) GetByClusterId 

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

GetByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) GetByClusterName 

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

GetByClusterName provides a mock function with given fields: ctx, name

func (*MockClustersInterface) GetOrCreateRunningCluster 

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

GetOrCreateRunningCluster provides a mock function with given fields: ctx, name, custom

func (*MockClustersInterface) GetPermissionLevels 

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

GetPermissionLevels provides a mock function with given fields: ctx, request

func (*MockClustersInterface) GetPermissionLevelsByClusterId 

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

GetPermissionLevelsByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) GetPermissions 

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

GetPermissions provides a mock function with given fields: ctx, request

func (*MockClustersInterface) GetPermissionsByClusterId 

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

GetPermissionsByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) List 

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

List provides a mock function with given fields: ctx, request

func (*MockClustersInterface) ListAll 

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

ListAll provides a mock function with given fields: ctx, request

func (*MockClustersInterface) ListNodeTypes 

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

ListNodeTypes provides a mock function with given fields: ctx

func (*MockClustersInterface) ListZones 

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

ListZones provides a mock function with given fields: ctx

func (*MockClustersInterface) PermanentDelete 

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

PermanentDelete provides a mock function with given fields: ctx, request

func (*MockClustersInterface) PermanentDeleteByClusterId 

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

PermanentDeleteByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) Pin 

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

Pin provides a mock function with given fields: ctx, request

func (*MockClustersInterface) PinByClusterId 

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

PinByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) Resize 

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

Resize provides a mock function with given fields: ctx, resizeCluster

func (*MockClustersInterface) ResizeAndWait 

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

ResizeAndWait provides a mock function with given fields: ctx, resizeCluster, options

func (*MockClustersInterface) Restart 

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

Restart provides a mock function with given fields: ctx, restartCluster

func (*MockClustersInterface) RestartAndWait 

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

RestartAndWait provides a mock function with given fields: ctx, restartCluster, options

func (*MockClustersInterface) SelectNodeType 

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

SelectNodeType provides a mock function with given fields: ctx, r

func (*MockClustersInterface) SelectSparkVersion 

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

SelectSparkVersion provides a mock function with given fields: ctx, r

func (*MockClustersInterface) SetPermissions 

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

SetPermissions provides a mock function with given fields: ctx, request

func (*MockClustersInterface) SparkVersions 

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

SparkVersions provides a mock function with given fields: ctx

func (*MockClustersInterface) Start 

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

Start provides a mock function with given fields: ctx, startCluster

func (*MockClustersInterface) StartAndWait 

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

StartAndWait provides a mock function with given fields: ctx, startCluster, options

func (*MockClustersInterface) StartByClusterId 

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

StartByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) StartByClusterIdAndWait 

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

StartByClusterIdAndWait provides a mock function with given fields: ctx, clusterId, options

func (*MockClustersInterface) Unpin 

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

Unpin provides a mock function with given fields: ctx, request

func (*MockClustersInterface) UnpinByClusterId 

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

UnpinByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockClustersInterface) Update added in v0.44.0 

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

Update provides a mock function with given fields: ctx, updateCluster

func (*MockClustersInterface) UpdateAndWait added in v0.44.0 

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

UpdateAndWait provides a mock function with given fields: ctx, updateCluster, options

func (*MockClustersInterface) UpdatePermissions 

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

UpdatePermissions provides a mock function with given fields: ctx, request

func (*MockClustersInterface) WaitGetClusterRunning 

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

WaitGetClusterRunning provides a mock function with given fields: ctx, clusterId, timeout, callback

func (*MockClustersInterface) WaitGetClusterTerminated 

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

WaitGetClusterTerminated provides a mock function with given fields: ctx, clusterId, timeout, callback

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(_a0 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(context.Context, 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(_a0 map[string]string, _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.CreateCluster, ...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(_a0 *compute.WaitGetClusterRunning[compute.CreateClusterResponse], _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.DeleteCluster, ...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(_a0 *compute.ClusterDetails, _a1 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(context.Context, string, ...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(_a0 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(context.Context, 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(_a0 *compute.WaitGetClusterTerminated[struct{}], _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.EditCluster, ...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(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 []compute.ClusterEvent, _a1 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(context.Context, 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(_a0 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(context.Context, 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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, createCluster interface{}) *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 interface{}, createCluster interface{}, options ...interface{}) *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 interface{}, deleteCluster interface{}) *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 interface{}, deleteCluster interface{}, options ...interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, clusterId interface{}, options ...interface{}) *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 interface{}, editCluster interface{}) *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 interface{}, editCluster interface{}, options ...interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, name interface{}) *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 interface{}, name interface{}, custom ...interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}) *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 interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, resizeCluster interface{}) *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 interface{}, resizeCluster interface{}, options ...interface{}) *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 interface{}, restartCluster interface{}) *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 interface{}, restartCluster interface{}, options ...interface{}) *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 interface{}, r interface{}) *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 interface{}, r interface{}) *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 interface{}, request interface{}) *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 interface{}) *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 interface{}, startCluster interface{}) *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 interface{}, startCluster interface{}, options ...interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, clusterId interface{}, options ...interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, updateCluster interface{}) *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 interface{}, updateCluster interface{}, options ...interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}, timeout interface{}, callback interface{}) *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 interface{}, clusterId interface{}, timeout interface{}, callback interface{}) *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(_a0 *compute.ClusterDetails, _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, 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(context.Context, string, ...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(_a0 *compute.GetClusterPermissionLevelsResponse, _a1 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(context.Context, 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(_a0 *compute.GetClusterPermissionLevelsResponse, _a1 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(context.Context, 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(_a0 *compute.ClusterPermissions, _a1 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(context.Context, 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(_a0 *compute.ClusterPermissions, _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, 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(_a0 []compute.ClusterDetails, _a1 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(context.Context, 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(_a0 *compute.ListNodeTypesResponse, _a1 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(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(_a0 *compute.ListAvailableZonesResponse, _a1 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(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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.ResizeCluster, ...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(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.RestartCluster, ...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(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 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(context.Context, 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(_a0 string, _a1 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(context.Context, 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(_a0 string, _a1 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(context.Context, 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(_a0 *compute.ClusterPermissions, _a1 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(context.Context, 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(_a0 *compute.GetSparkVersionsResponse, _a1 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(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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.StartCluster, ...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(_a0 *compute.ClusterDetails, _a1 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(context.Context, string, ...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(_a0 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(context.Context, 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(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, compute.UpdateCluster, ...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(_a0 *compute.ClusterPermissions, _a1 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(context.Context, 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(_a0 *compute.WaitGetClusterRunning[struct{}], _a1 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(context.Context, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, string, time.Duration, 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(_a0 *compute.ClusterDetails, _a1 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(context.Context, string, time.Duration, 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 (_m *MockCommandExecutionInterface) Cancel(ctx context.Context, cancelCommand compute.CancelCommand) (*compute.WaitCommandStatusCommandExecutionCancelled[struct{}], error)

Cancel provides a mock function with given fields: ctx, cancelCommand

func (*MockCommandExecutionInterface) CancelAndWait 

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

CancelAndWait provides a mock function with given fields: ctx, cancelCommand, options

func (*MockCommandExecutionInterface) CommandStatus 

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

CommandStatus provides a mock function with given fields: ctx, request

func (*MockCommandExecutionInterface) ContextStatus 

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

ContextStatus provides a mock function with given fields: ctx, request

func (*MockCommandExecutionInterface) Create 

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

Create provides a mock function with given fields: ctx, createContext

func (*MockCommandExecutionInterface) CreateAndWait 

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

CreateAndWait provides a mock function with given fields: ctx, createContext, options

func (*MockCommandExecutionInterface) Destroy 

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

Destroy provides a mock function with given fields: ctx, request

func (*MockCommandExecutionInterface) EXPECT 

func (_m *MockCommandExecutionInterface) EXPECT() *MockCommandExecutionInterface_Expecter

func (*MockCommandExecutionInterface) Execute 

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

Execute provides a mock function with given fields: ctx, command

func (*MockCommandExecutionInterface) ExecuteAndWait 

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

ExecuteAndWait provides a mock function with given fields: ctx, command, options

func (*MockCommandExecutionInterface) Start 

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

Start provides a mock function with given fields: ctx, clusterID, language

func (*MockCommandExecutionInterface) WaitCommandStatusCommandExecutionCancelled 

func (_m *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 with given fields: ctx, clusterId, commandId, contextId, timeout, callback

func (*MockCommandExecutionInterface) WaitCommandStatusCommandExecutionFinishedOrError 

func (_m *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 with given fields: ctx, clusterId, commandId, contextId, timeout, callback

func (*MockCommandExecutionInterface) WaitContextStatusCommandExecutionRunning 

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

WaitContextStatusCommandExecutionRunning provides a mock function with given fields: ctx, clusterId, contextId, timeout, callback

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(_a0 *compute.CommandStatusResponse, _a1 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(context.Context, compute.CancelCommand, ...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(_a0 *compute.WaitCommandStatusCommandExecutionCancelled[struct{}], _a1 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(context.Context, 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(_a0 *compute.CommandStatusResponse, _a1 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(context.Context, 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(_a0 *compute.ContextStatusResponse, _a1 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(context.Context, 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(_a0 *compute.ContextStatusResponse, _a1 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(context.Context, compute.CreateContext, ...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(_a0 *compute.WaitContextStatusCommandExecutionRunning[compute.Created], _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 *compute.CommandStatusResponse, _a1 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(context.Context, compute.Command, ...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(_a0 *compute.WaitCommandStatusCommandExecutionFinishedOrError[compute.Created], _a1 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(context.Context, 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 interface{}, cancelCommand interface{}) *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 interface{}, cancelCommand interface{}, options ...interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, createContext interface{}) *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 interface{}, createContext interface{}, options ...interface{}) *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 interface{}, request interface{}) *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 interface{}, command interface{}) *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 interface{}, command interface{}, options ...interface{}) *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 interface{}, clusterID interface{}, language interface{}) *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 interface{}, clusterId interface{}, commandId interface{}, contextId interface{}, timeout interface{}, callback interface{}) *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 interface{}, clusterId interface{}, commandId interface{}, contextId interface{}, timeout interface{}, callback interface{}) *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 interface{}, clusterId interface{}, contextId interface{}, timeout interface{}, callback interface{}) *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(_a0 *compute.CommandExecutorV2, _a1 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(context.Context, string, 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(_a0 *compute.CommandStatusResponse, _a1 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(context.Context, string, string, string, time.Duration, 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(_a0 *compute.CommandStatusResponse, _a1 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(context.Context, string, string, string, time.Duration, 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(_a0 *compute.ContextStatusResponse, _a1 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(context.Context, string, string, time.Duration, 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 (_m *MockGlobalInitScriptsInterface) Create(ctx context.Context, request compute.GlobalInitScriptCreateRequest) (*compute.CreateResponse, error)

Create provides a mock function with given fields: ctx, request

func (*MockGlobalInitScriptsInterface) Delete 

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

Delete provides a mock function with given fields: ctx, request

func (*MockGlobalInitScriptsInterface) DeleteByScriptId 

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

DeleteByScriptId provides a mock function with given fields: ctx, scriptId

func (*MockGlobalInitScriptsInterface) EXPECT 

func (_m *MockGlobalInitScriptsInterface) EXPECT() *MockGlobalInitScriptsInterface_Expecter

func (*MockGlobalInitScriptsInterface) Get 

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

Get provides a mock function with given fields: ctx, request

func (*MockGlobalInitScriptsInterface) GetByName 

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

GetByName provides a mock function with given fields: ctx, name

func (*MockGlobalInitScriptsInterface) GetByScriptId 

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

GetByScriptId provides a mock function with given fields: ctx, scriptId

func (*MockGlobalInitScriptsInterface) GlobalInitScriptDetailsNameToScriptIdMap 

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

GlobalInitScriptDetailsNameToScriptIdMap provides a mock function with given fields: ctx

func (*MockGlobalInitScriptsInterface) List 

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

List provides a mock function with given fields: ctx

func (*MockGlobalInitScriptsInterface) ListAll 

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

ListAll provides a mock function with given fields: ctx

func (*MockGlobalInitScriptsInterface) Update 

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

Update provides a mock function with given fields: ctx, request

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(_a0 *compute.CreateResponse, _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, scriptId interface{}) *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 interface{}, request interface{}) *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 interface{}, name interface{}) *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 interface{}, scriptId interface{}) *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 interface{}) *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 interface{}) *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 interface{}) *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 interface{}, request interface{}) *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(_a0 *compute.GlobalInitScriptDetails, _a1 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(context.Context, 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(_a0 *compute.GlobalInitScriptDetailsWithContent, _a1 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(context.Context, 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(_a0 *compute.GlobalInitScriptDetailsWithContent, _a1 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(context.Context, 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(_a0 map[string]string, _a1 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(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(_a0 []compute.GlobalInitScriptDetails, _a1 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(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(_a0 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(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(_a0 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(context.Context, 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 (_m *MockInstancePoolsInterface) Create(ctx context.Context, request compute.CreateInstancePool) (*compute.CreateInstancePoolResponse, error)

Create provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) Delete 

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

Delete provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) DeleteByInstancePoolId 

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

DeleteByInstancePoolId provides a mock function with given fields: ctx, instancePoolId

func (*MockInstancePoolsInterface) EXPECT 

func (_m *MockInstancePoolsInterface) EXPECT() *MockInstancePoolsInterface_Expecter

func (*MockInstancePoolsInterface) Edit 

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

Edit provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) Get 

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

Get provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) GetByInstancePoolId 

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

GetByInstancePoolId provides a mock function with given fields: ctx, instancePoolId

func (*MockInstancePoolsInterface) GetByInstancePoolName 

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

GetByInstancePoolName provides a mock function with given fields: ctx, name

func (*MockInstancePoolsInterface) GetPermissionLevels 

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

GetPermissionLevels provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) GetPermissionLevelsByInstancePoolId 

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

GetPermissionLevelsByInstancePoolId provides a mock function with given fields: ctx, instancePoolId

func (*MockInstancePoolsInterface) GetPermissions 

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

GetPermissions provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) GetPermissionsByInstancePoolId 

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

GetPermissionsByInstancePoolId provides a mock function with given fields: ctx, instancePoolId

func (*MockInstancePoolsInterface) InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap 

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

InstancePoolAndStatsInstancePoolNameToInstancePoolIdMap provides a mock function with given fields: ctx

func (*MockInstancePoolsInterface) List 

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

List provides a mock function with given fields: ctx

func (*MockInstancePoolsInterface) ListAll 

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

ListAll provides a mock function with given fields: ctx

func (*MockInstancePoolsInterface) SetPermissions 

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

SetPermissions provides a mock function with given fields: ctx, request

func (*MockInstancePoolsInterface) UpdatePermissions 

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

UpdatePermissions provides a mock function with given fields: ctx, request

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(_a0 *compute.CreateInstancePoolResponse, _a1 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, 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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, instancePoolId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, instancePoolId interface{}) *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 interface{}, name interface{}) *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 interface{}, request interface{}) *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 interface{}, instancePoolId interface{}) *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 interface{}, request interface{}) *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 interface{}, instancePoolId interface{}) *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 interface{}) *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 interface{}) *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 interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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(_a0 *compute.GetInstancePool, _a1 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(context.Context, 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(_a0 *compute.InstancePoolAndStats, _a1 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(context.Context, 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(_a0 *compute.GetInstancePoolPermissionLevelsResponse, _a1 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(context.Context, 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(_a0 *compute.GetInstancePoolPermissionLevelsResponse, _a1 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(context.Context, 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(_a0 *compute.InstancePoolPermissions, _a1 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(context.Context, 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(_a0 *compute.InstancePoolPermissions, _a1 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(context.Context, 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(_a0 *compute.GetInstancePool, _a1 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(context.Context, 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(_a0 map[string]string, _a1 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(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(_a0 []compute.InstancePoolAndStats, _a1 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(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(_a0 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(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(_a0 *compute.InstancePoolPermissions, _a1 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(context.Context, 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(_a0 *compute.InstancePoolPermissions, _a1 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(context.Context, 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 (_m *MockInstanceProfilesInterface) Add(ctx context.Context, request compute.AddInstanceProfile) error

Add provides a mock function with given fields: ctx, request

func (*MockInstanceProfilesInterface) EXPECT 

func (_m *MockInstanceProfilesInterface) EXPECT() *MockInstanceProfilesInterface_Expecter

func (*MockInstanceProfilesInterface) Edit 

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

Edit provides a mock function with given fields: ctx, request

func (*MockInstanceProfilesInterface) List 

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

List provides a mock function with given fields: ctx

func (*MockInstanceProfilesInterface) ListAll 

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

ListAll provides a mock function with given fields: ctx

func (*MockInstanceProfilesInterface) Remove 

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

Remove provides a mock function with given fields: ctx, request

func (*MockInstanceProfilesInterface) RemoveByInstanceProfileArn 

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

RemoveByInstanceProfileArn provides a mock function with given fields: ctx, instanceProfileArn

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(_a0 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(context.Context, 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(_a0 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(context.Context, 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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}) *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 interface{}) *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 interface{}, request interface{}) *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 interface{}, instanceProfileArn interface{}) *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(_a0 []compute.InstanceProfile, _a1 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(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(_a0 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(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(_a0 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(context.Context, 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(_a0 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(context.Context, 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 (_m *MockLibrariesInterface) AllClusterStatuses(ctx context.Context) listing.Iterator[compute.ClusterLibraryStatuses]

AllClusterStatuses provides a mock function with given fields: ctx

func (*MockLibrariesInterface) AllClusterStatusesAll added in v0.41.0 

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

AllClusterStatusesAll provides a mock function with given fields: ctx

func (*MockLibrariesInterface) ClusterStatus 

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

ClusterStatus provides a mock function with given fields: ctx, request

func (*MockLibrariesInterface) ClusterStatusAll 

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

ClusterStatusAll provides a mock function with given fields: ctx, request

func (*MockLibrariesInterface) ClusterStatusByClusterId 

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

ClusterStatusByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockLibrariesInterface) EXPECT 

func (_m *MockLibrariesInterface) EXPECT() *MockLibrariesInterface_Expecter

func (*MockLibrariesInterface) Install 

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

Install provides a mock function with given fields: ctx, request

func (*MockLibrariesInterface) Uninstall 

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

Uninstall provides a mock function with given fields: ctx, request

func (*MockLibrariesInterface) UpdateAndWait 

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

UpdateAndWait provides a mock function with given fields: ctx, update, options

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(_a0 []compute.ClusterLibraryStatuses, _a1 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(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(_a0 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(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(_a0 []compute.LibraryFullStatus, _a1 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(context.Context, 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(_a0 *compute.ClusterLibraryStatuses, _a1 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(context.Context, 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(_a0 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(context.Context, 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 interface{}) *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 interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, update interface{}, options ...interface{}) *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(_a0 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(context.Context, 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(_a0 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(context.Context, 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(_a0 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(context.Context, compute.Update, ...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 (_m *MockPolicyComplianceForClustersInterface) CancelPendingClusterEnforcement(ctx context.Context, request compute.CancelPendingClusterEnforcementRequest) (*compute.CancelPendingClusterEnforcementResponse, error)

CancelPendingClusterEnforcement provides a mock function with given fields: ctx, request

func (*MockPolicyComplianceForClustersInterface) EXPECT added in v0.45.0 

func (_m *MockPolicyComplianceForClustersInterface) EXPECT() *MockPolicyComplianceForClustersInterface_Expecter

func (*MockPolicyComplianceForClustersInterface) EnforceCompliance added in v0.45.0 

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

EnforceCompliance provides a mock function with given fields: ctx, request

func (*MockPolicyComplianceForClustersInterface) GetCompliance added in v0.45.0 

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

GetCompliance provides a mock function with given fields: ctx, request

func (*MockPolicyComplianceForClustersInterface) GetComplianceByClusterId added in v0.45.0 

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

GetComplianceByClusterId provides a mock function with given fields: ctx, clusterId

func (*MockPolicyComplianceForClustersInterface) ListCompliance added in v0.45.0 

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

ListCompliance provides a mock function with given fields: ctx, request

func (*MockPolicyComplianceForClustersInterface) ListComplianceAll added in v0.45.0 

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

ListComplianceAll provides a mock function with given fields: ctx, request

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(_a0 *compute.CancelPendingClusterEnforcementResponse, _a1 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(context.Context, 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(_a0 *compute.EnforceClusterComplianceResponse, _a1 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(context.Context, 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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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 interface{}, clusterId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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(_a0 *compute.GetClusterComplianceResponse, _a1 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(context.Context, 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(_a0 *compute.GetClusterComplianceResponse, _a1 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(context.Context, 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(_a0 []compute.ClusterCompliance, _a1 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(context.Context, 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(_a0 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(context.Context, 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 (_m *MockPolicyFamiliesInterface) Get(ctx context.Context, request compute.GetPolicyFamilyRequest) (*compute.PolicyFamily, error)

Get provides a mock function with given fields: ctx, request

func (*MockPolicyFamiliesInterface) GetByPolicyFamilyId 

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

GetByPolicyFamilyId provides a mock function with given fields: ctx, policyFamilyId

func (*MockPolicyFamiliesInterface) List 

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

List provides a mock function with given fields: ctx, request

func (*MockPolicyFamiliesInterface) ListAll 

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

ListAll provides a mock function with given fields: ctx, request

type MockPolicyFamiliesInterface_Expecter 

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

func (*MockPolicyFamiliesInterface_Expecter) Get 

func (_e *MockPolicyFamiliesInterface_Expecter) Get(ctx interface{}, request interface{}) *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 interface{}, policyFamilyId interface{}) *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 interface{}, request interface{}) *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 interface{}, request interface{}) *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(_a0 *compute.PolicyFamily, _a1 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(context.Context, 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(_a0 *compute.PolicyFamily, _a1 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(context.Context, 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(_a0 []compute.PolicyFamily, _a1 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(context.Context, 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(_a0 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(context.Context, compute.ListPolicyFamiliesRequest) listing.Iterator[compute.PolicyFamily]) *MockPolicyFamiliesInterface_List_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.