compute

package
v0.39.0 Latest Latest
Warning

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

 Go to latest Published: Apr 24, 2024 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) Impl 

func (_m *MockClusterPoliciesInterface) Impl() compute.ClusterPoliciesService

Impl provides a mock function with given fields:

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

func (*MockClusterPoliciesInterface) WithImpl 

func (_m *MockClusterPoliciesInterface) WithImpl(impl compute.ClusterPoliciesService) compute.ClusterPoliciesInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockClusterPoliciesInterface_Expecter) Impl() *MockClusterPoliciesInterface_Impl_Call

Impl is a helper method to define mock.On call

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

func (*MockClusterPoliciesInterface_Expecter) WithImpl 

func (_e *MockClusterPoliciesInterface_Expecter) WithImpl(impl interface{}) *MockClusterPoliciesInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.ClusterPoliciesService

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_Impl_Call 

type MockClusterPoliciesInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockClusterPoliciesInterface_Impl_Call) Return 

func (_c *MockClusterPoliciesInterface_Impl_Call) Return(_a0 compute.ClusterPoliciesService) *MockClusterPoliciesInterface_Impl_Call

func (*MockClusterPoliciesInterface_Impl_Call) Run 

func (_c *MockClusterPoliciesInterface_Impl_Call) Run(run func()) *MockClusterPoliciesInterface_Impl_Call

func (*MockClusterPoliciesInterface_Impl_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_Impl_Call) RunAndReturn(run func() compute.ClusterPoliciesService) *MockClusterPoliciesInterface_Impl_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 MockClusterPoliciesInterface_WithImpl_Call 

type MockClusterPoliciesInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockClusterPoliciesInterface_WithImpl_Call) Return 

func (_c *MockClusterPoliciesInterface_WithImpl_Call) Return(_a0 compute.ClusterPoliciesInterface) *MockClusterPoliciesInterface_WithImpl_Call

func (*MockClusterPoliciesInterface_WithImpl_Call) Run 

func (_c *MockClusterPoliciesInterface_WithImpl_Call) Run(run func(impl compute.ClusterPoliciesService)) *MockClusterPoliciesInterface_WithImpl_Call

func (*MockClusterPoliciesInterface_WithImpl_Call) RunAndReturn 

func (_c *MockClusterPoliciesInterface_WithImpl_Call) RunAndReturn(run func(compute.ClusterPoliciesService) compute.ClusterPoliciesInterface) *MockClusterPoliciesInterface_WithImpl_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) Impl 

func (_m *MockClustersInterface) Impl() compute.ClustersService

Impl provides a mock function with given fields:

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) ListByCanUseClient 

func (_m *MockClustersInterface) ListByCanUseClient(ctx context.Context, canUseClient string) (*compute.ListClustersResponse, error)

ListByCanUseClient provides a mock function with given fields: ctx, canUseClient

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) 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

func (*MockClustersInterface) WithImpl 

func (_m *MockClustersInterface) WithImpl(impl compute.ClustersService) compute.ClustersInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockClustersInterface_Expecter) Impl() *MockClustersInterface_Impl_Call

Impl is a helper method to define mock.On call

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) ListByCanUseClient 

func (_e *MockClustersInterface_Expecter) ListByCanUseClient(ctx interface{}, canUseClient interface{}) *MockClustersInterface_ListByCanUseClient_Call

ListByCanUseClient is a helper method to define mock.On call

  • ctx context.Context
  • canUseClient string

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) 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)

func (*MockClustersInterface_Expecter) WithImpl 

func (_e *MockClustersInterface_Expecter) WithImpl(impl interface{}) *MockClustersInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.ClustersService

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_Impl_Call 

type MockClustersInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockClustersInterface_Impl_Call) Return 

func (_c *MockClustersInterface_Impl_Call) Return(_a0 compute.ClustersService) *MockClustersInterface_Impl_Call

func (*MockClustersInterface_Impl_Call) Run 

func (_c *MockClustersInterface_Impl_Call) Run(run func()) *MockClustersInterface_Impl_Call

func (*MockClustersInterface_Impl_Call) RunAndReturn 

func (_c *MockClustersInterface_Impl_Call) RunAndReturn(run func() compute.ClustersService) *MockClustersInterface_Impl_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_ListByCanUseClient_Call 

type MockClustersInterface_ListByCanUseClient_Call struct {
	*mock.Call
}

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

func (*MockClustersInterface_ListByCanUseClient_Call) Return 

func (_c *MockClustersInterface_ListByCanUseClient_Call) Return(_a0 *compute.ListClustersResponse, _a1 error) *MockClustersInterface_ListByCanUseClient_Call

func (*MockClustersInterface_ListByCanUseClient_Call) Run 

func (_c *MockClustersInterface_ListByCanUseClient_Call) Run(run func(ctx context.Context, canUseClient string)) *MockClustersInterface_ListByCanUseClient_Call

func (*MockClustersInterface_ListByCanUseClient_Call) RunAndReturn 

func (_c *MockClustersInterface_ListByCanUseClient_Call) RunAndReturn(run func(context.Context, string) (*compute.ListClustersResponse, error)) *MockClustersInterface_ListByCanUseClient_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_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_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 MockClustersInterface_WithImpl_Call 

type MockClustersInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockClustersInterface_WithImpl_Call) Return 

func (_c *MockClustersInterface_WithImpl_Call) Return(_a0 compute.ClustersInterface) *MockClustersInterface_WithImpl_Call

func (*MockClustersInterface_WithImpl_Call) Run 

func (_c *MockClustersInterface_WithImpl_Call) Run(run func(impl compute.ClustersService)) *MockClustersInterface_WithImpl_Call

func (*MockClustersInterface_WithImpl_Call) RunAndReturn 

func (_c *MockClustersInterface_WithImpl_Call) RunAndReturn(run func(compute.ClustersService) compute.ClustersInterface) *MockClustersInterface_WithImpl_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) Impl 

func (_m *MockCommandExecutionInterface) Impl() compute.CommandExecutionService

Impl provides a mock function with given fields:

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

func (*MockCommandExecutionInterface) WithImpl 

func (_m *MockCommandExecutionInterface) WithImpl(impl compute.CommandExecutionService) compute.CommandExecutionInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockCommandExecutionInterface_Expecter) Impl() *MockCommandExecutionInterface_Impl_Call

Impl is a helper method to define mock.On call

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)

func (*MockCommandExecutionInterface_Expecter) WithImpl 

func (_e *MockCommandExecutionInterface_Expecter) WithImpl(impl interface{}) *MockCommandExecutionInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.CommandExecutionService

type MockCommandExecutionInterface_Impl_Call 

type MockCommandExecutionInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockCommandExecutionInterface_Impl_Call) Return 

func (_c *MockCommandExecutionInterface_Impl_Call) Return(_a0 compute.CommandExecutionService) *MockCommandExecutionInterface_Impl_Call

func (*MockCommandExecutionInterface_Impl_Call) Run 

func (_c *MockCommandExecutionInterface_Impl_Call) Run(run func()) *MockCommandExecutionInterface_Impl_Call

func (*MockCommandExecutionInterface_Impl_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_Impl_Call) RunAndReturn(run func() compute.CommandExecutionService) *MockCommandExecutionInterface_Impl_Call

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 MockCommandExecutionInterface_WithImpl_Call 

type MockCommandExecutionInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockCommandExecutionInterface_WithImpl_Call) Return 

func (_c *MockCommandExecutionInterface_WithImpl_Call) Return(_a0 compute.CommandExecutionInterface) *MockCommandExecutionInterface_WithImpl_Call

func (*MockCommandExecutionInterface_WithImpl_Call) Run 

func (_c *MockCommandExecutionInterface_WithImpl_Call) Run(run func(impl compute.CommandExecutionService)) *MockCommandExecutionInterface_WithImpl_Call

func (*MockCommandExecutionInterface_WithImpl_Call) RunAndReturn 

func (_c *MockCommandExecutionInterface_WithImpl_Call) RunAndReturn(run func(compute.CommandExecutionService) compute.CommandExecutionInterface) *MockCommandExecutionInterface_WithImpl_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) Impl 

func (_m *MockGlobalInitScriptsInterface) Impl() compute.GlobalInitScriptsService

Impl provides a mock function with given fields:

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

func (*MockGlobalInitScriptsInterface) WithImpl 

func (_m *MockGlobalInitScriptsInterface) WithImpl(impl compute.GlobalInitScriptsService) compute.GlobalInitScriptsInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockGlobalInitScriptsInterface_Expecter) Impl() *MockGlobalInitScriptsInterface_Impl_Call

Impl is a helper method to define mock.On call

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

func (*MockGlobalInitScriptsInterface_Expecter) WithImpl 

func (_e *MockGlobalInitScriptsInterface_Expecter) WithImpl(impl interface{}) *MockGlobalInitScriptsInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.GlobalInitScriptsService

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_Impl_Call 

type MockGlobalInitScriptsInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockGlobalInitScriptsInterface_Impl_Call) Return 

func (_c *MockGlobalInitScriptsInterface_Impl_Call) Return(_a0 compute.GlobalInitScriptsService) *MockGlobalInitScriptsInterface_Impl_Call

func (*MockGlobalInitScriptsInterface_Impl_Call) Run 

func (_c *MockGlobalInitScriptsInterface_Impl_Call) Run(run func()) *MockGlobalInitScriptsInterface_Impl_Call

func (*MockGlobalInitScriptsInterface_Impl_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_Impl_Call) RunAndReturn(run func() compute.GlobalInitScriptsService) *MockGlobalInitScriptsInterface_Impl_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 MockGlobalInitScriptsInterface_WithImpl_Call 

type MockGlobalInitScriptsInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockGlobalInitScriptsInterface_WithImpl_Call) Return 

func (_c *MockGlobalInitScriptsInterface_WithImpl_Call) Return(_a0 compute.GlobalInitScriptsInterface) *MockGlobalInitScriptsInterface_WithImpl_Call

func (*MockGlobalInitScriptsInterface_WithImpl_Call) Run 

func (_c *MockGlobalInitScriptsInterface_WithImpl_Call) Run(run func(impl compute.GlobalInitScriptsService)) *MockGlobalInitScriptsInterface_WithImpl_Call

func (*MockGlobalInitScriptsInterface_WithImpl_Call) RunAndReturn 

func (_c *MockGlobalInitScriptsInterface_WithImpl_Call) RunAndReturn(run func(compute.GlobalInitScriptsService) compute.GlobalInitScriptsInterface) *MockGlobalInitScriptsInterface_WithImpl_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) Impl 

func (_m *MockInstancePoolsInterface) Impl() compute.InstancePoolsService

Impl provides a mock function with given fields:

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

func (*MockInstancePoolsInterface) WithImpl 

func (_m *MockInstancePoolsInterface) WithImpl(impl compute.InstancePoolsService) compute.InstancePoolsInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockInstancePoolsInterface_Expecter) Impl() *MockInstancePoolsInterface_Impl_Call

Impl is a helper method to define mock.On call

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

func (*MockInstancePoolsInterface_Expecter) WithImpl 

func (_e *MockInstancePoolsInterface_Expecter) WithImpl(impl interface{}) *MockInstancePoolsInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.InstancePoolsService

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_Impl_Call 

type MockInstancePoolsInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockInstancePoolsInterface_Impl_Call) Return 

func (_c *MockInstancePoolsInterface_Impl_Call) Return(_a0 compute.InstancePoolsService) *MockInstancePoolsInterface_Impl_Call

func (*MockInstancePoolsInterface_Impl_Call) Run 

func (_c *MockInstancePoolsInterface_Impl_Call) Run(run func()) *MockInstancePoolsInterface_Impl_Call

func (*MockInstancePoolsInterface_Impl_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_Impl_Call) RunAndReturn(run func() compute.InstancePoolsService) *MockInstancePoolsInterface_Impl_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 MockInstancePoolsInterface_WithImpl_Call 

type MockInstancePoolsInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockInstancePoolsInterface_WithImpl_Call) Return 

func (_c *MockInstancePoolsInterface_WithImpl_Call) Return(_a0 compute.InstancePoolsInterface) *MockInstancePoolsInterface_WithImpl_Call

func (*MockInstancePoolsInterface_WithImpl_Call) Run 

func (_c *MockInstancePoolsInterface_WithImpl_Call) Run(run func(impl compute.InstancePoolsService)) *MockInstancePoolsInterface_WithImpl_Call

func (*MockInstancePoolsInterface_WithImpl_Call) RunAndReturn 

func (_c *MockInstancePoolsInterface_WithImpl_Call) RunAndReturn(run func(compute.InstancePoolsService) compute.InstancePoolsInterface) *MockInstancePoolsInterface_WithImpl_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) Impl 

func (_m *MockInstanceProfilesInterface) Impl() compute.InstanceProfilesService

Impl provides a mock function with given fields:

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

func (*MockInstanceProfilesInterface) WithImpl 

func (_m *MockInstanceProfilesInterface) WithImpl(impl compute.InstanceProfilesService) compute.InstanceProfilesInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockInstanceProfilesInterface_Expecter) Impl() *MockInstanceProfilesInterface_Impl_Call

Impl is a helper method to define mock.On call

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

func (*MockInstanceProfilesInterface_Expecter) WithImpl 

func (_e *MockInstanceProfilesInterface_Expecter) WithImpl(impl interface{}) *MockInstanceProfilesInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.InstanceProfilesService

type MockInstanceProfilesInterface_Impl_Call 

type MockInstanceProfilesInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockInstanceProfilesInterface_Impl_Call) Return 

func (_c *MockInstanceProfilesInterface_Impl_Call) Return(_a0 compute.InstanceProfilesService) *MockInstanceProfilesInterface_Impl_Call

func (*MockInstanceProfilesInterface_Impl_Call) Run 

func (_c *MockInstanceProfilesInterface_Impl_Call) Run(run func()) *MockInstanceProfilesInterface_Impl_Call

func (*MockInstanceProfilesInterface_Impl_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_Impl_Call) RunAndReturn(run func() compute.InstanceProfilesService) *MockInstanceProfilesInterface_Impl_Call

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 MockInstanceProfilesInterface_WithImpl_Call 

type MockInstanceProfilesInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockInstanceProfilesInterface_WithImpl_Call) Return 

func (_c *MockInstanceProfilesInterface_WithImpl_Call) Return(_a0 compute.InstanceProfilesInterface) *MockInstanceProfilesInterface_WithImpl_Call

func (*MockInstanceProfilesInterface_WithImpl_Call) Run 

func (_c *MockInstanceProfilesInterface_WithImpl_Call) Run(run func(impl compute.InstanceProfilesService)) *MockInstanceProfilesInterface_WithImpl_Call

func (*MockInstanceProfilesInterface_WithImpl_Call) RunAndReturn 

func (_c *MockInstanceProfilesInterface_WithImpl_Call) RunAndReturn(run func(compute.InstanceProfilesService) compute.InstanceProfilesInterface) *MockInstanceProfilesInterface_WithImpl_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) (*compute.ListAllClusterLibraryStatusesResponse, error)

AllClusterStatuses 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.ClusterStatusResponse, error)

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

func (*MockLibrariesInterface) EXPECT 

func (_m *MockLibrariesInterface) EXPECT() *MockLibrariesInterface_Expecter

func (*MockLibrariesInterface) Impl 

func (_m *MockLibrariesInterface) Impl() compute.LibrariesService

Impl provides a mock function with given fields:

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.ClusterStatusResponse]) error

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

func (*MockLibrariesInterface) WithImpl 

func (_m *MockLibrariesInterface) WithImpl(impl compute.LibrariesService) compute.LibrariesInterface

WithImpl provides a mock function with given fields: impl

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 *compute.ListAllClusterLibraryStatusesResponse, _a1 error) *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) (*compute.ListAllClusterLibraryStatusesResponse, error)) *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.ClusterStatusResponse, _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.ClusterStatusResponse, 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) 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) Impl 

func (_e *MockLibrariesInterface_Expecter) Impl() *MockLibrariesInterface_Impl_Call

Impl is a helper method to define mock.On call

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.ClusterStatusResponse]

func (*MockLibrariesInterface_Expecter) WithImpl 

func (_e *MockLibrariesInterface_Expecter) WithImpl(impl interface{}) *MockLibrariesInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.LibrariesService

type MockLibrariesInterface_Impl_Call 

type MockLibrariesInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockLibrariesInterface_Impl_Call) Return 

func (_c *MockLibrariesInterface_Impl_Call) Return(_a0 compute.LibrariesService) *MockLibrariesInterface_Impl_Call

func (*MockLibrariesInterface_Impl_Call) Run 

func (_c *MockLibrariesInterface_Impl_Call) Run(run func()) *MockLibrariesInterface_Impl_Call

func (*MockLibrariesInterface_Impl_Call) RunAndReturn 

func (_c *MockLibrariesInterface_Impl_Call) RunAndReturn(run func() compute.LibrariesService) *MockLibrariesInterface_Impl_Call

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.ClusterStatusResponse])) *MockLibrariesInterface_UpdateAndWait_Call

func (*MockLibrariesInterface_UpdateAndWait_Call) RunAndReturn 

func (_c *MockLibrariesInterface_UpdateAndWait_Call) RunAndReturn(run func(context.Context, compute.Update, ...retries.Option[compute.ClusterStatusResponse]) error) *MockLibrariesInterface_UpdateAndWait_Call

type MockLibrariesInterface_WithImpl_Call 

type MockLibrariesInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockLibrariesInterface_WithImpl_Call) Return 

func (_c *MockLibrariesInterface_WithImpl_Call) Return(_a0 compute.LibrariesInterface) *MockLibrariesInterface_WithImpl_Call

func (*MockLibrariesInterface_WithImpl_Call) Run 

func (_c *MockLibrariesInterface_WithImpl_Call) Run(run func(impl compute.LibrariesService)) *MockLibrariesInterface_WithImpl_Call

func (*MockLibrariesInterface_WithImpl_Call) RunAndReturn 

func (_c *MockLibrariesInterface_WithImpl_Call) RunAndReturn(run func(compute.LibrariesService) compute.LibrariesInterface) *MockLibrariesInterface_WithImpl_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) Impl 

func (_m *MockPolicyFamiliesInterface) Impl() compute.PolicyFamiliesService

Impl provides a mock function with given fields:

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

func (*MockPolicyFamiliesInterface) WithImpl 

func (_m *MockPolicyFamiliesInterface) WithImpl(impl compute.PolicyFamiliesService) compute.PolicyFamiliesInterface

WithImpl provides a mock function with given fields: impl

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) Impl 

func (_e *MockPolicyFamiliesInterface_Expecter) Impl() *MockPolicyFamiliesInterface_Impl_Call

Impl is a helper method to define mock.On call

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

func (*MockPolicyFamiliesInterface_Expecter) WithImpl 

func (_e *MockPolicyFamiliesInterface_Expecter) WithImpl(impl interface{}) *MockPolicyFamiliesInterface_WithImpl_Call

WithImpl is a helper method to define mock.On call

  • impl compute.PolicyFamiliesService

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_Impl_Call 

type MockPolicyFamiliesInterface_Impl_Call struct {
	*mock.Call
}

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

func (*MockPolicyFamiliesInterface_Impl_Call) Return 

func (_c *MockPolicyFamiliesInterface_Impl_Call) Return(_a0 compute.PolicyFamiliesService) *MockPolicyFamiliesInterface_Impl_Call

func (*MockPolicyFamiliesInterface_Impl_Call) Run 

func (_c *MockPolicyFamiliesInterface_Impl_Call) Run(run func()) *MockPolicyFamiliesInterface_Impl_Call

func (*MockPolicyFamiliesInterface_Impl_Call) RunAndReturn 

func (_c *MockPolicyFamiliesInterface_Impl_Call) RunAndReturn(run func() compute.PolicyFamiliesService) *MockPolicyFamiliesInterface_Impl_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

type MockPolicyFamiliesInterface_WithImpl_Call 

type MockPolicyFamiliesInterface_WithImpl_Call struct {
	*mock.Call
}

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

func (*MockPolicyFamiliesInterface_WithImpl_Call) Return 

func (_c *MockPolicyFamiliesInterface_WithImpl_Call) Return(_a0 compute.PolicyFamiliesInterface) *MockPolicyFamiliesInterface_WithImpl_Call

func (*MockPolicyFamiliesInterface_WithImpl_Call) Run 

func (_c *MockPolicyFamiliesInterface_WithImpl_Call) Run(run func(impl compute.PolicyFamiliesService)) *MockPolicyFamiliesInterface_WithImpl_Call

func (*MockPolicyFamiliesInterface_WithImpl_Call) RunAndReturn 

func (_c *MockPolicyFamiliesInterface_WithImpl_Call) RunAndReturn(run func(compute.PolicyFamiliesService) compute.PolicyFamiliesInterface) *MockPolicyFamiliesInterface_WithImpl_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.