mocks

package
v0.0.1 Latest Latest
Warning

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

 Go to latest Published: Feb 4, 2024 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockAwsAccountClient_interfaces 

type MockAwsAccountClient_interfaces struct {
	mock.Mock
}

MockAwsAccountClient_interfaces is an autogenerated mock type for the AwsAccountClient type

func NewMockAwsAccountClient_interfaces 

func NewMockAwsAccountClient_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAwsAccountClient_interfaces

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

func (_m *MockAwsAccountClient_interfaces) EXPECT() *MockAwsAccountClient_interfaces_Expecter

func (*MockAwsAccountClient_interfaces) EnableRegion 

func (_m *MockAwsAccountClient_interfaces) EnableRegion(ctx context.Context, params *account.EnableRegionInput, optFns ...func(*account.Options)) (*account.EnableRegionOutput, error)

EnableRegion provides a mock function with given fields: ctx, params, optFns

func (*MockAwsAccountClient_interfaces) GetRegionOptStatus 

func (_m *MockAwsAccountClient_interfaces) GetRegionOptStatus(ctx context.Context, params *account.GetRegionOptStatusInput, optFns ...func(*account.Options)) (*account.GetRegionOptStatusOutput, error)

GetRegionOptStatus provides a mock function with given fields: ctx, params, optFns

type MockAwsAccountClient_interfaces_EnableRegion_Call 

type MockAwsAccountClient_interfaces_EnableRegion_Call struct {
	*mock.Call
}

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

func (*MockAwsAccountClient_interfaces_EnableRegion_Call) Return 

func (_c *MockAwsAccountClient_interfaces_EnableRegion_Call) Return(_a0 *account.EnableRegionOutput, _a1 error) *MockAwsAccountClient_interfaces_EnableRegion_Call

func (*MockAwsAccountClient_interfaces_EnableRegion_Call) Run 

func (_c *MockAwsAccountClient_interfaces_EnableRegion_Call) Run(run func(ctx context.Context, params *account.EnableRegionInput, optFns ...func(*account.Options))) *MockAwsAccountClient_interfaces_EnableRegion_Call

func (*MockAwsAccountClient_interfaces_EnableRegion_Call) RunAndReturn 

func (_c *MockAwsAccountClient_interfaces_EnableRegion_Call) RunAndReturn(run func(context.Context, *account.EnableRegionInput, ...func(*account.Options)) (*account.EnableRegionOutput, error)) *MockAwsAccountClient_interfaces_EnableRegion_Call

type MockAwsAccountClient_interfaces_Expecter 

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

func (*MockAwsAccountClient_interfaces_Expecter) EnableRegion 

func (_e *MockAwsAccountClient_interfaces_Expecter) EnableRegion(ctx interface{}, params interface{}, optFns ...interface{}) *MockAwsAccountClient_interfaces_EnableRegion_Call

EnableRegion is a helper method to define mock.On call

  • ctx context.Context
  • params *account.EnableRegionInput
  • optFns ...func(*account.Options)

func (*MockAwsAccountClient_interfaces_Expecter) GetRegionOptStatus 

func (_e *MockAwsAccountClient_interfaces_Expecter) GetRegionOptStatus(ctx interface{}, params interface{}, optFns ...interface{}) *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call

GetRegionOptStatus is a helper method to define mock.On call

  • ctx context.Context
  • params *account.GetRegionOptStatusInput
  • optFns ...func(*account.Options)

type MockAwsAccountClient_interfaces_GetRegionOptStatus_Call 

type MockAwsAccountClient_interfaces_GetRegionOptStatus_Call struct {
	*mock.Call
}

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

func (*MockAwsAccountClient_interfaces_GetRegionOptStatus_Call) Return 

func (_c *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call) Return(_a0 *account.GetRegionOptStatusOutput, _a1 error) *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call

func (*MockAwsAccountClient_interfaces_GetRegionOptStatus_Call) Run 

func (_c *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call) Run(run func(ctx context.Context, params *account.GetRegionOptStatusInput, optFns ...func(*account.Options))) *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call

func (*MockAwsAccountClient_interfaces_GetRegionOptStatus_Call) RunAndReturn 

func (_c *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call) RunAndReturn(run func(context.Context, *account.GetRegionOptStatusInput, ...func(*account.Options)) (*account.GetRegionOptStatusOutput, error)) *MockAwsAccountClient_interfaces_GetRegionOptStatus_Call

type MockClientOption_headscale_service 

type MockClientOption_headscale_service struct {
	mock.Mock
}

MockClientOption_headscale_service is an autogenerated mock type for the ClientOption type

func NewMockClientOption_headscale_service 

func NewMockClientOption_headscale_service(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClientOption_headscale_service

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

func (_m *MockClientOption_headscale_service) EXPECT() *MockClientOption_headscale_service_Expecter

func (*MockClientOption_headscale_service) Execute 

func (_m *MockClientOption_headscale_service) Execute(_a0 *runtime.ClientOperation)

Execute provides a mock function with given fields: _a0

type MockClientOption_headscale_service_Execute_Call 

type MockClientOption_headscale_service_Execute_Call struct {
	*mock.Call
}

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

func (*MockClientOption_headscale_service_Execute_Call) Return 

func (_c *MockClientOption_headscale_service_Execute_Call) Return() *MockClientOption_headscale_service_Execute_Call

func (*MockClientOption_headscale_service_Execute_Call) Run 

func (_c *MockClientOption_headscale_service_Execute_Call) Run(run func(_a0 *runtime.ClientOperation)) *MockClientOption_headscale_service_Execute_Call

func (*MockClientOption_headscale_service_Execute_Call) RunAndReturn 

func (_c *MockClientOption_headscale_service_Execute_Call) RunAndReturn(run func(*runtime.ClientOperation)) *MockClientOption_headscale_service_Execute_Call

type MockClientOption_headscale_service_Expecter 

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

func (*MockClientOption_headscale_service_Expecter) Execute 

func (_e *MockClientOption_headscale_service_Expecter) Execute(_a0 interface{}) *MockClientOption_headscale_service_Execute_Call

Execute is a helper method to define mock.On call

  • _a0 *runtime.ClientOperation

type MockClientService_headscale_service 

type MockClientService_headscale_service struct {
	mock.Mock
}

MockClientService_headscale_service is an autogenerated mock type for the ClientService type

func NewMockClientService_headscale_service 

func NewMockClientService_headscale_service(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClientService_headscale_service

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

func (_m *MockClientService_headscale_service) EXPECT() *MockClientService_headscale_service_Expecter

func (*MockClientService_headscale_service) HeadscaleServiceCreateAPIKey 

func (_m *MockClientService_headscale_service) HeadscaleServiceCreateAPIKey(params *headscale_service.HeadscaleServiceCreateAPIKeyParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceCreateAPIKeyOK, error)

HeadscaleServiceCreateAPIKey provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceCreatePreAuthKey 

func (_m *MockClientService_headscale_service) HeadscaleServiceCreatePreAuthKey(params *headscale_service.HeadscaleServiceCreatePreAuthKeyParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceCreatePreAuthKeyOK, error)

HeadscaleServiceCreatePreAuthKey provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceCreateUser 

func (_m *MockClientService_headscale_service) HeadscaleServiceCreateUser(params *headscale_service.HeadscaleServiceCreateUserParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceCreateUserOK, error)

HeadscaleServiceCreateUser provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceDebugCreateMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceDebugCreateMachine(params *headscale_service.HeadscaleServiceDebugCreateMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDebugCreateMachineOK, error)

HeadscaleServiceDebugCreateMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceDeleteMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceDeleteMachine(params *headscale_service.HeadscaleServiceDeleteMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDeleteMachineOK, error)

HeadscaleServiceDeleteMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceDeleteRoute 

func (_m *MockClientService_headscale_service) HeadscaleServiceDeleteRoute(params *headscale_service.HeadscaleServiceDeleteRouteParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDeleteRouteOK, error)

HeadscaleServiceDeleteRoute provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceDeleteUser 

func (_m *MockClientService_headscale_service) HeadscaleServiceDeleteUser(params *headscale_service.HeadscaleServiceDeleteUserParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDeleteUserOK, error)

HeadscaleServiceDeleteUser provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceDisableRoute 

func (_m *MockClientService_headscale_service) HeadscaleServiceDisableRoute(params *headscale_service.HeadscaleServiceDisableRouteParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDisableRouteOK, error)

HeadscaleServiceDisableRoute provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceEnableRoute 

func (_m *MockClientService_headscale_service) HeadscaleServiceEnableRoute(params *headscale_service.HeadscaleServiceEnableRouteParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceEnableRouteOK, error)

HeadscaleServiceEnableRoute provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceExpireAPIKey 

func (_m *MockClientService_headscale_service) HeadscaleServiceExpireAPIKey(params *headscale_service.HeadscaleServiceExpireAPIKeyParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceExpireAPIKeyOK, error)

HeadscaleServiceExpireAPIKey provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceExpireMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceExpireMachine(params *headscale_service.HeadscaleServiceExpireMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceExpireMachineOK, error)

HeadscaleServiceExpireMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceExpirePreAuthKey 

func (_m *MockClientService_headscale_service) HeadscaleServiceExpirePreAuthKey(params *headscale_service.HeadscaleServiceExpirePreAuthKeyParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceExpirePreAuthKeyOK, error)

HeadscaleServiceExpirePreAuthKey provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceGetMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceGetMachine(params *headscale_service.HeadscaleServiceGetMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetMachineOK, error)

HeadscaleServiceGetMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceGetMachineRoutes 

func (_m *MockClientService_headscale_service) HeadscaleServiceGetMachineRoutes(params *headscale_service.HeadscaleServiceGetMachineRoutesParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetMachineRoutesOK, error)

HeadscaleServiceGetMachineRoutes provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceGetRoutes 

func (_m *MockClientService_headscale_service) HeadscaleServiceGetRoutes(params *headscale_service.HeadscaleServiceGetRoutesParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetRoutesOK, error)

HeadscaleServiceGetRoutes provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceGetUser 

func (_m *MockClientService_headscale_service) HeadscaleServiceGetUser(params *headscale_service.HeadscaleServiceGetUserParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetUserOK, error)

HeadscaleServiceGetUser provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceListAPIKeys 

func (_m *MockClientService_headscale_service) HeadscaleServiceListAPIKeys(params *headscale_service.HeadscaleServiceListAPIKeysParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListAPIKeysOK, error)

HeadscaleServiceListAPIKeys provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceListMachines 

func (_m *MockClientService_headscale_service) HeadscaleServiceListMachines(params *headscale_service.HeadscaleServiceListMachinesParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListMachinesOK, error)

HeadscaleServiceListMachines provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceListPreAuthKeys 

func (_m *MockClientService_headscale_service) HeadscaleServiceListPreAuthKeys(params *headscale_service.HeadscaleServiceListPreAuthKeysParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListPreAuthKeysOK, error)

HeadscaleServiceListPreAuthKeys provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceListUsers 

func (_m *MockClientService_headscale_service) HeadscaleServiceListUsers(params *headscale_service.HeadscaleServiceListUsersParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListUsersOK, error)

HeadscaleServiceListUsers provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceMoveMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceMoveMachine(params *headscale_service.HeadscaleServiceMoveMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceMoveMachineOK, error)

HeadscaleServiceMoveMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceRegisterMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceRegisterMachine(params *headscale_service.HeadscaleServiceRegisterMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceRegisterMachineOK, error)

HeadscaleServiceRegisterMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceRenameMachine 

func (_m *MockClientService_headscale_service) HeadscaleServiceRenameMachine(params *headscale_service.HeadscaleServiceRenameMachineParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceRenameMachineOK, error)

HeadscaleServiceRenameMachine provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceRenameUser 

func (_m *MockClientService_headscale_service) HeadscaleServiceRenameUser(params *headscale_service.HeadscaleServiceRenameUserParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceRenameUserOK, error)

HeadscaleServiceRenameUser provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) HeadscaleServiceSetTags 

func (_m *MockClientService_headscale_service) HeadscaleServiceSetTags(params *headscale_service.HeadscaleServiceSetTagsParams, opts ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceSetTagsOK, error)

HeadscaleServiceSetTags provides a mock function with given fields: params, opts

func (*MockClientService_headscale_service) SetTransport 

func (_m *MockClientService_headscale_service) SetTransport(transport runtime.ClientTransport)

SetTransport provides a mock function with given fields: transport

type MockClientService_headscale_service_Expecter 

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

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceCreateAPIKey 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceCreateAPIKey(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call

HeadscaleServiceCreateAPIKey is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceCreateAPIKeyParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceCreatePreAuthKey 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceCreatePreAuthKey(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call

HeadscaleServiceCreatePreAuthKey is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceCreatePreAuthKeyParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceCreateUser 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceCreateUser(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call

HeadscaleServiceCreateUser is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceCreateUserParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceDebugCreateMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceDebugCreateMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call

HeadscaleServiceDebugCreateMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceDebugCreateMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceDeleteMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceDeleteMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call

HeadscaleServiceDeleteMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceDeleteMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceDeleteRoute 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceDeleteRoute(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call

HeadscaleServiceDeleteRoute is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceDeleteRouteParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceDeleteUser 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceDeleteUser(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call

HeadscaleServiceDeleteUser is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceDeleteUserParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceDisableRoute 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceDisableRoute(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call

HeadscaleServiceDisableRoute is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceDisableRouteParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceEnableRoute 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceEnableRoute(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call

HeadscaleServiceEnableRoute is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceEnableRouteParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceExpireAPIKey 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceExpireAPIKey(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call

HeadscaleServiceExpireAPIKey is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceExpireAPIKeyParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceExpireMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceExpireMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call

HeadscaleServiceExpireMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceExpireMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceExpirePreAuthKey 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceExpirePreAuthKey(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call

HeadscaleServiceExpirePreAuthKey is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceExpirePreAuthKeyParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceGetMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceGetMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call

HeadscaleServiceGetMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceGetMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceGetMachineRoutes 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceGetMachineRoutes(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call

HeadscaleServiceGetMachineRoutes is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceGetMachineRoutesParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceGetRoutes 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceGetRoutes(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call

HeadscaleServiceGetRoutes is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceGetRoutesParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceGetUser 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceGetUser(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceGetUser_Call

HeadscaleServiceGetUser is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceGetUserParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceListAPIKeys 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceListAPIKeys(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call

HeadscaleServiceListAPIKeys is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceListAPIKeysParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceListMachines 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceListMachines(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceListMachines_Call

HeadscaleServiceListMachines is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceListMachinesParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceListPreAuthKeys 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceListPreAuthKeys(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call

HeadscaleServiceListPreAuthKeys is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceListPreAuthKeysParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceListUsers 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceListUsers(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceListUsers_Call

HeadscaleServiceListUsers is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceListUsersParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceMoveMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceMoveMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call

HeadscaleServiceMoveMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceMoveMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceRegisterMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceRegisterMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call

HeadscaleServiceRegisterMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceRegisterMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceRenameMachine 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceRenameMachine(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call

HeadscaleServiceRenameMachine is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceRenameMachineParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceRenameUser 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceRenameUser(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call

HeadscaleServiceRenameUser is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceRenameUserParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) HeadscaleServiceSetTags 

func (_e *MockClientService_headscale_service_Expecter) HeadscaleServiceSetTags(params interface{}, opts ...interface{}) *MockClientService_headscale_service_HeadscaleServiceSetTags_Call

HeadscaleServiceSetTags is a helper method to define mock.On call

  • params *headscale_service.HeadscaleServiceSetTagsParams
  • opts ...headscale_service.ClientOption

func (*MockClientService_headscale_service_Expecter) SetTransport 

func (_e *MockClientService_headscale_service_Expecter) SetTransport(transport interface{}) *MockClientService_headscale_service_SetTransport_Call

SetTransport is a helper method to define mock.On call

  • transport runtime.ClientTransport

type MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call 

type MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call) Return(_a0 *headscale_service.HeadscaleServiceCreateAPIKeyOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call) Run(run func(params *headscale_service.HeadscaleServiceCreateAPIKeyParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceCreateAPIKeyParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceCreateAPIKeyOK, error)) *MockClientService_headscale_service_HeadscaleServiceCreateAPIKey_Call

type MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call 

type MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call) Return(_a0 *headscale_service.HeadscaleServiceCreatePreAuthKeyOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call) Run(run func(params *headscale_service.HeadscaleServiceCreatePreAuthKeyParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceCreatePreAuthKeyParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceCreatePreAuthKeyOK, error)) *MockClientService_headscale_service_HeadscaleServiceCreatePreAuthKey_Call

type MockClientService_headscale_service_HeadscaleServiceCreateUser_Call 

type MockClientService_headscale_service_HeadscaleServiceCreateUser_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceCreateUser_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call) Return(_a0 *headscale_service.HeadscaleServiceCreateUserOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceCreateUser_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call) Run(run func(params *headscale_service.HeadscaleServiceCreateUserParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceCreateUser_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceCreateUserParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceCreateUserOK, error)) *MockClientService_headscale_service_HeadscaleServiceCreateUser_Call

type MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceDebugCreateMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceDebugCreateMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceDebugCreateMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDebugCreateMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceDebugCreateMachine_Call

type MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceDeleteMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceDeleteMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceDeleteMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDeleteMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceDeleteMachine_Call

type MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call 

type MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call) Return(_a0 *headscale_service.HeadscaleServiceDeleteRouteOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call

func (*MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call) Run(run func(params *headscale_service.HeadscaleServiceDeleteRouteParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call

func (*MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceDeleteRouteParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDeleteRouteOK, error)) *MockClientService_headscale_service_HeadscaleServiceDeleteRoute_Call

type MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call 

type MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call) Return(_a0 *headscale_service.HeadscaleServiceDeleteUserOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call) Run(run func(params *headscale_service.HeadscaleServiceDeleteUserParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceDeleteUserParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDeleteUserOK, error)) *MockClientService_headscale_service_HeadscaleServiceDeleteUser_Call

type MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call 

type MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call) Return(_a0 *headscale_service.HeadscaleServiceDisableRouteOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call

func (*MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call) Run(run func(params *headscale_service.HeadscaleServiceDisableRouteParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call

func (*MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceDisableRouteParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceDisableRouteOK, error)) *MockClientService_headscale_service_HeadscaleServiceDisableRoute_Call

type MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call 

type MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call) Return(_a0 *headscale_service.HeadscaleServiceEnableRouteOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call

func (*MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call) Run(run func(params *headscale_service.HeadscaleServiceEnableRouteParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call

func (*MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceEnableRouteParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceEnableRouteOK, error)) *MockClientService_headscale_service_HeadscaleServiceEnableRoute_Call

type MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call 

type MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call) Return(_a0 *headscale_service.HeadscaleServiceExpireAPIKeyOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call) Run(run func(params *headscale_service.HeadscaleServiceExpireAPIKeyParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceExpireAPIKeyParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceExpireAPIKeyOK, error)) *MockClientService_headscale_service_HeadscaleServiceExpireAPIKey_Call

type MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceExpireMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceExpireMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceExpireMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceExpireMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceExpireMachine_Call

type MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call 

type MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call) Return(_a0 *headscale_service.HeadscaleServiceExpirePreAuthKeyOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call) Run(run func(params *headscale_service.HeadscaleServiceExpirePreAuthKeyParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call

func (*MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceExpirePreAuthKeyParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceExpirePreAuthKeyOK, error)) *MockClientService_headscale_service_HeadscaleServiceExpirePreAuthKey_Call

type MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call 

type MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call) Return(_a0 *headscale_service.HeadscaleServiceGetMachineRoutesOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call) Run(run func(params *headscale_service.HeadscaleServiceGetMachineRoutesParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceGetMachineRoutesParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetMachineRoutesOK, error)) *MockClientService_headscale_service_HeadscaleServiceGetMachineRoutes_Call

type MockClientService_headscale_service_HeadscaleServiceGetMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceGetMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceGetMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceGetMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceGetMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceGetMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceGetMachine_Call

type MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call 

type MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call) Return(_a0 *headscale_service.HeadscaleServiceGetRoutesOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call) Run(run func(params *headscale_service.HeadscaleServiceGetRoutesParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceGetRoutesParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetRoutesOK, error)) *MockClientService_headscale_service_HeadscaleServiceGetRoutes_Call

type MockClientService_headscale_service_HeadscaleServiceGetUser_Call 

type MockClientService_headscale_service_HeadscaleServiceGetUser_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceGetUser_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetUser_Call) Return(_a0 *headscale_service.HeadscaleServiceGetUserOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceGetUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetUser_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetUser_Call) Run(run func(params *headscale_service.HeadscaleServiceGetUserParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceGetUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceGetUser_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceGetUser_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceGetUserParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceGetUserOK, error)) *MockClientService_headscale_service_HeadscaleServiceGetUser_Call

type MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call 

type MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call) Return(_a0 *headscale_service.HeadscaleServiceListAPIKeysOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call

func (*MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call) Run(run func(params *headscale_service.HeadscaleServiceListAPIKeysParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call

func (*MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceListAPIKeysParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListAPIKeysOK, error)) *MockClientService_headscale_service_HeadscaleServiceListAPIKeys_Call

type MockClientService_headscale_service_HeadscaleServiceListMachines_Call 

type MockClientService_headscale_service_HeadscaleServiceListMachines_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceListMachines_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceListMachines_Call) Return(_a0 *headscale_service.HeadscaleServiceListMachinesOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceListMachines_Call

func (*MockClientService_headscale_service_HeadscaleServiceListMachines_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceListMachines_Call) Run(run func(params *headscale_service.HeadscaleServiceListMachinesParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceListMachines_Call

func (*MockClientService_headscale_service_HeadscaleServiceListMachines_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceListMachines_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceListMachinesParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListMachinesOK, error)) *MockClientService_headscale_service_HeadscaleServiceListMachines_Call

type MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call 

type MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call) Return(_a0 *headscale_service.HeadscaleServiceListPreAuthKeysOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call

func (*MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call) Run(run func(params *headscale_service.HeadscaleServiceListPreAuthKeysParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call

func (*MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceListPreAuthKeysParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListPreAuthKeysOK, error)) *MockClientService_headscale_service_HeadscaleServiceListPreAuthKeys_Call

type MockClientService_headscale_service_HeadscaleServiceListUsers_Call 

type MockClientService_headscale_service_HeadscaleServiceListUsers_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceListUsers_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceListUsers_Call) Return(_a0 *headscale_service.HeadscaleServiceListUsersOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceListUsers_Call

func (*MockClientService_headscale_service_HeadscaleServiceListUsers_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceListUsers_Call) Run(run func(params *headscale_service.HeadscaleServiceListUsersParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceListUsers_Call

func (*MockClientService_headscale_service_HeadscaleServiceListUsers_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceListUsers_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceListUsersParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceListUsersOK, error)) *MockClientService_headscale_service_HeadscaleServiceListUsers_Call

type MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceMoveMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceMoveMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceMoveMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceMoveMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceMoveMachine_Call

type MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceRegisterMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceRegisterMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceRegisterMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceRegisterMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceRegisterMachine_Call

type MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call 

type MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call) Return(_a0 *headscale_service.HeadscaleServiceRenameMachineOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call) Run(run func(params *headscale_service.HeadscaleServiceRenameMachineParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call

func (*MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceRenameMachineParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceRenameMachineOK, error)) *MockClientService_headscale_service_HeadscaleServiceRenameMachine_Call

type MockClientService_headscale_service_HeadscaleServiceRenameUser_Call 

type MockClientService_headscale_service_HeadscaleServiceRenameUser_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceRenameUser_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call) Return(_a0 *headscale_service.HeadscaleServiceRenameUserOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceRenameUser_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call) Run(run func(params *headscale_service.HeadscaleServiceRenameUserParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call

func (*MockClientService_headscale_service_HeadscaleServiceRenameUser_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceRenameUserParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceRenameUserOK, error)) *MockClientService_headscale_service_HeadscaleServiceRenameUser_Call

type MockClientService_headscale_service_HeadscaleServiceSetTags_Call 

type MockClientService_headscale_service_HeadscaleServiceSetTags_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_HeadscaleServiceSetTags_Call) Return 

func (_c *MockClientService_headscale_service_HeadscaleServiceSetTags_Call) Return(_a0 *headscale_service.HeadscaleServiceSetTagsOK, _a1 error) *MockClientService_headscale_service_HeadscaleServiceSetTags_Call

func (*MockClientService_headscale_service_HeadscaleServiceSetTags_Call) Run 

func (_c *MockClientService_headscale_service_HeadscaleServiceSetTags_Call) Run(run func(params *headscale_service.HeadscaleServiceSetTagsParams, opts ...headscale_service.ClientOption)) *MockClientService_headscale_service_HeadscaleServiceSetTags_Call

func (*MockClientService_headscale_service_HeadscaleServiceSetTags_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_HeadscaleServiceSetTags_Call) RunAndReturn(run func(*headscale_service.HeadscaleServiceSetTagsParams, ...headscale_service.ClientOption) (*headscale_service.HeadscaleServiceSetTagsOK, error)) *MockClientService_headscale_service_HeadscaleServiceSetTags_Call

type MockClientService_headscale_service_SetTransport_Call 

type MockClientService_headscale_service_SetTransport_Call struct {
	*mock.Call
}

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

func (*MockClientService_headscale_service_SetTransport_Call) Return 

func (_c *MockClientService_headscale_service_SetTransport_Call) Return() *MockClientService_headscale_service_SetTransport_Call

func (*MockClientService_headscale_service_SetTransport_Call) Run 

func (_c *MockClientService_headscale_service_SetTransport_Call) Run(run func(transport runtime.ClientTransport)) *MockClientService_headscale_service_SetTransport_Call

func (*MockClientService_headscale_service_SetTransport_Call) RunAndReturn 

func (_c *MockClientService_headscale_service_SetTransport_Call) RunAndReturn(run func(runtime.ClientTransport)) *MockClientService_headscale_service_SetTransport_Call

type MockEc2Client_interfaces 

type MockEc2Client_interfaces struct {
	mock.Mock
}

MockEc2Client_interfaces is an autogenerated mock type for the Ec2Client type

func NewMockEc2Client_interfaces 

func NewMockEc2Client_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEc2Client_interfaces

NewMockEc2Client_interfaces creates a new instance of MockEc2Client_interfaces. 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 (*MockEc2Client_interfaces) DescribeSecurityGroups 

func (_m *MockEc2Client_interfaces) DescribeSecurityGroups(ctx context.Context, params *ec2.DescribeSecurityGroupsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error)

DescribeSecurityGroups provides a mock function with given fields: ctx, params, optFns

func (*MockEc2Client_interfaces) DescribeSubnets 

func (_m *MockEc2Client_interfaces) DescribeSubnets(ctx context.Context, params *ec2.DescribeSubnetsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error)

DescribeSubnets provides a mock function with given fields: ctx, params, optFns

func (*MockEc2Client_interfaces) DescribeVpcs 

func (_m *MockEc2Client_interfaces) DescribeVpcs(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error)

DescribeVpcs provides a mock function with given fields: ctx, params, optFns

func (*MockEc2Client_interfaces) EXPECT 

func (_m *MockEc2Client_interfaces) EXPECT() *MockEc2Client_interfaces_Expecter

type MockEc2Client_interfaces_DescribeSecurityGroups_Call 

type MockEc2Client_interfaces_DescribeSecurityGroups_Call struct {
	*mock.Call
}

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

func (*MockEc2Client_interfaces_DescribeSecurityGroups_Call) Return 

func (_c *MockEc2Client_interfaces_DescribeSecurityGroups_Call) Return(_a0 *ec2.DescribeSecurityGroupsOutput, _a1 error) *MockEc2Client_interfaces_DescribeSecurityGroups_Call

func (*MockEc2Client_interfaces_DescribeSecurityGroups_Call) Run 

func (_c *MockEc2Client_interfaces_DescribeSecurityGroups_Call) Run(run func(ctx context.Context, params *ec2.DescribeSecurityGroupsInput, optFns ...func(*ec2.Options))) *MockEc2Client_interfaces_DescribeSecurityGroups_Call

func (*MockEc2Client_interfaces_DescribeSecurityGroups_Call) RunAndReturn 

func (_c *MockEc2Client_interfaces_DescribeSecurityGroups_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSecurityGroupsInput, ...func(*ec2.Options)) (*ec2.DescribeSecurityGroupsOutput, error)) *MockEc2Client_interfaces_DescribeSecurityGroups_Call

type MockEc2Client_interfaces_DescribeSubnets_Call 

type MockEc2Client_interfaces_DescribeSubnets_Call struct {
	*mock.Call
}

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

func (*MockEc2Client_interfaces_DescribeSubnets_Call) Return 

func (_c *MockEc2Client_interfaces_DescribeSubnets_Call) Return(_a0 *ec2.DescribeSubnetsOutput, _a1 error) *MockEc2Client_interfaces_DescribeSubnets_Call

func (*MockEc2Client_interfaces_DescribeSubnets_Call) Run 

func (_c *MockEc2Client_interfaces_DescribeSubnets_Call) Run(run func(ctx context.Context, params *ec2.DescribeSubnetsInput, optFns ...func(*ec2.Options))) *MockEc2Client_interfaces_DescribeSubnets_Call

func (*MockEc2Client_interfaces_DescribeSubnets_Call) RunAndReturn 

func (_c *MockEc2Client_interfaces_DescribeSubnets_Call) RunAndReturn(run func(context.Context, *ec2.DescribeSubnetsInput, ...func(*ec2.Options)) (*ec2.DescribeSubnetsOutput, error)) *MockEc2Client_interfaces_DescribeSubnets_Call

type MockEc2Client_interfaces_DescribeVpcs_Call 

type MockEc2Client_interfaces_DescribeVpcs_Call struct {
	*mock.Call
}

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

func (*MockEc2Client_interfaces_DescribeVpcs_Call) Return 

func (_c *MockEc2Client_interfaces_DescribeVpcs_Call) Return(_a0 *ec2.DescribeVpcsOutput, _a1 error) *MockEc2Client_interfaces_DescribeVpcs_Call

func (*MockEc2Client_interfaces_DescribeVpcs_Call) Run 

func (_c *MockEc2Client_interfaces_DescribeVpcs_Call) Run(run func(ctx context.Context, params *ec2.DescribeVpcsInput, optFns ...func(*ec2.Options))) *MockEc2Client_interfaces_DescribeVpcs_Call

func (*MockEc2Client_interfaces_DescribeVpcs_Call) RunAndReturn 

func (_c *MockEc2Client_interfaces_DescribeVpcs_Call) RunAndReturn(run func(context.Context, *ec2.DescribeVpcsInput, ...func(*ec2.Options)) (*ec2.DescribeVpcsOutput, error)) *MockEc2Client_interfaces_DescribeVpcs_Call

type MockEc2Client_interfaces_Expecter 

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

func (*MockEc2Client_interfaces_Expecter) DescribeSecurityGroups 

func (_e *MockEc2Client_interfaces_Expecter) DescribeSecurityGroups(ctx interface{}, params interface{}, optFns ...interface{}) *MockEc2Client_interfaces_DescribeSecurityGroups_Call

DescribeSecurityGroups is a helper method to define mock.On call

  • ctx context.Context
  • params *ec2.DescribeSecurityGroupsInput
  • optFns ...func(*ec2.Options)

func (*MockEc2Client_interfaces_Expecter) DescribeSubnets 

func (_e *MockEc2Client_interfaces_Expecter) DescribeSubnets(ctx interface{}, params interface{}, optFns ...interface{}) *MockEc2Client_interfaces_DescribeSubnets_Call

DescribeSubnets is a helper method to define mock.On call

  • ctx context.Context
  • params *ec2.DescribeSubnetsInput
  • optFns ...func(*ec2.Options)

func (*MockEc2Client_interfaces_Expecter) DescribeVpcs 

func (_e *MockEc2Client_interfaces_Expecter) DescribeVpcs(ctx interface{}, params interface{}, optFns ...interface{}) *MockEc2Client_interfaces_DescribeVpcs_Call

DescribeVpcs is a helper method to define mock.On call

  • ctx context.Context
  • params *ec2.DescribeVpcsInput
  • optFns ...func(*ec2.Options)

type MockEcsClient_interfaces 

type MockEcsClient_interfaces struct {
	mock.Mock
}

MockEcsClient_interfaces is an autogenerated mock type for the EcsClient type

func NewMockEcsClient_interfaces 

func NewMockEcsClient_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEcsClient_interfaces

NewMockEcsClient_interfaces creates a new instance of MockEcsClient_interfaces. 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 (*MockEcsClient_interfaces) CreateCluster 

func (_m *MockEcsClient_interfaces) CreateCluster(ctx context.Context, params *ecs.CreateClusterInput, optFns ...func(*ecs.Options)) (*ecs.CreateClusterOutput, error)

CreateCluster provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) CreateService 

func (_m *MockEcsClient_interfaces) CreateService(ctx context.Context, params *ecs.CreateServiceInput, optFns ...func(*ecs.Options)) (*ecs.CreateServiceOutput, error)

CreateService provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) CreateTaskSet 

func (_m *MockEcsClient_interfaces) CreateTaskSet(ctx context.Context, params *ecs.CreateTaskSetInput, optFns ...func(*ecs.Options)) (*ecs.CreateTaskSetOutput, error)

CreateTaskSet provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) DeleteService 

func (_m *MockEcsClient_interfaces) DeleteService(ctx context.Context, params *ecs.DeleteServiceInput, optFns ...func(*ecs.Options)) (*ecs.DeleteServiceOutput, error)

DeleteService provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) DeleteTaskDefinitions 

func (_m *MockEcsClient_interfaces) DeleteTaskDefinitions(ctx context.Context, params *ecs.DeleteTaskDefinitionsInput, optFns ...func(*ecs.Options)) (*ecs.DeleteTaskDefinitionsOutput, error)

DeleteTaskDefinitions provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) DeregisterTaskDefinition 

func (_m *MockEcsClient_interfaces) DeregisterTaskDefinition(ctx context.Context, params *ecs.DeregisterTaskDefinitionInput, optFns ...func(*ecs.Options)) (*ecs.DeregisterTaskDefinitionOutput, error)

DeregisterTaskDefinition provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) DescribeClusters 

func (_m *MockEcsClient_interfaces) DescribeClusters(ctx context.Context, params *ecs.DescribeClustersInput, optFns ...func(*ecs.Options)) (*ecs.DescribeClustersOutput, error)

DescribeClusters provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) DescribeServices 

func (_m *MockEcsClient_interfaces) DescribeServices(ctx context.Context, params *ecs.DescribeServicesInput, optFns ...func(*ecs.Options)) (*ecs.DescribeServicesOutput, error)

DescribeServices provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) DescribeTasks 

func (_m *MockEcsClient_interfaces) DescribeTasks(ctx context.Context, params *ecs.DescribeTasksInput, optFns ...func(*ecs.Options)) (*ecs.DescribeTasksOutput, error)

DescribeTasks provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) EXPECT 

func (_m *MockEcsClient_interfaces) EXPECT() *MockEcsClient_interfaces_Expecter

func (*MockEcsClient_interfaces) ListClusters 

func (_m *MockEcsClient_interfaces) ListClusters(ctx context.Context, params *ecs.ListClustersInput, optFns ...func(*ecs.Options)) (*ecs.ListClustersOutput, error)

ListClusters provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) ListTasks 

func (_m *MockEcsClient_interfaces) ListTasks(ctx context.Context, params *ecs.ListTasksInput, optFns ...func(*ecs.Options)) (*ecs.ListTasksOutput, error)

ListTasks provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) RegisterTaskDefinition 

func (_m *MockEcsClient_interfaces) RegisterTaskDefinition(ctx context.Context, params *ecs.RegisterTaskDefinitionInput, optFns ...func(*ecs.Options)) (*ecs.RegisterTaskDefinitionOutput, error)

RegisterTaskDefinition provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) RunTask 

func (_m *MockEcsClient_interfaces) RunTask(ctx context.Context, params *ecs.RunTaskInput, optFns ...func(*ecs.Options)) (*ecs.RunTaskOutput, error)

RunTask provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) StopTask 

func (_m *MockEcsClient_interfaces) StopTask(ctx context.Context, params *ecs.StopTaskInput, optFns ...func(*ecs.Options)) (*ecs.StopTaskOutput, error)

StopTask provides a mock function with given fields: ctx, params, optFns

func (*MockEcsClient_interfaces) UpdateService 

func (_m *MockEcsClient_interfaces) UpdateService(ctx context.Context, params *ecs.UpdateServiceInput, optFns ...func(*ecs.Options)) (*ecs.UpdateServiceOutput, error)

UpdateService provides a mock function with given fields: ctx, params, optFns

type MockEcsClient_interfaces_CreateCluster_Call 

type MockEcsClient_interfaces_CreateCluster_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_CreateCluster_Call) Return 

func (_c *MockEcsClient_interfaces_CreateCluster_Call) Return(_a0 *ecs.CreateClusterOutput, _a1 error) *MockEcsClient_interfaces_CreateCluster_Call

func (*MockEcsClient_interfaces_CreateCluster_Call) Run 

func (_c *MockEcsClient_interfaces_CreateCluster_Call) Run(run func(ctx context.Context, params *ecs.CreateClusterInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_CreateCluster_Call

func (*MockEcsClient_interfaces_CreateCluster_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_CreateCluster_Call) RunAndReturn(run func(context.Context, *ecs.CreateClusterInput, ...func(*ecs.Options)) (*ecs.CreateClusterOutput, error)) *MockEcsClient_interfaces_CreateCluster_Call

type MockEcsClient_interfaces_CreateService_Call 

type MockEcsClient_interfaces_CreateService_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_CreateService_Call) Return 

func (_c *MockEcsClient_interfaces_CreateService_Call) Return(_a0 *ecs.CreateServiceOutput, _a1 error) *MockEcsClient_interfaces_CreateService_Call

func (*MockEcsClient_interfaces_CreateService_Call) Run 

func (_c *MockEcsClient_interfaces_CreateService_Call) Run(run func(ctx context.Context, params *ecs.CreateServiceInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_CreateService_Call

func (*MockEcsClient_interfaces_CreateService_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_CreateService_Call) RunAndReturn(run func(context.Context, *ecs.CreateServiceInput, ...func(*ecs.Options)) (*ecs.CreateServiceOutput, error)) *MockEcsClient_interfaces_CreateService_Call

type MockEcsClient_interfaces_CreateTaskSet_Call 

type MockEcsClient_interfaces_CreateTaskSet_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_CreateTaskSet_Call) Return 

func (_c *MockEcsClient_interfaces_CreateTaskSet_Call) Return(_a0 *ecs.CreateTaskSetOutput, _a1 error) *MockEcsClient_interfaces_CreateTaskSet_Call

func (*MockEcsClient_interfaces_CreateTaskSet_Call) Run 

func (_c *MockEcsClient_interfaces_CreateTaskSet_Call) Run(run func(ctx context.Context, params *ecs.CreateTaskSetInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_CreateTaskSet_Call

func (*MockEcsClient_interfaces_CreateTaskSet_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_CreateTaskSet_Call) RunAndReturn(run func(context.Context, *ecs.CreateTaskSetInput, ...func(*ecs.Options)) (*ecs.CreateTaskSetOutput, error)) *MockEcsClient_interfaces_CreateTaskSet_Call

type MockEcsClient_interfaces_DeleteService_Call 

type MockEcsClient_interfaces_DeleteService_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_DeleteService_Call) Return 

func (_c *MockEcsClient_interfaces_DeleteService_Call) Return(_a0 *ecs.DeleteServiceOutput, _a1 error) *MockEcsClient_interfaces_DeleteService_Call

func (*MockEcsClient_interfaces_DeleteService_Call) Run 

func (_c *MockEcsClient_interfaces_DeleteService_Call) Run(run func(ctx context.Context, params *ecs.DeleteServiceInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_DeleteService_Call

func (*MockEcsClient_interfaces_DeleteService_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_DeleteService_Call) RunAndReturn(run func(context.Context, *ecs.DeleteServiceInput, ...func(*ecs.Options)) (*ecs.DeleteServiceOutput, error)) *MockEcsClient_interfaces_DeleteService_Call

type MockEcsClient_interfaces_DeleteTaskDefinitions_Call 

type MockEcsClient_interfaces_DeleteTaskDefinitions_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_DeleteTaskDefinitions_Call) Return 

func (_c *MockEcsClient_interfaces_DeleteTaskDefinitions_Call) Return(_a0 *ecs.DeleteTaskDefinitionsOutput, _a1 error) *MockEcsClient_interfaces_DeleteTaskDefinitions_Call

func (*MockEcsClient_interfaces_DeleteTaskDefinitions_Call) Run 

func (_c *MockEcsClient_interfaces_DeleteTaskDefinitions_Call) Run(run func(ctx context.Context, params *ecs.DeleteTaskDefinitionsInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_DeleteTaskDefinitions_Call

func (*MockEcsClient_interfaces_DeleteTaskDefinitions_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_DeleteTaskDefinitions_Call) RunAndReturn(run func(context.Context, *ecs.DeleteTaskDefinitionsInput, ...func(*ecs.Options)) (*ecs.DeleteTaskDefinitionsOutput, error)) *MockEcsClient_interfaces_DeleteTaskDefinitions_Call

type MockEcsClient_interfaces_DeregisterTaskDefinition_Call 

type MockEcsClient_interfaces_DeregisterTaskDefinition_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_DeregisterTaskDefinition_Call) Return 

func (_c *MockEcsClient_interfaces_DeregisterTaskDefinition_Call) Return(_a0 *ecs.DeregisterTaskDefinitionOutput, _a1 error) *MockEcsClient_interfaces_DeregisterTaskDefinition_Call

func (*MockEcsClient_interfaces_DeregisterTaskDefinition_Call) Run 

func (_c *MockEcsClient_interfaces_DeregisterTaskDefinition_Call) Run(run func(ctx context.Context, params *ecs.DeregisterTaskDefinitionInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_DeregisterTaskDefinition_Call

func (*MockEcsClient_interfaces_DeregisterTaskDefinition_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_DeregisterTaskDefinition_Call) RunAndReturn(run func(context.Context, *ecs.DeregisterTaskDefinitionInput, ...func(*ecs.Options)) (*ecs.DeregisterTaskDefinitionOutput, error)) *MockEcsClient_interfaces_DeregisterTaskDefinition_Call

type MockEcsClient_interfaces_DescribeClusters_Call 

type MockEcsClient_interfaces_DescribeClusters_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_DescribeClusters_Call) Return 

func (_c *MockEcsClient_interfaces_DescribeClusters_Call) Return(_a0 *ecs.DescribeClustersOutput, _a1 error) *MockEcsClient_interfaces_DescribeClusters_Call

func (*MockEcsClient_interfaces_DescribeClusters_Call) Run 

func (_c *MockEcsClient_interfaces_DescribeClusters_Call) Run(run func(ctx context.Context, params *ecs.DescribeClustersInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_DescribeClusters_Call

func (*MockEcsClient_interfaces_DescribeClusters_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_DescribeClusters_Call) RunAndReturn(run func(context.Context, *ecs.DescribeClustersInput, ...func(*ecs.Options)) (*ecs.DescribeClustersOutput, error)) *MockEcsClient_interfaces_DescribeClusters_Call

type MockEcsClient_interfaces_DescribeServices_Call 

type MockEcsClient_interfaces_DescribeServices_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_DescribeServices_Call) Return 

func (_c *MockEcsClient_interfaces_DescribeServices_Call) Return(_a0 *ecs.DescribeServicesOutput, _a1 error) *MockEcsClient_interfaces_DescribeServices_Call

func (*MockEcsClient_interfaces_DescribeServices_Call) Run 

func (_c *MockEcsClient_interfaces_DescribeServices_Call) Run(run func(ctx context.Context, params *ecs.DescribeServicesInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_DescribeServices_Call

func (*MockEcsClient_interfaces_DescribeServices_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_DescribeServices_Call) RunAndReturn(run func(context.Context, *ecs.DescribeServicesInput, ...func(*ecs.Options)) (*ecs.DescribeServicesOutput, error)) *MockEcsClient_interfaces_DescribeServices_Call

type MockEcsClient_interfaces_DescribeTasks_Call 

type MockEcsClient_interfaces_DescribeTasks_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_DescribeTasks_Call) Return 

func (_c *MockEcsClient_interfaces_DescribeTasks_Call) Return(_a0 *ecs.DescribeTasksOutput, _a1 error) *MockEcsClient_interfaces_DescribeTasks_Call

func (*MockEcsClient_interfaces_DescribeTasks_Call) Run 

func (_c *MockEcsClient_interfaces_DescribeTasks_Call) Run(run func(ctx context.Context, params *ecs.DescribeTasksInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_DescribeTasks_Call

func (*MockEcsClient_interfaces_DescribeTasks_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_DescribeTasks_Call) RunAndReturn(run func(context.Context, *ecs.DescribeTasksInput, ...func(*ecs.Options)) (*ecs.DescribeTasksOutput, error)) *MockEcsClient_interfaces_DescribeTasks_Call

type MockEcsClient_interfaces_Expecter 

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

func (*MockEcsClient_interfaces_Expecter) CreateCluster 

func (_e *MockEcsClient_interfaces_Expecter) CreateCluster(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_CreateCluster_Call

CreateCluster is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.CreateClusterInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) CreateService 

func (_e *MockEcsClient_interfaces_Expecter) CreateService(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_CreateService_Call

CreateService is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.CreateServiceInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) CreateTaskSet 

func (_e *MockEcsClient_interfaces_Expecter) CreateTaskSet(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_CreateTaskSet_Call

CreateTaskSet is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.CreateTaskSetInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) DeleteService 

func (_e *MockEcsClient_interfaces_Expecter) DeleteService(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_DeleteService_Call

DeleteService is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.DeleteServiceInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) DeleteTaskDefinitions 

func (_e *MockEcsClient_interfaces_Expecter) DeleteTaskDefinitions(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_DeleteTaskDefinitions_Call

DeleteTaskDefinitions is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.DeleteTaskDefinitionsInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) DeregisterTaskDefinition 

func (_e *MockEcsClient_interfaces_Expecter) DeregisterTaskDefinition(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_DeregisterTaskDefinition_Call

DeregisterTaskDefinition is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.DeregisterTaskDefinitionInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) DescribeClusters 

func (_e *MockEcsClient_interfaces_Expecter) DescribeClusters(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_DescribeClusters_Call

DescribeClusters is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.DescribeClustersInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) DescribeServices 

func (_e *MockEcsClient_interfaces_Expecter) DescribeServices(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_DescribeServices_Call

DescribeServices is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.DescribeServicesInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) DescribeTasks 

func (_e *MockEcsClient_interfaces_Expecter) DescribeTasks(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_DescribeTasks_Call

DescribeTasks is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.DescribeTasksInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) ListClusters 

func (_e *MockEcsClient_interfaces_Expecter) ListClusters(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_ListClusters_Call

ListClusters is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.ListClustersInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) ListTasks 

func (_e *MockEcsClient_interfaces_Expecter) ListTasks(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_ListTasks_Call

ListTasks is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.ListTasksInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) RegisterTaskDefinition 

func (_e *MockEcsClient_interfaces_Expecter) RegisterTaskDefinition(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_RegisterTaskDefinition_Call

RegisterTaskDefinition is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.RegisterTaskDefinitionInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) RunTask 

func (_e *MockEcsClient_interfaces_Expecter) RunTask(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_RunTask_Call

RunTask is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.RunTaskInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) StopTask 

func (_e *MockEcsClient_interfaces_Expecter) StopTask(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_StopTask_Call

StopTask is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.StopTaskInput
  • optFns ...func(*ecs.Options)

func (*MockEcsClient_interfaces_Expecter) UpdateService 

func (_e *MockEcsClient_interfaces_Expecter) UpdateService(ctx interface{}, params interface{}, optFns ...interface{}) *MockEcsClient_interfaces_UpdateService_Call

UpdateService is a helper method to define mock.On call

  • ctx context.Context
  • params *ecs.UpdateServiceInput
  • optFns ...func(*ecs.Options)

type MockEcsClient_interfaces_ListClusters_Call 

type MockEcsClient_interfaces_ListClusters_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_ListClusters_Call) Return 

func (_c *MockEcsClient_interfaces_ListClusters_Call) Return(_a0 *ecs.ListClustersOutput, _a1 error) *MockEcsClient_interfaces_ListClusters_Call

func (*MockEcsClient_interfaces_ListClusters_Call) Run 

func (_c *MockEcsClient_interfaces_ListClusters_Call) Run(run func(ctx context.Context, params *ecs.ListClustersInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_ListClusters_Call

func (*MockEcsClient_interfaces_ListClusters_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_ListClusters_Call) RunAndReturn(run func(context.Context, *ecs.ListClustersInput, ...func(*ecs.Options)) (*ecs.ListClustersOutput, error)) *MockEcsClient_interfaces_ListClusters_Call

type MockEcsClient_interfaces_ListTasks_Call 

type MockEcsClient_interfaces_ListTasks_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_ListTasks_Call) Return 

func (_c *MockEcsClient_interfaces_ListTasks_Call) Return(_a0 *ecs.ListTasksOutput, _a1 error) *MockEcsClient_interfaces_ListTasks_Call

func (*MockEcsClient_interfaces_ListTasks_Call) Run 

func (_c *MockEcsClient_interfaces_ListTasks_Call) Run(run func(ctx context.Context, params *ecs.ListTasksInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_ListTasks_Call

func (*MockEcsClient_interfaces_ListTasks_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_ListTasks_Call) RunAndReturn(run func(context.Context, *ecs.ListTasksInput, ...func(*ecs.Options)) (*ecs.ListTasksOutput, error)) *MockEcsClient_interfaces_ListTasks_Call

type MockEcsClient_interfaces_RegisterTaskDefinition_Call 

type MockEcsClient_interfaces_RegisterTaskDefinition_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_RegisterTaskDefinition_Call) Return 

func (_c *MockEcsClient_interfaces_RegisterTaskDefinition_Call) Return(_a0 *ecs.RegisterTaskDefinitionOutput, _a1 error) *MockEcsClient_interfaces_RegisterTaskDefinition_Call

func (*MockEcsClient_interfaces_RegisterTaskDefinition_Call) Run 

func (_c *MockEcsClient_interfaces_RegisterTaskDefinition_Call) Run(run func(ctx context.Context, params *ecs.RegisterTaskDefinitionInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_RegisterTaskDefinition_Call

func (*MockEcsClient_interfaces_RegisterTaskDefinition_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_RegisterTaskDefinition_Call) RunAndReturn(run func(context.Context, *ecs.RegisterTaskDefinitionInput, ...func(*ecs.Options)) (*ecs.RegisterTaskDefinitionOutput, error)) *MockEcsClient_interfaces_RegisterTaskDefinition_Call

type MockEcsClient_interfaces_RunTask_Call 

type MockEcsClient_interfaces_RunTask_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_RunTask_Call) Return 

func (_c *MockEcsClient_interfaces_RunTask_Call) Return(_a0 *ecs.RunTaskOutput, _a1 error) *MockEcsClient_interfaces_RunTask_Call

func (*MockEcsClient_interfaces_RunTask_Call) Run 

func (_c *MockEcsClient_interfaces_RunTask_Call) Run(run func(ctx context.Context, params *ecs.RunTaskInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_RunTask_Call

func (*MockEcsClient_interfaces_RunTask_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_RunTask_Call) RunAndReturn(run func(context.Context, *ecs.RunTaskInput, ...func(*ecs.Options)) (*ecs.RunTaskOutput, error)) *MockEcsClient_interfaces_RunTask_Call

type MockEcsClient_interfaces_StopTask_Call 

type MockEcsClient_interfaces_StopTask_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_StopTask_Call) Return 

func (_c *MockEcsClient_interfaces_StopTask_Call) Return(_a0 *ecs.StopTaskOutput, _a1 error) *MockEcsClient_interfaces_StopTask_Call

func (*MockEcsClient_interfaces_StopTask_Call) Run 

func (_c *MockEcsClient_interfaces_StopTask_Call) Run(run func(ctx context.Context, params *ecs.StopTaskInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_StopTask_Call

func (*MockEcsClient_interfaces_StopTask_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_StopTask_Call) RunAndReturn(run func(context.Context, *ecs.StopTaskInput, ...func(*ecs.Options)) (*ecs.StopTaskOutput, error)) *MockEcsClient_interfaces_StopTask_Call

type MockEcsClient_interfaces_UpdateService_Call 

type MockEcsClient_interfaces_UpdateService_Call struct {
	*mock.Call
}

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

func (*MockEcsClient_interfaces_UpdateService_Call) Return 

func (_c *MockEcsClient_interfaces_UpdateService_Call) Return(_a0 *ecs.UpdateServiceOutput, _a1 error) *MockEcsClient_interfaces_UpdateService_Call

func (*MockEcsClient_interfaces_UpdateService_Call) Run 

func (_c *MockEcsClient_interfaces_UpdateService_Call) Run(run func(ctx context.Context, params *ecs.UpdateServiceInput, optFns ...func(*ecs.Options))) *MockEcsClient_interfaces_UpdateService_Call

func (*MockEcsClient_interfaces_UpdateService_Call) RunAndReturn 

func (_c *MockEcsClient_interfaces_UpdateService_Call) RunAndReturn(run func(context.Context, *ecs.UpdateServiceInput, ...func(*ecs.Options)) (*ecs.UpdateServiceOutput, error)) *MockEcsClient_interfaces_UpdateService_Call

type MockExecution_repository 

type MockExecution_repository struct {
	mock.Mock
}

MockExecution_repository is an autogenerated mock type for the Execution type

func NewMockExecution_repository 

func NewMockExecution_repository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExecution_repository

NewMockExecution_repository creates a new instance of MockExecution_repository. 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 (*MockExecution_repository) CloseExecution 

func (_m *MockExecution_repository) CloseExecution(ctx context.Context, id workflow.ExecutionIdentifier, result workflow.Status, msg []string) error

CloseExecution provides a mock function with given fields: ctx, id, result, msg

func (*MockExecution_repository) CreateExecution 

func (_m *MockExecution_repository) CreateExecution(ctx context.Context, ex *workflow.Execution) error

CreateExecution provides a mock function with given fields: ctx, ex

func (*MockExecution_repository) EXPECT 

func (_m *MockExecution_repository) EXPECT() *MockExecution_repository_Expecter

func (*MockExecution_repository) GetExecution 

func (_m *MockExecution_repository) GetExecution(ctx context.Context, id workflow.ExecutionIdentifier) (*workflow.Execution, error)

GetExecution provides a mock function with given fields: ctx, id

func (*MockExecution_repository) Init 

func (_m *MockExecution_repository) Init(ctx context.Context) error

Init provides a mock function with given fields: ctx

type MockExecution_repository_CloseExecution_Call 

type MockExecution_repository_CloseExecution_Call struct {
	*mock.Call
}

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

func (*MockExecution_repository_CloseExecution_Call) Return 

func (_c *MockExecution_repository_CloseExecution_Call) Return(_a0 error) *MockExecution_repository_CloseExecution_Call

func (*MockExecution_repository_CloseExecution_Call) Run 

func (_c *MockExecution_repository_CloseExecution_Call) Run(run func(ctx context.Context, id workflow.ExecutionIdentifier, result workflow.Status, msg []string)) *MockExecution_repository_CloseExecution_Call

func (*MockExecution_repository_CloseExecution_Call) RunAndReturn 

func (_c *MockExecution_repository_CloseExecution_Call) RunAndReturn(run func(context.Context, workflow.ExecutionIdentifier, workflow.Status, []string) error) *MockExecution_repository_CloseExecution_Call

type MockExecution_repository_CreateExecution_Call 

type MockExecution_repository_CreateExecution_Call struct {
	*mock.Call
}

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

func (*MockExecution_repository_CreateExecution_Call) Return 

func (_c *MockExecution_repository_CreateExecution_Call) Return(_a0 error) *MockExecution_repository_CreateExecution_Call

func (*MockExecution_repository_CreateExecution_Call) Run 

func (_c *MockExecution_repository_CreateExecution_Call) Run(run func(ctx context.Context, ex *workflow.Execution)) *MockExecution_repository_CreateExecution_Call

func (*MockExecution_repository_CreateExecution_Call) RunAndReturn 

func (_c *MockExecution_repository_CreateExecution_Call) RunAndReturn(run func(context.Context, *workflow.Execution) error) *MockExecution_repository_CreateExecution_Call

type MockExecution_repository_Expecter 

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

func (*MockExecution_repository_Expecter) CloseExecution 

func (_e *MockExecution_repository_Expecter) CloseExecution(ctx interface{}, id interface{}, result interface{}, msg interface{}) *MockExecution_repository_CloseExecution_Call

CloseExecution is a helper method to define mock.On call

  • ctx context.Context
  • id workflow.ExecutionIdentifier
  • result workflow.Status
  • msg []string

func (*MockExecution_repository_Expecter) CreateExecution 

func (_e *MockExecution_repository_Expecter) CreateExecution(ctx interface{}, ex interface{}) *MockExecution_repository_CreateExecution_Call

CreateExecution is a helper method to define mock.On call

  • ctx context.Context
  • ex *workflow.Execution

func (*MockExecution_repository_Expecter) GetExecution 

func (_e *MockExecution_repository_Expecter) GetExecution(ctx interface{}, id interface{}) *MockExecution_repository_GetExecution_Call

GetExecution is a helper method to define mock.On call

  • ctx context.Context
  • id workflow.ExecutionIdentifier

func (*MockExecution_repository_Expecter) Init 

func (_e *MockExecution_repository_Expecter) Init(ctx interface{}) *MockExecution_repository_Init_Call

Init is a helper method to define mock.On call

  • ctx context.Context

type MockExecution_repository_GetExecution_Call 

type MockExecution_repository_GetExecution_Call struct {
	*mock.Call
}

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

func (*MockExecution_repository_GetExecution_Call) Return 

func (_c *MockExecution_repository_GetExecution_Call) Return(_a0 *workflow.Execution, _a1 error) *MockExecution_repository_GetExecution_Call

func (*MockExecution_repository_GetExecution_Call) Run 

func (_c *MockExecution_repository_GetExecution_Call) Run(run func(ctx context.Context, id workflow.ExecutionIdentifier)) *MockExecution_repository_GetExecution_Call

func (*MockExecution_repository_GetExecution_Call) RunAndReturn 

func (_c *MockExecution_repository_GetExecution_Call) RunAndReturn(run func(context.Context, workflow.ExecutionIdentifier) (*workflow.Execution, error)) *MockExecution_repository_GetExecution_Call

type MockExecution_repository_Init_Call 

type MockExecution_repository_Init_Call struct {
	*mock.Call
}

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

func (*MockExecution_repository_Init_Call) Return 

func (_c *MockExecution_repository_Init_Call) Return(_a0 error) *MockExecution_repository_Init_Call

func (*MockExecution_repository_Init_Call) Run 

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

func (*MockExecution_repository_Init_Call) RunAndReturn 

func (_c *MockExecution_repository_Init_Call) RunAndReturn(run func(context.Context) error) *MockExecution_repository_Init_Call

type MockIamClient_interfaces 

type MockIamClient_interfaces struct {
	mock.Mock
}

MockIamClient_interfaces is an autogenerated mock type for the IamClient type

func NewMockIamClient_interfaces 

func NewMockIamClient_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockIamClient_interfaces

NewMockIamClient_interfaces creates a new instance of MockIamClient_interfaces. 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 (*MockIamClient_interfaces) AttachRolePolicy 

func (_m *MockIamClient_interfaces) AttachRolePolicy(ctx context.Context, params *iam.AttachRolePolicyInput, optFns ...func(*iam.Options)) (*iam.AttachRolePolicyOutput, error)

AttachRolePolicy provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) CreatePolicy 

func (_m *MockIamClient_interfaces) CreatePolicy(ctx context.Context, params *iam.CreatePolicyInput, optFns ...func(*iam.Options)) (*iam.CreatePolicyOutput, error)

CreatePolicy provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) CreateRole 

func (_m *MockIamClient_interfaces) CreateRole(ctx context.Context, params *iam.CreateRoleInput, optFns ...func(*iam.Options)) (*iam.CreateRoleOutput, error)

CreateRole provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) DeletePolicy 

func (_m *MockIamClient_interfaces) DeletePolicy(ctx context.Context, params *iam.DeletePolicyInput, optFns ...func(*iam.Options)) (*iam.DeletePolicyOutput, error)

DeletePolicy provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) DeleteRole 

func (_m *MockIamClient_interfaces) DeleteRole(ctx context.Context, params *iam.DeleteRoleInput, optFns ...func(*iam.Options)) (*iam.DeleteRoleOutput, error)

DeleteRole provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) DeleteRolePolicy 

func (_m *MockIamClient_interfaces) DeleteRolePolicy(ctx context.Context, params *iam.DeleteRolePolicyInput, optFns ...func(*iam.Options)) (*iam.DeleteRolePolicyOutput, error)

DeleteRolePolicy provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) DetachRolePolicy 

func (_m *MockIamClient_interfaces) DetachRolePolicy(ctx context.Context, params *iam.DetachRolePolicyInput, optFns ...func(*iam.Options)) (*iam.DetachRolePolicyOutput, error)

DetachRolePolicy provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) EXPECT 

func (_m *MockIamClient_interfaces) EXPECT() *MockIamClient_interfaces_Expecter

func (*MockIamClient_interfaces) GetRole 

func (_m *MockIamClient_interfaces) GetRole(ctx context.Context, params *iam.GetRoleInput, optFns ...func(*iam.Options)) (*iam.GetRoleOutput, error)

GetRole provides a mock function with given fields: ctx, params, optFns

func (*MockIamClient_interfaces) ListAttachedRolePolicies 

func (_m *MockIamClient_interfaces) ListAttachedRolePolicies(ctx context.Context, params *iam.ListAttachedRolePoliciesInput, optFns ...func(*iam.Options)) (*iam.ListAttachedRolePoliciesOutput, error)

ListAttachedRolePolicies provides a mock function with given fields: ctx, params, optFns

type MockIamClient_interfaces_AttachRolePolicy_Call 

type MockIamClient_interfaces_AttachRolePolicy_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_AttachRolePolicy_Call) Return 

func (_c *MockIamClient_interfaces_AttachRolePolicy_Call) Return(_a0 *iam.AttachRolePolicyOutput, _a1 error) *MockIamClient_interfaces_AttachRolePolicy_Call

func (*MockIamClient_interfaces_AttachRolePolicy_Call) Run 

func (_c *MockIamClient_interfaces_AttachRolePolicy_Call) Run(run func(ctx context.Context, params *iam.AttachRolePolicyInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_AttachRolePolicy_Call

func (*MockIamClient_interfaces_AttachRolePolicy_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_AttachRolePolicy_Call) RunAndReturn(run func(context.Context, *iam.AttachRolePolicyInput, ...func(*iam.Options)) (*iam.AttachRolePolicyOutput, error)) *MockIamClient_interfaces_AttachRolePolicy_Call

type MockIamClient_interfaces_CreatePolicy_Call 

type MockIamClient_interfaces_CreatePolicy_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_CreatePolicy_Call) Return 

func (_c *MockIamClient_interfaces_CreatePolicy_Call) Return(_a0 *iam.CreatePolicyOutput, _a1 error) *MockIamClient_interfaces_CreatePolicy_Call

func (*MockIamClient_interfaces_CreatePolicy_Call) Run 

func (_c *MockIamClient_interfaces_CreatePolicy_Call) Run(run func(ctx context.Context, params *iam.CreatePolicyInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_CreatePolicy_Call

func (*MockIamClient_interfaces_CreatePolicy_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_CreatePolicy_Call) RunAndReturn(run func(context.Context, *iam.CreatePolicyInput, ...func(*iam.Options)) (*iam.CreatePolicyOutput, error)) *MockIamClient_interfaces_CreatePolicy_Call

type MockIamClient_interfaces_CreateRole_Call 

type MockIamClient_interfaces_CreateRole_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_CreateRole_Call) Return 

func (_c *MockIamClient_interfaces_CreateRole_Call) Return(_a0 *iam.CreateRoleOutput, _a1 error) *MockIamClient_interfaces_CreateRole_Call

func (*MockIamClient_interfaces_CreateRole_Call) Run 

func (_c *MockIamClient_interfaces_CreateRole_Call) Run(run func(ctx context.Context, params *iam.CreateRoleInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_CreateRole_Call

func (*MockIamClient_interfaces_CreateRole_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_CreateRole_Call) RunAndReturn(run func(context.Context, *iam.CreateRoleInput, ...func(*iam.Options)) (*iam.CreateRoleOutput, error)) *MockIamClient_interfaces_CreateRole_Call

type MockIamClient_interfaces_DeletePolicy_Call 

type MockIamClient_interfaces_DeletePolicy_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_DeletePolicy_Call) Return 

func (_c *MockIamClient_interfaces_DeletePolicy_Call) Return(_a0 *iam.DeletePolicyOutput, _a1 error) *MockIamClient_interfaces_DeletePolicy_Call

func (*MockIamClient_interfaces_DeletePolicy_Call) Run 

func (_c *MockIamClient_interfaces_DeletePolicy_Call) Run(run func(ctx context.Context, params *iam.DeletePolicyInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_DeletePolicy_Call

func (*MockIamClient_interfaces_DeletePolicy_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_DeletePolicy_Call) RunAndReturn(run func(context.Context, *iam.DeletePolicyInput, ...func(*iam.Options)) (*iam.DeletePolicyOutput, error)) *MockIamClient_interfaces_DeletePolicy_Call

type MockIamClient_interfaces_DeleteRolePolicy_Call 

type MockIamClient_interfaces_DeleteRolePolicy_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_DeleteRolePolicy_Call) Return 

func (_c *MockIamClient_interfaces_DeleteRolePolicy_Call) Return(_a0 *iam.DeleteRolePolicyOutput, _a1 error) *MockIamClient_interfaces_DeleteRolePolicy_Call

func (*MockIamClient_interfaces_DeleteRolePolicy_Call) Run 

func (_c *MockIamClient_interfaces_DeleteRolePolicy_Call) Run(run func(ctx context.Context, params *iam.DeleteRolePolicyInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_DeleteRolePolicy_Call

func (*MockIamClient_interfaces_DeleteRolePolicy_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_DeleteRolePolicy_Call) RunAndReturn(run func(context.Context, *iam.DeleteRolePolicyInput, ...func(*iam.Options)) (*iam.DeleteRolePolicyOutput, error)) *MockIamClient_interfaces_DeleteRolePolicy_Call

type MockIamClient_interfaces_DeleteRole_Call 

type MockIamClient_interfaces_DeleteRole_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_DeleteRole_Call) Return 

func (_c *MockIamClient_interfaces_DeleteRole_Call) Return(_a0 *iam.DeleteRoleOutput, _a1 error) *MockIamClient_interfaces_DeleteRole_Call

func (*MockIamClient_interfaces_DeleteRole_Call) Run 

func (_c *MockIamClient_interfaces_DeleteRole_Call) Run(run func(ctx context.Context, params *iam.DeleteRoleInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_DeleteRole_Call

func (*MockIamClient_interfaces_DeleteRole_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_DeleteRole_Call) RunAndReturn(run func(context.Context, *iam.DeleteRoleInput, ...func(*iam.Options)) (*iam.DeleteRoleOutput, error)) *MockIamClient_interfaces_DeleteRole_Call

type MockIamClient_interfaces_DetachRolePolicy_Call 

type MockIamClient_interfaces_DetachRolePolicy_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_DetachRolePolicy_Call) Return 

func (_c *MockIamClient_interfaces_DetachRolePolicy_Call) Return(_a0 *iam.DetachRolePolicyOutput, _a1 error) *MockIamClient_interfaces_DetachRolePolicy_Call

func (*MockIamClient_interfaces_DetachRolePolicy_Call) Run 

func (_c *MockIamClient_interfaces_DetachRolePolicy_Call) Run(run func(ctx context.Context, params *iam.DetachRolePolicyInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_DetachRolePolicy_Call

func (*MockIamClient_interfaces_DetachRolePolicy_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_DetachRolePolicy_Call) RunAndReturn(run func(context.Context, *iam.DetachRolePolicyInput, ...func(*iam.Options)) (*iam.DetachRolePolicyOutput, error)) *MockIamClient_interfaces_DetachRolePolicy_Call

type MockIamClient_interfaces_Expecter 

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

func (*MockIamClient_interfaces_Expecter) AttachRolePolicy 

func (_e *MockIamClient_interfaces_Expecter) AttachRolePolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_AttachRolePolicy_Call

AttachRolePolicy is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.AttachRolePolicyInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) CreatePolicy 

func (_e *MockIamClient_interfaces_Expecter) CreatePolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_CreatePolicy_Call

CreatePolicy is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.CreatePolicyInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) CreateRole 

func (_e *MockIamClient_interfaces_Expecter) CreateRole(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_CreateRole_Call

CreateRole is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.CreateRoleInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) DeletePolicy 

func (_e *MockIamClient_interfaces_Expecter) DeletePolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_DeletePolicy_Call

DeletePolicy is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.DeletePolicyInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) DeleteRole 

func (_e *MockIamClient_interfaces_Expecter) DeleteRole(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_DeleteRole_Call

DeleteRole is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.DeleteRoleInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) DeleteRolePolicy 

func (_e *MockIamClient_interfaces_Expecter) DeleteRolePolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_DeleteRolePolicy_Call

DeleteRolePolicy is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.DeleteRolePolicyInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) DetachRolePolicy 

func (_e *MockIamClient_interfaces_Expecter) DetachRolePolicy(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_DetachRolePolicy_Call

DetachRolePolicy is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.DetachRolePolicyInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) GetRole 

func (_e *MockIamClient_interfaces_Expecter) GetRole(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_GetRole_Call

GetRole is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.GetRoleInput
  • optFns ...func(*iam.Options)

func (*MockIamClient_interfaces_Expecter) ListAttachedRolePolicies 

func (_e *MockIamClient_interfaces_Expecter) ListAttachedRolePolicies(ctx interface{}, params interface{}, optFns ...interface{}) *MockIamClient_interfaces_ListAttachedRolePolicies_Call

ListAttachedRolePolicies is a helper method to define mock.On call

  • ctx context.Context
  • params *iam.ListAttachedRolePoliciesInput
  • optFns ...func(*iam.Options)

type MockIamClient_interfaces_GetRole_Call 

type MockIamClient_interfaces_GetRole_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_GetRole_Call) Return 

func (_c *MockIamClient_interfaces_GetRole_Call) Return(_a0 *iam.GetRoleOutput, _a1 error) *MockIamClient_interfaces_GetRole_Call

func (*MockIamClient_interfaces_GetRole_Call) Run 

func (_c *MockIamClient_interfaces_GetRole_Call) Run(run func(ctx context.Context, params *iam.GetRoleInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_GetRole_Call

func (*MockIamClient_interfaces_GetRole_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_GetRole_Call) RunAndReturn(run func(context.Context, *iam.GetRoleInput, ...func(*iam.Options)) (*iam.GetRoleOutput, error)) *MockIamClient_interfaces_GetRole_Call

type MockIamClient_interfaces_ListAttachedRolePolicies_Call 

type MockIamClient_interfaces_ListAttachedRolePolicies_Call struct {
	*mock.Call
}

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

func (*MockIamClient_interfaces_ListAttachedRolePolicies_Call) Return 

func (_c *MockIamClient_interfaces_ListAttachedRolePolicies_Call) Return(_a0 *iam.ListAttachedRolePoliciesOutput, _a1 error) *MockIamClient_interfaces_ListAttachedRolePolicies_Call

func (*MockIamClient_interfaces_ListAttachedRolePolicies_Call) Run 

func (_c *MockIamClient_interfaces_ListAttachedRolePolicies_Call) Run(run func(ctx context.Context, params *iam.ListAttachedRolePoliciesInput, optFns ...func(*iam.Options))) *MockIamClient_interfaces_ListAttachedRolePolicies_Call

func (*MockIamClient_interfaces_ListAttachedRolePolicies_Call) RunAndReturn 

func (_c *MockIamClient_interfaces_ListAttachedRolePolicies_Call) RunAndReturn(run func(context.Context, *iam.ListAttachedRolePoliciesInput, ...func(*iam.Options)) (*iam.ListAttachedRolePoliciesOutput, error)) *MockIamClient_interfaces_ListAttachedRolePolicies_Call

type MockInvoker_texit 

type MockInvoker_texit struct {
	mock.Mock
}

MockInvoker_texit is an autogenerated mock type for the Invoker type

func NewMockInvoker_texit 

func NewMockInvoker_texit(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInvoker_texit

NewMockInvoker_texit creates a new instance of MockInvoker_texit. 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 (*MockInvoker_texit) DeprovisionNode 

func (_m *MockInvoker_texit) DeprovisionNode(ctx context.Context, params texit.DeprovisionNodeParams) (texit.DeprovisionNodeRes, error)

DeprovisionNode provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) DescribeNode 

func (_m *MockInvoker_texit) DescribeNode(ctx context.Context, params texit.DescribeNodeParams) (texit.DescribeNodeRes, error)

DescribeNode provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) DescribeProvider 

func (_m *MockInvoker_texit) DescribeProvider(ctx context.Context, params texit.DescribeProviderParams) (texit.DescribeProviderRes, error)

DescribeProvider provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) DescribeTailnet 

func (_m *MockInvoker_texit) DescribeTailnet(ctx context.Context, params texit.DescribeTailnetParams) (texit.DescribeTailnetRes, error)

DescribeTailnet provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) EXPECT 

func (_m *MockInvoker_texit) EXPECT() *MockInvoker_texit_Expecter

func (*MockInvoker_texit) GetExecution 

func (_m *MockInvoker_texit) GetExecution(ctx context.Context, params texit.GetExecutionParams) (texit.GetExecutionRes, error)

GetExecution provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) GetNodeStatus 

func (_m *MockInvoker_texit) GetNodeStatus(ctx context.Context, params texit.GetNodeStatusParams) (texit.GetNodeStatusRes, error)

GetNodeStatus provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) Health 

func (_m *MockInvoker_texit) Health(ctx context.Context) (*texit.HealthResponseContent, error)

Health provides a mock function with given fields: ctx

func (*MockInvoker_texit) ListNodes 

func (_m *MockInvoker_texit) ListNodes(ctx context.Context) (texit.ListNodesRes, error)

ListNodes provides a mock function with given fields: ctx

func (*MockInvoker_texit) ListProviders 

func (_m *MockInvoker_texit) ListProviders(ctx context.Context) (*texit.ListProvidersResponseContent, error)

ListProviders provides a mock function with given fields: ctx

func (*MockInvoker_texit) ListTailnets 

func (_m *MockInvoker_texit) ListTailnets(ctx context.Context) (*texit.ListTailnetsResponseContent, error)

ListTailnets provides a mock function with given fields: ctx

func (*MockInvoker_texit) ProvisionNode 

func (_m *MockInvoker_texit) ProvisionNode(ctx context.Context, request *texit.ProvisionNodeRequestContent) (texit.ProvisionNodeRes, error)

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

func (*MockInvoker_texit) StartNode 

func (_m *MockInvoker_texit) StartNode(ctx context.Context, params texit.StartNodeParams) (texit.StartNodeRes, error)

StartNode provides a mock function with given fields: ctx, params

func (*MockInvoker_texit) StopNode 

func (_m *MockInvoker_texit) StopNode(ctx context.Context, params texit.StopNodeParams) (texit.StopNodeRes, error)

StopNode provides a mock function with given fields: ctx, params

type MockInvoker_texit_DeprovisionNode_Call 

type MockInvoker_texit_DeprovisionNode_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_DeprovisionNode_Call) Return 

func (_c *MockInvoker_texit_DeprovisionNode_Call) Return(_a0 texit.DeprovisionNodeRes, _a1 error) *MockInvoker_texit_DeprovisionNode_Call

func (*MockInvoker_texit_DeprovisionNode_Call) Run 

func (_c *MockInvoker_texit_DeprovisionNode_Call) Run(run func(ctx context.Context, params texit.DeprovisionNodeParams)) *MockInvoker_texit_DeprovisionNode_Call

func (*MockInvoker_texit_DeprovisionNode_Call) RunAndReturn 

func (_c *MockInvoker_texit_DeprovisionNode_Call) RunAndReturn(run func(context.Context, texit.DeprovisionNodeParams) (texit.DeprovisionNodeRes, error)) *MockInvoker_texit_DeprovisionNode_Call

type MockInvoker_texit_DescribeNode_Call 

type MockInvoker_texit_DescribeNode_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_DescribeNode_Call) Return 

func (_c *MockInvoker_texit_DescribeNode_Call) Return(_a0 texit.DescribeNodeRes, _a1 error) *MockInvoker_texit_DescribeNode_Call

func (*MockInvoker_texit_DescribeNode_Call) Run 

func (_c *MockInvoker_texit_DescribeNode_Call) Run(run func(ctx context.Context, params texit.DescribeNodeParams)) *MockInvoker_texit_DescribeNode_Call

func (*MockInvoker_texit_DescribeNode_Call) RunAndReturn 

func (_c *MockInvoker_texit_DescribeNode_Call) RunAndReturn(run func(context.Context, texit.DescribeNodeParams) (texit.DescribeNodeRes, error)) *MockInvoker_texit_DescribeNode_Call

type MockInvoker_texit_DescribeProvider_Call 

type MockInvoker_texit_DescribeProvider_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_DescribeProvider_Call) Return 

func (_c *MockInvoker_texit_DescribeProvider_Call) Return(_a0 texit.DescribeProviderRes, _a1 error) *MockInvoker_texit_DescribeProvider_Call

func (*MockInvoker_texit_DescribeProvider_Call) Run 

func (_c *MockInvoker_texit_DescribeProvider_Call) Run(run func(ctx context.Context, params texit.DescribeProviderParams)) *MockInvoker_texit_DescribeProvider_Call

func (*MockInvoker_texit_DescribeProvider_Call) RunAndReturn 

func (_c *MockInvoker_texit_DescribeProvider_Call) RunAndReturn(run func(context.Context, texit.DescribeProviderParams) (texit.DescribeProviderRes, error)) *MockInvoker_texit_DescribeProvider_Call

type MockInvoker_texit_DescribeTailnet_Call 

type MockInvoker_texit_DescribeTailnet_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_DescribeTailnet_Call) Return 

func (_c *MockInvoker_texit_DescribeTailnet_Call) Return(_a0 texit.DescribeTailnetRes, _a1 error) *MockInvoker_texit_DescribeTailnet_Call

func (*MockInvoker_texit_DescribeTailnet_Call) Run 

func (_c *MockInvoker_texit_DescribeTailnet_Call) Run(run func(ctx context.Context, params texit.DescribeTailnetParams)) *MockInvoker_texit_DescribeTailnet_Call

func (*MockInvoker_texit_DescribeTailnet_Call) RunAndReturn 

func (_c *MockInvoker_texit_DescribeTailnet_Call) RunAndReturn(run func(context.Context, texit.DescribeTailnetParams) (texit.DescribeTailnetRes, error)) *MockInvoker_texit_DescribeTailnet_Call

type MockInvoker_texit_Expecter 

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

func (*MockInvoker_texit_Expecter) DeprovisionNode 

func (_e *MockInvoker_texit_Expecter) DeprovisionNode(ctx interface{}, params interface{}) *MockInvoker_texit_DeprovisionNode_Call

DeprovisionNode is a helper method to define mock.On call

  • ctx context.Context
  • params texit.DeprovisionNodeParams

func (*MockInvoker_texit_Expecter) DescribeNode 

func (_e *MockInvoker_texit_Expecter) DescribeNode(ctx interface{}, params interface{}) *MockInvoker_texit_DescribeNode_Call

DescribeNode is a helper method to define mock.On call

  • ctx context.Context
  • params texit.DescribeNodeParams

func (*MockInvoker_texit_Expecter) DescribeProvider 

func (_e *MockInvoker_texit_Expecter) DescribeProvider(ctx interface{}, params interface{}) *MockInvoker_texit_DescribeProvider_Call

DescribeProvider is a helper method to define mock.On call

  • ctx context.Context
  • params texit.DescribeProviderParams

func (*MockInvoker_texit_Expecter) DescribeTailnet 

func (_e *MockInvoker_texit_Expecter) DescribeTailnet(ctx interface{}, params interface{}) *MockInvoker_texit_DescribeTailnet_Call

DescribeTailnet is a helper method to define mock.On call

  • ctx context.Context
  • params texit.DescribeTailnetParams

func (*MockInvoker_texit_Expecter) GetExecution 

func (_e *MockInvoker_texit_Expecter) GetExecution(ctx interface{}, params interface{}) *MockInvoker_texit_GetExecution_Call

GetExecution is a helper method to define mock.On call

  • ctx context.Context
  • params texit.GetExecutionParams

func (*MockInvoker_texit_Expecter) GetNodeStatus 

func (_e *MockInvoker_texit_Expecter) GetNodeStatus(ctx interface{}, params interface{}) *MockInvoker_texit_GetNodeStatus_Call

GetNodeStatus is a helper method to define mock.On call

  • ctx context.Context
  • params texit.GetNodeStatusParams

func (*MockInvoker_texit_Expecter) Health 

func (_e *MockInvoker_texit_Expecter) Health(ctx interface{}) *MockInvoker_texit_Health_Call

Health is a helper method to define mock.On call

  • ctx context.Context

func (*MockInvoker_texit_Expecter) ListNodes 

func (_e *MockInvoker_texit_Expecter) ListNodes(ctx interface{}) *MockInvoker_texit_ListNodes_Call

ListNodes is a helper method to define mock.On call

  • ctx context.Context

func (*MockInvoker_texit_Expecter) ListProviders 

func (_e *MockInvoker_texit_Expecter) ListProviders(ctx interface{}) *MockInvoker_texit_ListProviders_Call

ListProviders is a helper method to define mock.On call

  • ctx context.Context

func (*MockInvoker_texit_Expecter) ListTailnets 

func (_e *MockInvoker_texit_Expecter) ListTailnets(ctx interface{}) *MockInvoker_texit_ListTailnets_Call

ListTailnets is a helper method to define mock.On call

  • ctx context.Context

func (*MockInvoker_texit_Expecter) ProvisionNode 

func (_e *MockInvoker_texit_Expecter) ProvisionNode(ctx interface{}, request interface{}) *MockInvoker_texit_ProvisionNode_Call

ProvisionNode is a helper method to define mock.On call

  • ctx context.Context
  • request *texit.ProvisionNodeRequestContent

func (*MockInvoker_texit_Expecter) StartNode 

func (_e *MockInvoker_texit_Expecter) StartNode(ctx interface{}, params interface{}) *MockInvoker_texit_StartNode_Call

StartNode is a helper method to define mock.On call

  • ctx context.Context
  • params texit.StartNodeParams

func (*MockInvoker_texit_Expecter) StopNode 

func (_e *MockInvoker_texit_Expecter) StopNode(ctx interface{}, params interface{}) *MockInvoker_texit_StopNode_Call

StopNode is a helper method to define mock.On call

  • ctx context.Context
  • params texit.StopNodeParams

type MockInvoker_texit_GetExecution_Call 

type MockInvoker_texit_GetExecution_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_GetExecution_Call) Return 

func (_c *MockInvoker_texit_GetExecution_Call) Return(_a0 texit.GetExecutionRes, _a1 error) *MockInvoker_texit_GetExecution_Call

func (*MockInvoker_texit_GetExecution_Call) Run 

func (_c *MockInvoker_texit_GetExecution_Call) Run(run func(ctx context.Context, params texit.GetExecutionParams)) *MockInvoker_texit_GetExecution_Call

func (*MockInvoker_texit_GetExecution_Call) RunAndReturn 

func (_c *MockInvoker_texit_GetExecution_Call) RunAndReturn(run func(context.Context, texit.GetExecutionParams) (texit.GetExecutionRes, error)) *MockInvoker_texit_GetExecution_Call

type MockInvoker_texit_GetNodeStatus_Call 

type MockInvoker_texit_GetNodeStatus_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_GetNodeStatus_Call) Return 

func (_c *MockInvoker_texit_GetNodeStatus_Call) Return(_a0 texit.GetNodeStatusRes, _a1 error) *MockInvoker_texit_GetNodeStatus_Call

func (*MockInvoker_texit_GetNodeStatus_Call) Run 

func (_c *MockInvoker_texit_GetNodeStatus_Call) Run(run func(ctx context.Context, params texit.GetNodeStatusParams)) *MockInvoker_texit_GetNodeStatus_Call

func (*MockInvoker_texit_GetNodeStatus_Call) RunAndReturn 

func (_c *MockInvoker_texit_GetNodeStatus_Call) RunAndReturn(run func(context.Context, texit.GetNodeStatusParams) (texit.GetNodeStatusRes, error)) *MockInvoker_texit_GetNodeStatus_Call

type MockInvoker_texit_Health_Call 

type MockInvoker_texit_Health_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_Health_Call) Return 

func (_c *MockInvoker_texit_Health_Call) Return(_a0 *texit.HealthResponseContent, _a1 error) *MockInvoker_texit_Health_Call

func (*MockInvoker_texit_Health_Call) Run 

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

func (*MockInvoker_texit_Health_Call) RunAndReturn 

func (_c *MockInvoker_texit_Health_Call) RunAndReturn(run func(context.Context) (*texit.HealthResponseContent, error)) *MockInvoker_texit_Health_Call

type MockInvoker_texit_ListNodes_Call 

type MockInvoker_texit_ListNodes_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_ListNodes_Call) Return 

func (_c *MockInvoker_texit_ListNodes_Call) Return(_a0 texit.ListNodesRes, _a1 error) *MockInvoker_texit_ListNodes_Call

func (*MockInvoker_texit_ListNodes_Call) Run 

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

func (*MockInvoker_texit_ListNodes_Call) RunAndReturn 

func (_c *MockInvoker_texit_ListNodes_Call) RunAndReturn(run func(context.Context) (texit.ListNodesRes, error)) *MockInvoker_texit_ListNodes_Call

type MockInvoker_texit_ListProviders_Call 

type MockInvoker_texit_ListProviders_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_ListProviders_Call) Return 

func (_c *MockInvoker_texit_ListProviders_Call) Return(_a0 *texit.ListProvidersResponseContent, _a1 error) *MockInvoker_texit_ListProviders_Call

func (*MockInvoker_texit_ListProviders_Call) Run 

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

func (*MockInvoker_texit_ListProviders_Call) RunAndReturn 

func (_c *MockInvoker_texit_ListProviders_Call) RunAndReturn(run func(context.Context) (*texit.ListProvidersResponseContent, error)) *MockInvoker_texit_ListProviders_Call

type MockInvoker_texit_ListTailnets_Call 

type MockInvoker_texit_ListTailnets_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_ListTailnets_Call) Return 

func (_c *MockInvoker_texit_ListTailnets_Call) Return(_a0 *texit.ListTailnetsResponseContent, _a1 error) *MockInvoker_texit_ListTailnets_Call

func (*MockInvoker_texit_ListTailnets_Call) Run 

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

func (*MockInvoker_texit_ListTailnets_Call) RunAndReturn 

func (_c *MockInvoker_texit_ListTailnets_Call) RunAndReturn(run func(context.Context) (*texit.ListTailnetsResponseContent, error)) *MockInvoker_texit_ListTailnets_Call

type MockInvoker_texit_ProvisionNode_Call 

type MockInvoker_texit_ProvisionNode_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_ProvisionNode_Call) Return 

func (_c *MockInvoker_texit_ProvisionNode_Call) Return(_a0 texit.ProvisionNodeRes, _a1 error) *MockInvoker_texit_ProvisionNode_Call

func (*MockInvoker_texit_ProvisionNode_Call) Run 

func (_c *MockInvoker_texit_ProvisionNode_Call) Run(run func(ctx context.Context, request *texit.ProvisionNodeRequestContent)) *MockInvoker_texit_ProvisionNode_Call

func (*MockInvoker_texit_ProvisionNode_Call) RunAndReturn 

func (_c *MockInvoker_texit_ProvisionNode_Call) RunAndReturn(run func(context.Context, *texit.ProvisionNodeRequestContent) (texit.ProvisionNodeRes, error)) *MockInvoker_texit_ProvisionNode_Call

type MockInvoker_texit_StartNode_Call 

type MockInvoker_texit_StartNode_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_StartNode_Call) Return 

func (_c *MockInvoker_texit_StartNode_Call) Return(_a0 texit.StartNodeRes, _a1 error) *MockInvoker_texit_StartNode_Call

func (*MockInvoker_texit_StartNode_Call) Run 

func (_c *MockInvoker_texit_StartNode_Call) Run(run func(ctx context.Context, params texit.StartNodeParams)) *MockInvoker_texit_StartNode_Call

func (*MockInvoker_texit_StartNode_Call) RunAndReturn 

func (_c *MockInvoker_texit_StartNode_Call) RunAndReturn(run func(context.Context, texit.StartNodeParams) (texit.StartNodeRes, error)) *MockInvoker_texit_StartNode_Call

type MockInvoker_texit_StopNode_Call 

type MockInvoker_texit_StopNode_Call struct {
	*mock.Call
}

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

func (*MockInvoker_texit_StopNode_Call) Return 

func (_c *MockInvoker_texit_StopNode_Call) Return(_a0 texit.StopNodeRes, _a1 error) *MockInvoker_texit_StopNode_Call

func (*MockInvoker_texit_StopNode_Call) Run 

func (_c *MockInvoker_texit_StopNode_Call) Run(run func(ctx context.Context, params texit.StopNodeParams)) *MockInvoker_texit_StopNode_Call

func (*MockInvoker_texit_StopNode_Call) RunAndReturn 

func (_c *MockInvoker_texit_StopNode_Call) RunAndReturn(run func(context.Context, texit.StopNodeParams) (texit.StopNodeRes, error)) *MockInvoker_texit_StopNode_Call

type MockNode_repository 

type MockNode_repository struct {
	mock.Mock
}

MockNode_repository is an autogenerated mock type for the Node type

func NewMockNode_repository 

func NewMockNode_repository(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockNode_repository

NewMockNode_repository creates a new instance of MockNode_repository. 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 (*MockNode_repository) Create 

func (_m *MockNode_repository) Create(ctx context.Context, _a1 *node.Node) error

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

func (*MockNode_repository) Delete 

func (_m *MockNode_repository) Delete(ctx context.Context, id node.Identifier) error

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

func (*MockNode_repository) EXPECT 

func (_m *MockNode_repository) EXPECT() *MockNode_repository_Expecter

func (*MockNode_repository) Get 

func (_m *MockNode_repository) Get(ctx context.Context, id node.Identifier) (*node.Node, error)

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

func (*MockNode_repository) Init 

func (_m *MockNode_repository) Init(ctx context.Context) error

Init provides a mock function with given fields: ctx

func (*MockNode_repository) List 

func (_m *MockNode_repository) List(ctx context.Context) ([]*node.Node, error)

List provides a mock function with given fields: ctx

type MockNode_repository_Create_Call 

type MockNode_repository_Create_Call struct {
	*mock.Call
}

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

func (*MockNode_repository_Create_Call) Return 

func (_c *MockNode_repository_Create_Call) Return(_a0 error) *MockNode_repository_Create_Call

func (*MockNode_repository_Create_Call) Run 

func (_c *MockNode_repository_Create_Call) Run(run func(ctx context.Context, _a1 *node.Node)) *MockNode_repository_Create_Call

func (*MockNode_repository_Create_Call) RunAndReturn 

func (_c *MockNode_repository_Create_Call) RunAndReturn(run func(context.Context, *node.Node) error) *MockNode_repository_Create_Call

type MockNode_repository_Delete_Call 

type MockNode_repository_Delete_Call struct {
	*mock.Call
}

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

func (*MockNode_repository_Delete_Call) Return 

func (_c *MockNode_repository_Delete_Call) Return(_a0 error) *MockNode_repository_Delete_Call

func (*MockNode_repository_Delete_Call) Run 

func (_c *MockNode_repository_Delete_Call) Run(run func(ctx context.Context, id node.Identifier)) *MockNode_repository_Delete_Call

func (*MockNode_repository_Delete_Call) RunAndReturn 

func (_c *MockNode_repository_Delete_Call) RunAndReturn(run func(context.Context, node.Identifier) error) *MockNode_repository_Delete_Call

type MockNode_repository_Expecter 

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

func (*MockNode_repository_Expecter) Create 

func (_e *MockNode_repository_Expecter) Create(ctx interface{}, _a1 interface{}) *MockNode_repository_Create_Call

Create is a helper method to define mock.On call

  • ctx context.Context
  • _a1 *node.Node

func (*MockNode_repository_Expecter) Delete 

func (_e *MockNode_repository_Expecter) Delete(ctx interface{}, id interface{}) *MockNode_repository_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • id node.Identifier

func (*MockNode_repository_Expecter) Get 

func (_e *MockNode_repository_Expecter) Get(ctx interface{}, id interface{}) *MockNode_repository_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • id node.Identifier

func (*MockNode_repository_Expecter) Init 

func (_e *MockNode_repository_Expecter) Init(ctx interface{}) *MockNode_repository_Init_Call

Init is a helper method to define mock.On call

  • ctx context.Context

func (*MockNode_repository_Expecter) List 

func (_e *MockNode_repository_Expecter) List(ctx interface{}) *MockNode_repository_List_Call

List is a helper method to define mock.On call

  • ctx context.Context

type MockNode_repository_Get_Call 

type MockNode_repository_Get_Call struct {
	*mock.Call
}

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

func (*MockNode_repository_Get_Call) Return 

func (_c *MockNode_repository_Get_Call) Return(_a0 *node.Node, _a1 error) *MockNode_repository_Get_Call

func (*MockNode_repository_Get_Call) Run 

func (_c *MockNode_repository_Get_Call) Run(run func(ctx context.Context, id node.Identifier)) *MockNode_repository_Get_Call

func (*MockNode_repository_Get_Call) RunAndReturn 

func (_c *MockNode_repository_Get_Call) RunAndReturn(run func(context.Context, node.Identifier) (*node.Node, error)) *MockNode_repository_Get_Call

type MockNode_repository_Init_Call 

type MockNode_repository_Init_Call struct {
	*mock.Call
}

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

func (*MockNode_repository_Init_Call) Return 

func (_c *MockNode_repository_Init_Call) Return(_a0 error) *MockNode_repository_Init_Call

func (*MockNode_repository_Init_Call) Run 

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

func (*MockNode_repository_Init_Call) RunAndReturn 

func (_c *MockNode_repository_Init_Call) RunAndReturn(run func(context.Context) error) *MockNode_repository_Init_Call

type MockNode_repository_List_Call 

type MockNode_repository_List_Call struct {
	*mock.Call
}

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

func (*MockNode_repository_List_Call) Return 

func (_c *MockNode_repository_List_Call) Return(_a0 []*node.Node, _a1 error) *MockNode_repository_List_Call

func (*MockNode_repository_List_Call) Run 

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

func (*MockNode_repository_List_Call) RunAndReturn 

func (_c *MockNode_repository_List_Call) RunAndReturn(run func(context.Context) ([]*node.Node, error)) *MockNode_repository_List_Call

type MockNode_service 

type MockNode_service struct {
	mock.Mock
}

MockNode_service is an autogenerated mock type for the Node type

func NewMockNode_service 

func NewMockNode_service(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockNode_service

NewMockNode_service creates a new instance of MockNode_service. 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 (*MockNode_service) Describe 

func (_m *MockNode_service) Describe(ctx context.Context, id node.Identifier) (*node.Node, error)

Describe provides a mock function with given fields: ctx, id

func (*MockNode_service) EXPECT 

func (_m *MockNode_service) EXPECT() *MockNode_service_Expecter

func (*MockNode_service) List 

func (_m *MockNode_service) List(ctx context.Context) ([]*node.Node, error)

List provides a mock function with given fields: ctx

func (*MockNode_service) Start 

func (_m *MockNode_service) Start(ctx context.Context, id node.Identifier) error

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

func (*MockNode_service) Status 

func (_m *MockNode_service) Status(ctx context.Context, id node.Identifier) (node.Status, error)

Status provides a mock function with given fields: ctx, id

func (*MockNode_service) Stop 

func (_m *MockNode_service) Stop(ctx context.Context, id node.Identifier) error

Stop provides a mock function with given fields: ctx, id

type MockNode_service_Describe_Call 

type MockNode_service_Describe_Call struct {
	*mock.Call
}

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

func (*MockNode_service_Describe_Call) Return 

func (_c *MockNode_service_Describe_Call) Return(_a0 *node.Node, _a1 error) *MockNode_service_Describe_Call

func (*MockNode_service_Describe_Call) Run 

func (_c *MockNode_service_Describe_Call) Run(run func(ctx context.Context, id node.Identifier)) *MockNode_service_Describe_Call

func (*MockNode_service_Describe_Call) RunAndReturn 

func (_c *MockNode_service_Describe_Call) RunAndReturn(run func(context.Context, node.Identifier) (*node.Node, error)) *MockNode_service_Describe_Call

type MockNode_service_Expecter 

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

func (*MockNode_service_Expecter) Describe 

func (_e *MockNode_service_Expecter) Describe(ctx interface{}, id interface{}) *MockNode_service_Describe_Call

Describe is a helper method to define mock.On call

  • ctx context.Context
  • id node.Identifier

func (*MockNode_service_Expecter) List 

func (_e *MockNode_service_Expecter) List(ctx interface{}) *MockNode_service_List_Call

List is a helper method to define mock.On call

  • ctx context.Context

func (*MockNode_service_Expecter) Start 

func (_e *MockNode_service_Expecter) Start(ctx interface{}, id interface{}) *MockNode_service_Start_Call

Start is a helper method to define mock.On call

  • ctx context.Context
  • id node.Identifier

func (*MockNode_service_Expecter) Status 

func (_e *MockNode_service_Expecter) Status(ctx interface{}, id interface{}) *MockNode_service_Status_Call

Status is a helper method to define mock.On call

  • ctx context.Context
  • id node.Identifier

func (*MockNode_service_Expecter) Stop 

func (_e *MockNode_service_Expecter) Stop(ctx interface{}, id interface{}) *MockNode_service_Stop_Call

Stop is a helper method to define mock.On call

  • ctx context.Context
  • id node.Identifier

type MockNode_service_List_Call 

type MockNode_service_List_Call struct {
	*mock.Call
}

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

func (*MockNode_service_List_Call) Return 

func (_c *MockNode_service_List_Call) Return(_a0 []*node.Node, _a1 error) *MockNode_service_List_Call

func (*MockNode_service_List_Call) Run 

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

func (*MockNode_service_List_Call) RunAndReturn 

func (_c *MockNode_service_List_Call) RunAndReturn(run func(context.Context) ([]*node.Node, error)) *MockNode_service_List_Call

type MockNode_service_Start_Call 

type MockNode_service_Start_Call struct {
	*mock.Call
}

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

func (*MockNode_service_Start_Call) Return 

func (_c *MockNode_service_Start_Call) Return(_a0 error) *MockNode_service_Start_Call

func (*MockNode_service_Start_Call) Run 

func (_c *MockNode_service_Start_Call) Run(run func(ctx context.Context, id node.Identifier)) *MockNode_service_Start_Call

func (*MockNode_service_Start_Call) RunAndReturn 

func (_c *MockNode_service_Start_Call) RunAndReturn(run func(context.Context, node.Identifier) error) *MockNode_service_Start_Call

type MockNode_service_Status_Call 

type MockNode_service_Status_Call struct {
	*mock.Call
}

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

func (*MockNode_service_Status_Call) Return 

func (_c *MockNode_service_Status_Call) Return(_a0 node.Status, _a1 error) *MockNode_service_Status_Call

func (*MockNode_service_Status_Call) Run 

func (_c *MockNode_service_Status_Call) Run(run func(ctx context.Context, id node.Identifier)) *MockNode_service_Status_Call

func (*MockNode_service_Status_Call) RunAndReturn 

func (_c *MockNode_service_Status_Call) RunAndReturn(run func(context.Context, node.Identifier) (node.Status, error)) *MockNode_service_Status_Call

type MockNode_service_Stop_Call 

type MockNode_service_Stop_Call struct {
	*mock.Call
}

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

func (*MockNode_service_Stop_Call) Return 

func (_c *MockNode_service_Stop_Call) Return(_a0 error) *MockNode_service_Stop_Call

func (*MockNode_service_Stop_Call) Run 

func (_c *MockNode_service_Stop_Call) Run(run func(ctx context.Context, id node.Identifier)) *MockNode_service_Stop_Call

func (*MockNode_service_Stop_Call) RunAndReturn 

func (_c *MockNode_service_Stop_Call) RunAndReturn(run func(context.Context, node.Identifier) error) *MockNode_service_Stop_Call

type MockPlatform_gateway 

type MockPlatform_gateway struct {
	mock.Mock
}

MockPlatform_gateway is an autogenerated mock type for the Platform type

func NewMockPlatform_gateway 

func NewMockPlatform_gateway(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPlatform_gateway

NewMockPlatform_gateway creates a new instance of MockPlatform_gateway. 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 (*MockPlatform_gateway) CreateNode 

func (_m *MockPlatform_gateway) CreateNode(_a0 context.Context, _a1 node.Identifier, _a2 tailnet.DeviceName, _a3 *provider.Provider, _a4 provider.Location, _a5 *tailnet.Tailnet, _a6 tailnet.PreauthKey) (node.PlatformIdentifier, error)

CreateNode provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4, _a5, _a6

func (*MockPlatform_gateway) DeleteNode 

func (_m *MockPlatform_gateway) DeleteNode(_a0 context.Context, _a1 *node.Node) error

DeleteNode provides a mock function with given fields: _a0, _a1

func (*MockPlatform_gateway) EXPECT 

func (_m *MockPlatform_gateway) EXPECT() *MockPlatform_gateway_Expecter

func (*MockPlatform_gateway) GetStatus 

func (_m *MockPlatform_gateway) GetStatus(_a0 context.Context, _a1 *node.Node) (node.Status, error)

GetStatus provides a mock function with given fields: _a0, _a1

func (*MockPlatform_gateway) StartNode 

func (_m *MockPlatform_gateway) StartNode(_a0 context.Context, _a1 *node.Node) error

StartNode provides a mock function with given fields: _a0, _a1

func (*MockPlatform_gateway) StopNode 

func (_m *MockPlatform_gateway) StopNode(_a0 context.Context, _a1 *node.Node) error

StopNode provides a mock function with given fields: _a0, _a1

type MockPlatform_gateway_CreateNode_Call 

type MockPlatform_gateway_CreateNode_Call struct {
	*mock.Call
}

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

func (*MockPlatform_gateway_CreateNode_Call) Return 

func (_c *MockPlatform_gateway_CreateNode_Call) Return(_a0 node.PlatformIdentifier, _a1 error) *MockPlatform_gateway_CreateNode_Call

func (*MockPlatform_gateway_CreateNode_Call) Run 

func (_c *MockPlatform_gateway_CreateNode_Call) Run(run func(_a0 context.Context, _a1 node.Identifier, _a2 tailnet.DeviceName, _a3 *provider.Provider, _a4 provider.Location, _a5 *tailnet.Tailnet, _a6 tailnet.PreauthKey)) *MockPlatform_gateway_CreateNode_Call

func (*MockPlatform_gateway_CreateNode_Call) RunAndReturn 

func (_c *MockPlatform_gateway_CreateNode_Call) RunAndReturn(run func(context.Context, node.Identifier, tailnet.DeviceName, *provider.Provider, provider.Location, *tailnet.Tailnet, tailnet.PreauthKey) (node.PlatformIdentifier, error)) *MockPlatform_gateway_CreateNode_Call

type MockPlatform_gateway_DeleteNode_Call 

type MockPlatform_gateway_DeleteNode_Call struct {
	*mock.Call
}

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

func (*MockPlatform_gateway_DeleteNode_Call) Return 

func (_c *MockPlatform_gateway_DeleteNode_Call) Return(_a0 error) *MockPlatform_gateway_DeleteNode_Call

func (*MockPlatform_gateway_DeleteNode_Call) Run 

func (_c *MockPlatform_gateway_DeleteNode_Call) Run(run func(_a0 context.Context, _a1 *node.Node)) *MockPlatform_gateway_DeleteNode_Call

func (*MockPlatform_gateway_DeleteNode_Call) RunAndReturn 

func (_c *MockPlatform_gateway_DeleteNode_Call) RunAndReturn(run func(context.Context, *node.Node) error) *MockPlatform_gateway_DeleteNode_Call

type MockPlatform_gateway_Expecter 

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

func (*MockPlatform_gateway_Expecter) CreateNode 

func (_e *MockPlatform_gateway_Expecter) CreateNode(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}, _a4 interface{}, _a5 interface{}, _a6 interface{}) *MockPlatform_gateway_CreateNode_Call

CreateNode is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 node.Identifier
  • _a2 tailnet.DeviceName
  • _a3 *provider.Provider
  • _a4 provider.Location
  • _a5 *tailnet.Tailnet
  • _a6 tailnet.PreauthKey

func (*MockPlatform_gateway_Expecter) DeleteNode 

func (_e *MockPlatform_gateway_Expecter) DeleteNode(_a0 interface{}, _a1 interface{}) *MockPlatform_gateway_DeleteNode_Call

DeleteNode is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *node.Node

func (*MockPlatform_gateway_Expecter) GetStatus 

func (_e *MockPlatform_gateway_Expecter) GetStatus(_a0 interface{}, _a1 interface{}) *MockPlatform_gateway_GetStatus_Call

GetStatus is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *node.Node

func (*MockPlatform_gateway_Expecter) StartNode 

func (_e *MockPlatform_gateway_Expecter) StartNode(_a0 interface{}, _a1 interface{}) *MockPlatform_gateway_StartNode_Call

StartNode is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *node.Node

func (*MockPlatform_gateway_Expecter) StopNode 

func (_e *MockPlatform_gateway_Expecter) StopNode(_a0 interface{}, _a1 interface{}) *MockPlatform_gateway_StopNode_Call

StopNode is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *node.Node

type MockPlatform_gateway_GetStatus_Call 

type MockPlatform_gateway_GetStatus_Call struct {
	*mock.Call
}

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

func (*MockPlatform_gateway_GetStatus_Call) Return 

func (_c *MockPlatform_gateway_GetStatus_Call) Return(_a0 node.Status, _a1 error) *MockPlatform_gateway_GetStatus_Call

func (*MockPlatform_gateway_GetStatus_Call) Run 

func (_c *MockPlatform_gateway_GetStatus_Call) Run(run func(_a0 context.Context, _a1 *node.Node)) *MockPlatform_gateway_GetStatus_Call

func (*MockPlatform_gateway_GetStatus_Call) RunAndReturn 

func (_c *MockPlatform_gateway_GetStatus_Call) RunAndReturn(run func(context.Context, *node.Node) (node.Status, error)) *MockPlatform_gateway_GetStatus_Call

type MockPlatform_gateway_StartNode_Call 

type MockPlatform_gateway_StartNode_Call struct {
	*mock.Call
}

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

func (*MockPlatform_gateway_StartNode_Call) Return 

func (_c *MockPlatform_gateway_StartNode_Call) Return(_a0 error) *MockPlatform_gateway_StartNode_Call

func (*MockPlatform_gateway_StartNode_Call) Run 

func (_c *MockPlatform_gateway_StartNode_Call) Run(run func(_a0 context.Context, _a1 *node.Node)) *MockPlatform_gateway_StartNode_Call

func (*MockPlatform_gateway_StartNode_Call) RunAndReturn 

func (_c *MockPlatform_gateway_StartNode_Call) RunAndReturn(run func(context.Context, *node.Node) error) *MockPlatform_gateway_StartNode_Call

type MockPlatform_gateway_StopNode_Call 

type MockPlatform_gateway_StopNode_Call struct {
	*mock.Call
}

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

func (*MockPlatform_gateway_StopNode_Call) Return 

func (_c *MockPlatform_gateway_StopNode_Call) Return(_a0 error) *MockPlatform_gateway_StopNode_Call

func (*MockPlatform_gateway_StopNode_Call) Run 

func (_c *MockPlatform_gateway_StopNode_Call) Run(run func(_a0 context.Context, _a1 *node.Node)) *MockPlatform_gateway_StopNode_Call

func (*MockPlatform_gateway_StopNode_Call) RunAndReturn 

func (_c *MockPlatform_gateway_StopNode_Call) RunAndReturn(run func(context.Context, *node.Node) error) *MockPlatform_gateway_StopNode_Call

type MockProvider_service 

type MockProvider_service struct {
	mock.Mock
}

MockProvider_service is an autogenerated mock type for the Provider type

func NewMockProvider_service 

func NewMockProvider_service(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockProvider_service

NewMockProvider_service creates a new instance of MockProvider_service. 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 (*MockProvider_service) Describe 

func (_m *MockProvider_service) Describe(_a0 context.Context, _a1 provider.Identifier) (*provider.Provider, error)

Describe provides a mock function with given fields: _a0, _a1

func (*MockProvider_service) EXPECT 

func (_m *MockProvider_service) EXPECT() *MockProvider_service_Expecter

func (*MockProvider_service) List 

func (_m *MockProvider_service) List(_a0 context.Context) ([]*provider.Provider, error)

List provides a mock function with given fields: _a0

type MockProvider_service_Describe_Call 

type MockProvider_service_Describe_Call struct {
	*mock.Call
}

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

func (*MockProvider_service_Describe_Call) Return 

func (_c *MockProvider_service_Describe_Call) Return(_a0 *provider.Provider, _a1 error) *MockProvider_service_Describe_Call

func (*MockProvider_service_Describe_Call) Run 

func (_c *MockProvider_service_Describe_Call) Run(run func(_a0 context.Context, _a1 provider.Identifier)) *MockProvider_service_Describe_Call

func (*MockProvider_service_Describe_Call) RunAndReturn 

func (_c *MockProvider_service_Describe_Call) RunAndReturn(run func(context.Context, provider.Identifier) (*provider.Provider, error)) *MockProvider_service_Describe_Call

type MockProvider_service_Expecter 

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

func (*MockProvider_service_Expecter) Describe 

func (_e *MockProvider_service_Expecter) Describe(_a0 interface{}, _a1 interface{}) *MockProvider_service_Describe_Call

Describe is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 provider.Identifier

func (*MockProvider_service_Expecter) List 

func (_e *MockProvider_service_Expecter) List(_a0 interface{}) *MockProvider_service_List_Call

List is a helper method to define mock.On call

  • _a0 context.Context

type MockProvider_service_List_Call 

type MockProvider_service_List_Call struct {
	*mock.Call
}

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

func (*MockProvider_service_List_Call) Return 

func (_c *MockProvider_service_List_Call) Return(_a0 []*provider.Provider, _a1 error) *MockProvider_service_List_Call

func (*MockProvider_service_List_Call) Run 

func (_c *MockProvider_service_List_Call) Run(run func(_a0 context.Context)) *MockProvider_service_List_Call

func (*MockProvider_service_List_Call) RunAndReturn 

func (_c *MockProvider_service_List_Call) RunAndReturn(run func(context.Context) ([]*provider.Provider, error)) *MockProvider_service_List_Call

type MockSqlDatabase_interfaces 

type MockSqlDatabase_interfaces struct {
	mock.Mock
}

MockSqlDatabase_interfaces is an autogenerated mock type for the SqlDatabase type

func NewMockSqlDatabase_interfaces 

func NewMockSqlDatabase_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSqlDatabase_interfaces

NewMockSqlDatabase_interfaces creates a new instance of MockSqlDatabase_interfaces. 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 (*MockSqlDatabase_interfaces) Close 

func (_m *MockSqlDatabase_interfaces) Close() error

Close provides a mock function with given fields:

func (*MockSqlDatabase_interfaces) EXPECT 

func (_m *MockSqlDatabase_interfaces) EXPECT() *MockSqlDatabase_interfaces_Expecter

func (*MockSqlDatabase_interfaces) ExecContext 

func (_m *MockSqlDatabase_interfaces) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)

ExecContext provides a mock function with given fields: ctx, query, args

func (*MockSqlDatabase_interfaces) GetContext 

func (_m *MockSqlDatabase_interfaces) GetContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

GetContext provides a mock function with given fields: ctx, dest, query, args

func (*MockSqlDatabase_interfaces) SelectContext 

func (_m *MockSqlDatabase_interfaces) SelectContext(ctx context.Context, dest interface{}, query string, args ...interface{}) error

SelectContext provides a mock function with given fields: ctx, dest, query, args

type MockSqlDatabase_interfaces_Close_Call 

type MockSqlDatabase_interfaces_Close_Call struct {
	*mock.Call
}

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

func (*MockSqlDatabase_interfaces_Close_Call) Return 

func (_c *MockSqlDatabase_interfaces_Close_Call) Return(_a0 error) *MockSqlDatabase_interfaces_Close_Call

func (*MockSqlDatabase_interfaces_Close_Call) Run 

func (_c *MockSqlDatabase_interfaces_Close_Call) Run(run func()) *MockSqlDatabase_interfaces_Close_Call

func (*MockSqlDatabase_interfaces_Close_Call) RunAndReturn 

func (_c *MockSqlDatabase_interfaces_Close_Call) RunAndReturn(run func() error) *MockSqlDatabase_interfaces_Close_Call

type MockSqlDatabase_interfaces_ExecContext_Call 

type MockSqlDatabase_interfaces_ExecContext_Call struct {
	*mock.Call
}

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

func (*MockSqlDatabase_interfaces_ExecContext_Call) Return 

func (_c *MockSqlDatabase_interfaces_ExecContext_Call) Return(_a0 sql.Result, _a1 error) *MockSqlDatabase_interfaces_ExecContext_Call

func (*MockSqlDatabase_interfaces_ExecContext_Call) Run 

func (_c *MockSqlDatabase_interfaces_ExecContext_Call) Run(run func(ctx context.Context, query string, args ...interface{})) *MockSqlDatabase_interfaces_ExecContext_Call

func (*MockSqlDatabase_interfaces_ExecContext_Call) RunAndReturn 

func (_c *MockSqlDatabase_interfaces_ExecContext_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (sql.Result, error)) *MockSqlDatabase_interfaces_ExecContext_Call

type MockSqlDatabase_interfaces_Expecter 

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

func (*MockSqlDatabase_interfaces_Expecter) Close 

func (_e *MockSqlDatabase_interfaces_Expecter) Close() *MockSqlDatabase_interfaces_Close_Call

Close is a helper method to define mock.On call

func (*MockSqlDatabase_interfaces_Expecter) ExecContext 

func (_e *MockSqlDatabase_interfaces_Expecter) ExecContext(ctx interface{}, query interface{}, args ...interface{}) *MockSqlDatabase_interfaces_ExecContext_Call

ExecContext is a helper method to define mock.On call

  • ctx context.Context
  • query string
  • args ...interface{}

func (*MockSqlDatabase_interfaces_Expecter) GetContext 

func (_e *MockSqlDatabase_interfaces_Expecter) GetContext(ctx interface{}, dest interface{}, query interface{}, args ...interface{}) *MockSqlDatabase_interfaces_GetContext_Call

GetContext is a helper method to define mock.On call

  • ctx context.Context
  • dest interface{}
  • query string
  • args ...interface{}

func (*MockSqlDatabase_interfaces_Expecter) SelectContext 

func (_e *MockSqlDatabase_interfaces_Expecter) SelectContext(ctx interface{}, dest interface{}, query interface{}, args ...interface{}) *MockSqlDatabase_interfaces_SelectContext_Call

SelectContext is a helper method to define mock.On call

  • ctx context.Context
  • dest interface{}
  • query string
  • args ...interface{}

type MockSqlDatabase_interfaces_GetContext_Call 

type MockSqlDatabase_interfaces_GetContext_Call struct {
	*mock.Call
}

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

func (*MockSqlDatabase_interfaces_GetContext_Call) Return 

func (_c *MockSqlDatabase_interfaces_GetContext_Call) Return(_a0 error) *MockSqlDatabase_interfaces_GetContext_Call

func (*MockSqlDatabase_interfaces_GetContext_Call) Run 

func (_c *MockSqlDatabase_interfaces_GetContext_Call) Run(run func(ctx context.Context, dest interface{}, query string, args ...interface{})) *MockSqlDatabase_interfaces_GetContext_Call

func (*MockSqlDatabase_interfaces_GetContext_Call) RunAndReturn 

func (_c *MockSqlDatabase_interfaces_GetContext_Call) RunAndReturn(run func(context.Context, interface{}, string, ...interface{}) error) *MockSqlDatabase_interfaces_GetContext_Call

type MockSqlDatabase_interfaces_SelectContext_Call 

type MockSqlDatabase_interfaces_SelectContext_Call struct {
	*mock.Call
}

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

func (*MockSqlDatabase_interfaces_SelectContext_Call) Return 

func (_c *MockSqlDatabase_interfaces_SelectContext_Call) Return(_a0 error) *MockSqlDatabase_interfaces_SelectContext_Call

func (*MockSqlDatabase_interfaces_SelectContext_Call) Run 

func (_c *MockSqlDatabase_interfaces_SelectContext_Call) Run(run func(ctx context.Context, dest interface{}, query string, args ...interface{})) *MockSqlDatabase_interfaces_SelectContext_Call

func (*MockSqlDatabase_interfaces_SelectContext_Call) RunAndReturn 

func (_c *MockSqlDatabase_interfaces_SelectContext_Call) RunAndReturn(run func(context.Context, interface{}, string, ...interface{}) error) *MockSqlDatabase_interfaces_SelectContext_Call

type MockSsmClient_interfaces 

type MockSsmClient_interfaces struct {
	mock.Mock
}

MockSsmClient_interfaces is an autogenerated mock type for the SsmClient type

func NewMockSsmClient_interfaces 

func NewMockSsmClient_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSsmClient_interfaces

NewMockSsmClient_interfaces creates a new instance of MockSsmClient_interfaces. 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 (*MockSsmClient_interfaces) DeleteParameter 

func (_m *MockSsmClient_interfaces) DeleteParameter(ctx context.Context, params *ssm.DeleteParameterInput, optFns ...func(*ssm.Options)) (*ssm.DeleteParameterOutput, error)

DeleteParameter provides a mock function with given fields: ctx, params, optFns

func (*MockSsmClient_interfaces) DescribeParameters 

func (_m *MockSsmClient_interfaces) DescribeParameters(ctx context.Context, params *ssm.DescribeParametersInput, optFns ...func(*ssm.Options)) (*ssm.DescribeParametersOutput, error)

DescribeParameters provides a mock function with given fields: ctx, params, optFns

func (*MockSsmClient_interfaces) EXPECT 

func (_m *MockSsmClient_interfaces) EXPECT() *MockSsmClient_interfaces_Expecter

func (*MockSsmClient_interfaces) GetParameter 

func (_m *MockSsmClient_interfaces) GetParameter(ctx context.Context, params *ssm.GetParameterInput, optFns ...func(*ssm.Options)) (*ssm.GetParameterOutput, error)

GetParameter provides a mock function with given fields: ctx, params, optFns

func (*MockSsmClient_interfaces) PutParameter 

func (_m *MockSsmClient_interfaces) PutParameter(ctx context.Context, params *ssm.PutParameterInput, optFns ...func(*ssm.Options)) (*ssm.PutParameterOutput, error)

PutParameter provides a mock function with given fields: ctx, params, optFns

type MockSsmClient_interfaces_DeleteParameter_Call 

type MockSsmClient_interfaces_DeleteParameter_Call struct {
	*mock.Call
}

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

func (*MockSsmClient_interfaces_DeleteParameter_Call) Return 

func (_c *MockSsmClient_interfaces_DeleteParameter_Call) Return(_a0 *ssm.DeleteParameterOutput, _a1 error) *MockSsmClient_interfaces_DeleteParameter_Call

func (*MockSsmClient_interfaces_DeleteParameter_Call) Run 

func (_c *MockSsmClient_interfaces_DeleteParameter_Call) Run(run func(ctx context.Context, params *ssm.DeleteParameterInput, optFns ...func(*ssm.Options))) *MockSsmClient_interfaces_DeleteParameter_Call

func (*MockSsmClient_interfaces_DeleteParameter_Call) RunAndReturn 

func (_c *MockSsmClient_interfaces_DeleteParameter_Call) RunAndReturn(run func(context.Context, *ssm.DeleteParameterInput, ...func(*ssm.Options)) (*ssm.DeleteParameterOutput, error)) *MockSsmClient_interfaces_DeleteParameter_Call

type MockSsmClient_interfaces_DescribeParameters_Call 

type MockSsmClient_interfaces_DescribeParameters_Call struct {
	*mock.Call
}

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

func (*MockSsmClient_interfaces_DescribeParameters_Call) Return 

func (_c *MockSsmClient_interfaces_DescribeParameters_Call) Return(_a0 *ssm.DescribeParametersOutput, _a1 error) *MockSsmClient_interfaces_DescribeParameters_Call

func (*MockSsmClient_interfaces_DescribeParameters_Call) Run 

func (_c *MockSsmClient_interfaces_DescribeParameters_Call) Run(run func(ctx context.Context, params *ssm.DescribeParametersInput, optFns ...func(*ssm.Options))) *MockSsmClient_interfaces_DescribeParameters_Call

func (*MockSsmClient_interfaces_DescribeParameters_Call) RunAndReturn 

func (_c *MockSsmClient_interfaces_DescribeParameters_Call) RunAndReturn(run func(context.Context, *ssm.DescribeParametersInput, ...func(*ssm.Options)) (*ssm.DescribeParametersOutput, error)) *MockSsmClient_interfaces_DescribeParameters_Call

type MockSsmClient_interfaces_Expecter 

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

func (*MockSsmClient_interfaces_Expecter) DeleteParameter 

func (_e *MockSsmClient_interfaces_Expecter) DeleteParameter(ctx interface{}, params interface{}, optFns ...interface{}) *MockSsmClient_interfaces_DeleteParameter_Call

DeleteParameter is a helper method to define mock.On call

  • ctx context.Context
  • params *ssm.DeleteParameterInput
  • optFns ...func(*ssm.Options)

func (*MockSsmClient_interfaces_Expecter) DescribeParameters 

func (_e *MockSsmClient_interfaces_Expecter) DescribeParameters(ctx interface{}, params interface{}, optFns ...interface{}) *MockSsmClient_interfaces_DescribeParameters_Call

DescribeParameters is a helper method to define mock.On call

  • ctx context.Context
  • params *ssm.DescribeParametersInput
  • optFns ...func(*ssm.Options)

func (*MockSsmClient_interfaces_Expecter) GetParameter 

func (_e *MockSsmClient_interfaces_Expecter) GetParameter(ctx interface{}, params interface{}, optFns ...interface{}) *MockSsmClient_interfaces_GetParameter_Call

GetParameter is a helper method to define mock.On call

  • ctx context.Context
  • params *ssm.GetParameterInput
  • optFns ...func(*ssm.Options)

func (*MockSsmClient_interfaces_Expecter) PutParameter 

func (_e *MockSsmClient_interfaces_Expecter) PutParameter(ctx interface{}, params interface{}, optFns ...interface{}) *MockSsmClient_interfaces_PutParameter_Call

PutParameter is a helper method to define mock.On call

  • ctx context.Context
  • params *ssm.PutParameterInput
  • optFns ...func(*ssm.Options)

type MockSsmClient_interfaces_GetParameter_Call 

type MockSsmClient_interfaces_GetParameter_Call struct {
	*mock.Call
}

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

func (*MockSsmClient_interfaces_GetParameter_Call) Return 

func (_c *MockSsmClient_interfaces_GetParameter_Call) Return(_a0 *ssm.GetParameterOutput, _a1 error) *MockSsmClient_interfaces_GetParameter_Call

func (*MockSsmClient_interfaces_GetParameter_Call) Run 

func (_c *MockSsmClient_interfaces_GetParameter_Call) Run(run func(ctx context.Context, params *ssm.GetParameterInput, optFns ...func(*ssm.Options))) *MockSsmClient_interfaces_GetParameter_Call

func (*MockSsmClient_interfaces_GetParameter_Call) RunAndReturn 

func (_c *MockSsmClient_interfaces_GetParameter_Call) RunAndReturn(run func(context.Context, *ssm.GetParameterInput, ...func(*ssm.Options)) (*ssm.GetParameterOutput, error)) *MockSsmClient_interfaces_GetParameter_Call

type MockSsmClient_interfaces_PutParameter_Call 

type MockSsmClient_interfaces_PutParameter_Call struct {
	*mock.Call
}

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

func (*MockSsmClient_interfaces_PutParameter_Call) Return 

func (_c *MockSsmClient_interfaces_PutParameter_Call) Return(_a0 *ssm.PutParameterOutput, _a1 error) *MockSsmClient_interfaces_PutParameter_Call

func (*MockSsmClient_interfaces_PutParameter_Call) Run 

func (_c *MockSsmClient_interfaces_PutParameter_Call) Run(run func(ctx context.Context, params *ssm.PutParameterInput, optFns ...func(*ssm.Options))) *MockSsmClient_interfaces_PutParameter_Call

func (*MockSsmClient_interfaces_PutParameter_Call) RunAndReturn 

func (_c *MockSsmClient_interfaces_PutParameter_Call) RunAndReturn(run func(context.Context, *ssm.PutParameterInput, ...func(*ssm.Options)) (*ssm.PutParameterOutput, error)) *MockSsmClient_interfaces_PutParameter_Call

type MockTailnet_gateway 

type MockTailnet_gateway struct {
	mock.Mock
}

MockTailnet_gateway is an autogenerated mock type for the Tailnet type

func NewMockTailnet_gateway 

func NewMockTailnet_gateway(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTailnet_gateway

NewMockTailnet_gateway creates a new instance of MockTailnet_gateway. 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 (*MockTailnet_gateway) CreatePreauthKey 

func (_m *MockTailnet_gateway) CreatePreauthKey(_a0 context.Context, _a1 bool) (tailnet.PreauthKey, error)

CreatePreauthKey provides a mock function with given fields: _a0, _a1

func (*MockTailnet_gateway) DeleteDevice 

func (_m *MockTailnet_gateway) DeleteDevice(_a0 context.Context, _a1 tailnet.DeviceIdentifier) error

DeleteDevice provides a mock function with given fields: _a0, _a1

func (*MockTailnet_gateway) DeletePreauthKey 

func (_m *MockTailnet_gateway) DeletePreauthKey(_a0 context.Context, _a1 tailnet.PreauthKey) error

DeletePreauthKey provides a mock function with given fields: _a0, _a1

func (*MockTailnet_gateway) EXPECT 

func (_m *MockTailnet_gateway) EXPECT() *MockTailnet_gateway_Expecter

func (*MockTailnet_gateway) EnableExitNode 

func (_m *MockTailnet_gateway) EnableExitNode(_a0 context.Context, _a1 tailnet.DeviceIdentifier) error

EnableExitNode provides a mock function with given fields: _a0, _a1

func (*MockTailnet_gateway) GetDeviceId 

func (_m *MockTailnet_gateway) GetDeviceId(_a0 context.Context, _a1 tailnet.DeviceName) (tailnet.DeviceIdentifier, error)

GetDeviceId provides a mock function with given fields: _a0, _a1

type MockTailnet_gateway_CreatePreauthKey_Call 

type MockTailnet_gateway_CreatePreauthKey_Call struct {
	*mock.Call
}

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

func (*MockTailnet_gateway_CreatePreauthKey_Call) Return 

func (_c *MockTailnet_gateway_CreatePreauthKey_Call) Return(_a0 tailnet.PreauthKey, _a1 error) *MockTailnet_gateway_CreatePreauthKey_Call

func (*MockTailnet_gateway_CreatePreauthKey_Call) Run 

func (_c *MockTailnet_gateway_CreatePreauthKey_Call) Run(run func(_a0 context.Context, _a1 bool)) *MockTailnet_gateway_CreatePreauthKey_Call

func (*MockTailnet_gateway_CreatePreauthKey_Call) RunAndReturn 

func (_c *MockTailnet_gateway_CreatePreauthKey_Call) RunAndReturn(run func(context.Context, bool) (tailnet.PreauthKey, error)) *MockTailnet_gateway_CreatePreauthKey_Call

type MockTailnet_gateway_DeleteDevice_Call 

type MockTailnet_gateway_DeleteDevice_Call struct {
	*mock.Call
}

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

func (*MockTailnet_gateway_DeleteDevice_Call) Return 

func (_c *MockTailnet_gateway_DeleteDevice_Call) Return(_a0 error) *MockTailnet_gateway_DeleteDevice_Call

func (*MockTailnet_gateway_DeleteDevice_Call) Run 

func (_c *MockTailnet_gateway_DeleteDevice_Call) Run(run func(_a0 context.Context, _a1 tailnet.DeviceIdentifier)) *MockTailnet_gateway_DeleteDevice_Call

func (*MockTailnet_gateway_DeleteDevice_Call) RunAndReturn 

func (_c *MockTailnet_gateway_DeleteDevice_Call) RunAndReturn(run func(context.Context, tailnet.DeviceIdentifier) error) *MockTailnet_gateway_DeleteDevice_Call

type MockTailnet_gateway_DeletePreauthKey_Call 

type MockTailnet_gateway_DeletePreauthKey_Call struct {
	*mock.Call
}

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

func (*MockTailnet_gateway_DeletePreauthKey_Call) Return 

func (_c *MockTailnet_gateway_DeletePreauthKey_Call) Return(_a0 error) *MockTailnet_gateway_DeletePreauthKey_Call

func (*MockTailnet_gateway_DeletePreauthKey_Call) Run 

func (_c *MockTailnet_gateway_DeletePreauthKey_Call) Run(run func(_a0 context.Context, _a1 tailnet.PreauthKey)) *MockTailnet_gateway_DeletePreauthKey_Call

func (*MockTailnet_gateway_DeletePreauthKey_Call) RunAndReturn 

func (_c *MockTailnet_gateway_DeletePreauthKey_Call) RunAndReturn(run func(context.Context, tailnet.PreauthKey) error) *MockTailnet_gateway_DeletePreauthKey_Call

type MockTailnet_gateway_EnableExitNode_Call 

type MockTailnet_gateway_EnableExitNode_Call struct {
	*mock.Call
}

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

func (*MockTailnet_gateway_EnableExitNode_Call) Return 

func (_c *MockTailnet_gateway_EnableExitNode_Call) Return(_a0 error) *MockTailnet_gateway_EnableExitNode_Call

func (*MockTailnet_gateway_EnableExitNode_Call) Run 

func (_c *MockTailnet_gateway_EnableExitNode_Call) Run(run func(_a0 context.Context, _a1 tailnet.DeviceIdentifier)) *MockTailnet_gateway_EnableExitNode_Call

func (*MockTailnet_gateway_EnableExitNode_Call) RunAndReturn 

func (_c *MockTailnet_gateway_EnableExitNode_Call) RunAndReturn(run func(context.Context, tailnet.DeviceIdentifier) error) *MockTailnet_gateway_EnableExitNode_Call

type MockTailnet_gateway_Expecter 

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

func (*MockTailnet_gateway_Expecter) CreatePreauthKey 

func (_e *MockTailnet_gateway_Expecter) CreatePreauthKey(_a0 interface{}, _a1 interface{}) *MockTailnet_gateway_CreatePreauthKey_Call

CreatePreauthKey is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 bool

func (*MockTailnet_gateway_Expecter) DeleteDevice 

func (_e *MockTailnet_gateway_Expecter) DeleteDevice(_a0 interface{}, _a1 interface{}) *MockTailnet_gateway_DeleteDevice_Call

DeleteDevice is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 tailnet.DeviceIdentifier

func (*MockTailnet_gateway_Expecter) DeletePreauthKey 

func (_e *MockTailnet_gateway_Expecter) DeletePreauthKey(_a0 interface{}, _a1 interface{}) *MockTailnet_gateway_DeletePreauthKey_Call

DeletePreauthKey is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 tailnet.PreauthKey

func (*MockTailnet_gateway_Expecter) EnableExitNode 

func (_e *MockTailnet_gateway_Expecter) EnableExitNode(_a0 interface{}, _a1 interface{}) *MockTailnet_gateway_EnableExitNode_Call

EnableExitNode is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 tailnet.DeviceIdentifier

func (*MockTailnet_gateway_Expecter) GetDeviceId 

func (_e *MockTailnet_gateway_Expecter) GetDeviceId(_a0 interface{}, _a1 interface{}) *MockTailnet_gateway_GetDeviceId_Call

GetDeviceId is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 tailnet.DeviceName

type MockTailnet_gateway_GetDeviceId_Call 

type MockTailnet_gateway_GetDeviceId_Call struct {
	*mock.Call
}

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

func (*MockTailnet_gateway_GetDeviceId_Call) Return 

func (_c *MockTailnet_gateway_GetDeviceId_Call) Return(_a0 tailnet.DeviceIdentifier, _a1 error) *MockTailnet_gateway_GetDeviceId_Call

func (*MockTailnet_gateway_GetDeviceId_Call) Run 

func (_c *MockTailnet_gateway_GetDeviceId_Call) Run(run func(_a0 context.Context, _a1 tailnet.DeviceName)) *MockTailnet_gateway_GetDeviceId_Call

func (*MockTailnet_gateway_GetDeviceId_Call) RunAndReturn 

func (_c *MockTailnet_gateway_GetDeviceId_Call) RunAndReturn(run func(context.Context, tailnet.DeviceName) (tailnet.DeviceIdentifier, error)) *MockTailnet_gateway_GetDeviceId_Call

type MockTailnet_service 

type MockTailnet_service struct {
	mock.Mock
}

MockTailnet_service is an autogenerated mock type for the Tailnet type

func NewMockTailnet_service 

func NewMockTailnet_service(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTailnet_service

NewMockTailnet_service creates a new instance of MockTailnet_service. 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 (*MockTailnet_service) Describe 

func (_m *MockTailnet_service) Describe(_a0 context.Context, _a1 tailnet.Identifier) (*tailnet.Tailnet, error)

Describe provides a mock function with given fields: _a0, _a1

func (*MockTailnet_service) EXPECT 

func (_m *MockTailnet_service) EXPECT() *MockTailnet_service_Expecter

func (*MockTailnet_service) List 

func (_m *MockTailnet_service) List(_a0 context.Context) ([]*tailnet.Tailnet, error)

List provides a mock function with given fields: _a0

type MockTailnet_service_Describe_Call 

type MockTailnet_service_Describe_Call struct {
	*mock.Call
}

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

func (*MockTailnet_service_Describe_Call) Return 

func (_c *MockTailnet_service_Describe_Call) Return(_a0 *tailnet.Tailnet, _a1 error) *MockTailnet_service_Describe_Call

func (*MockTailnet_service_Describe_Call) Run 

func (_c *MockTailnet_service_Describe_Call) Run(run func(_a0 context.Context, _a1 tailnet.Identifier)) *MockTailnet_service_Describe_Call

func (*MockTailnet_service_Describe_Call) RunAndReturn 

func (_c *MockTailnet_service_Describe_Call) RunAndReturn(run func(context.Context, tailnet.Identifier) (*tailnet.Tailnet, error)) *MockTailnet_service_Describe_Call

type MockTailnet_service_Expecter 

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

func (*MockTailnet_service_Expecter) Describe 

func (_e *MockTailnet_service_Expecter) Describe(_a0 interface{}, _a1 interface{}) *MockTailnet_service_Describe_Call

Describe is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 tailnet.Identifier

func (*MockTailnet_service_Expecter) List 

func (_e *MockTailnet_service_Expecter) List(_a0 interface{}) *MockTailnet_service_List_Call

List is a helper method to define mock.On call

  • _a0 context.Context

type MockTailnet_service_List_Call 

type MockTailnet_service_List_Call struct {
	*mock.Call
}

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

func (*MockTailnet_service_List_Call) Return 

func (_c *MockTailnet_service_List_Call) Return(_a0 []*tailnet.Tailnet, _a1 error) *MockTailnet_service_List_Call

func (*MockTailnet_service_List_Call) Run 

func (_c *MockTailnet_service_List_Call) Run(run func(_a0 context.Context)) *MockTailnet_service_List_Call

func (*MockTailnet_service_List_Call) RunAndReturn 

func (_c *MockTailnet_service_List_Call) RunAndReturn(run func(context.Context) ([]*tailnet.Tailnet, error)) *MockTailnet_service_List_Call

type MockTailscale_interfaces 

type MockTailscale_interfaces struct {
	mock.Mock
}

MockTailscale_interfaces is an autogenerated mock type for the Tailscale type

func NewMockTailscale_interfaces 

func NewMockTailscale_interfaces(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockTailscale_interfaces

NewMockTailscale_interfaces creates a new instance of MockTailscale_interfaces. 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 (*MockTailscale_interfaces) ACL 

func (_m *MockTailscale_interfaces) ACL(ctx context.Context) (*tailscale.ACL, error)

ACL provides a mock function with given fields: ctx

func (*MockTailscale_interfaces) CreateKey 

func (_m *MockTailscale_interfaces) CreateKey(ctx context.Context, caps tailscale.KeyCapabilities, opts ...tailscale.CreateKeyOption) (tailscale.Key, error)

CreateKey provides a mock function with given fields: ctx, caps, opts

func (*MockTailscale_interfaces) DeleteDevice 

func (_m *MockTailscale_interfaces) DeleteDevice(_a0 context.Context, _a1 string) error

DeleteDevice provides a mock function with given fields: _a0, _a1

func (*MockTailscale_interfaces) DeleteKey 

func (_m *MockTailscale_interfaces) DeleteKey(_a0 context.Context, _a1 string) error

DeleteKey provides a mock function with given fields: _a0, _a1

func (*MockTailscale_interfaces) Devices 

func (_m *MockTailscale_interfaces) Devices(ctx context.Context) ([]tailscale.Device, error)

Devices provides a mock function with given fields: ctx

func (*MockTailscale_interfaces) EXPECT 

func (_m *MockTailscale_interfaces) EXPECT() *MockTailscale_interfaces_Expecter

func (*MockTailscale_interfaces) SetACL 

func (_m *MockTailscale_interfaces) SetACL(ctx context.Context, acl tailscale.ACL, opts ...tailscale.SetACLOption) error

SetACL provides a mock function with given fields: ctx, acl, opts

func (*MockTailscale_interfaces) SetDeviceTags 

func (_m *MockTailscale_interfaces) SetDeviceTags(ctx context.Context, deviceID string, tags []string) error

SetDeviceTags provides a mock function with given fields: ctx, deviceID, tags

func (*MockTailscale_interfaces) ValidateACL 

func (_m *MockTailscale_interfaces) ValidateACL(ctx context.Context, acl tailscale.ACL) error

ValidateACL provides a mock function with given fields: ctx, acl

type MockTailscale_interfaces_ACL_Call 

type MockTailscale_interfaces_ACL_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_ACL_Call) Return 

func (_c *MockTailscale_interfaces_ACL_Call) Return(_a0 *tailscale.ACL, _a1 error) *MockTailscale_interfaces_ACL_Call

func (*MockTailscale_interfaces_ACL_Call) Run 

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

func (*MockTailscale_interfaces_ACL_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_ACL_Call) RunAndReturn(run func(context.Context) (*tailscale.ACL, error)) *MockTailscale_interfaces_ACL_Call

type MockTailscale_interfaces_CreateKey_Call 

type MockTailscale_interfaces_CreateKey_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_CreateKey_Call) Return 

func (_c *MockTailscale_interfaces_CreateKey_Call) Return(_a0 tailscale.Key, _a1 error) *MockTailscale_interfaces_CreateKey_Call

func (*MockTailscale_interfaces_CreateKey_Call) Run 

func (_c *MockTailscale_interfaces_CreateKey_Call) Run(run func(ctx context.Context, caps tailscale.KeyCapabilities, opts ...tailscale.CreateKeyOption)) *MockTailscale_interfaces_CreateKey_Call

func (*MockTailscale_interfaces_CreateKey_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_CreateKey_Call) RunAndReturn(run func(context.Context, tailscale.KeyCapabilities, ...tailscale.CreateKeyOption) (tailscale.Key, error)) *MockTailscale_interfaces_CreateKey_Call

type MockTailscale_interfaces_DeleteDevice_Call 

type MockTailscale_interfaces_DeleteDevice_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_DeleteDevice_Call) Return 

func (_c *MockTailscale_interfaces_DeleteDevice_Call) Return(_a0 error) *MockTailscale_interfaces_DeleteDevice_Call

func (*MockTailscale_interfaces_DeleteDevice_Call) Run 

func (_c *MockTailscale_interfaces_DeleteDevice_Call) Run(run func(_a0 context.Context, _a1 string)) *MockTailscale_interfaces_DeleteDevice_Call

func (*MockTailscale_interfaces_DeleteDevice_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_DeleteDevice_Call) RunAndReturn(run func(context.Context, string) error) *MockTailscale_interfaces_DeleteDevice_Call

type MockTailscale_interfaces_DeleteKey_Call 

type MockTailscale_interfaces_DeleteKey_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_DeleteKey_Call) Return 

func (_c *MockTailscale_interfaces_DeleteKey_Call) Return(_a0 error) *MockTailscale_interfaces_DeleteKey_Call

func (*MockTailscale_interfaces_DeleteKey_Call) Run 

func (_c *MockTailscale_interfaces_DeleteKey_Call) Run(run func(_a0 context.Context, _a1 string)) *MockTailscale_interfaces_DeleteKey_Call

func (*MockTailscale_interfaces_DeleteKey_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_DeleteKey_Call) RunAndReturn(run func(context.Context, string) error) *MockTailscale_interfaces_DeleteKey_Call

type MockTailscale_interfaces_Devices_Call 

type MockTailscale_interfaces_Devices_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_Devices_Call) Return 

func (_c *MockTailscale_interfaces_Devices_Call) Return(_a0 []tailscale.Device, _a1 error) *MockTailscale_interfaces_Devices_Call

func (*MockTailscale_interfaces_Devices_Call) Run 

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

func (*MockTailscale_interfaces_Devices_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_Devices_Call) RunAndReturn(run func(context.Context) ([]tailscale.Device, error)) *MockTailscale_interfaces_Devices_Call

type MockTailscale_interfaces_Expecter 

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

func (*MockTailscale_interfaces_Expecter) ACL 

func (_e *MockTailscale_interfaces_Expecter) ACL(ctx interface{}) *MockTailscale_interfaces_ACL_Call

ACL is a helper method to define mock.On call

  • ctx context.Context

func (*MockTailscale_interfaces_Expecter) CreateKey 

func (_e *MockTailscale_interfaces_Expecter) CreateKey(ctx interface{}, caps interface{}, opts ...interface{}) *MockTailscale_interfaces_CreateKey_Call

CreateKey is a helper method to define mock.On call

  • ctx context.Context
  • caps tailscale.KeyCapabilities
  • opts ...tailscale.CreateKeyOption

func (*MockTailscale_interfaces_Expecter) DeleteDevice 

func (_e *MockTailscale_interfaces_Expecter) DeleteDevice(_a0 interface{}, _a1 interface{}) *MockTailscale_interfaces_DeleteDevice_Call

DeleteDevice is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 string

func (*MockTailscale_interfaces_Expecter) DeleteKey 

func (_e *MockTailscale_interfaces_Expecter) DeleteKey(_a0 interface{}, _a1 interface{}) *MockTailscale_interfaces_DeleteKey_Call

DeleteKey is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 string

func (*MockTailscale_interfaces_Expecter) Devices 

func (_e *MockTailscale_interfaces_Expecter) Devices(ctx interface{}) *MockTailscale_interfaces_Devices_Call

Devices is a helper method to define mock.On call

  • ctx context.Context

func (*MockTailscale_interfaces_Expecter) SetACL 

func (_e *MockTailscale_interfaces_Expecter) SetACL(ctx interface{}, acl interface{}, opts ...interface{}) *MockTailscale_interfaces_SetACL_Call

SetACL is a helper method to define mock.On call

  • ctx context.Context
  • acl tailscale.ACL
  • opts ...tailscale.SetACLOption

func (*MockTailscale_interfaces_Expecter) SetDeviceTags 

func (_e *MockTailscale_interfaces_Expecter) SetDeviceTags(ctx interface{}, deviceID interface{}, tags interface{}) *MockTailscale_interfaces_SetDeviceTags_Call

SetDeviceTags is a helper method to define mock.On call

  • ctx context.Context
  • deviceID string
  • tags []string

func (*MockTailscale_interfaces_Expecter) ValidateACL 

func (_e *MockTailscale_interfaces_Expecter) ValidateACL(ctx interface{}, acl interface{}) *MockTailscale_interfaces_ValidateACL_Call

ValidateACL is a helper method to define mock.On call

  • ctx context.Context
  • acl tailscale.ACL

type MockTailscale_interfaces_SetACL_Call 

type MockTailscale_interfaces_SetACL_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_SetACL_Call) Return 

func (_c *MockTailscale_interfaces_SetACL_Call) Return(_a0 error) *MockTailscale_interfaces_SetACL_Call

func (*MockTailscale_interfaces_SetACL_Call) Run 

func (_c *MockTailscale_interfaces_SetACL_Call) Run(run func(ctx context.Context, acl tailscale.ACL, opts ...tailscale.SetACLOption)) *MockTailscale_interfaces_SetACL_Call

func (*MockTailscale_interfaces_SetACL_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_SetACL_Call) RunAndReturn(run func(context.Context, tailscale.ACL, ...tailscale.SetACLOption) error) *MockTailscale_interfaces_SetACL_Call

type MockTailscale_interfaces_SetDeviceTags_Call 

type MockTailscale_interfaces_SetDeviceTags_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_SetDeviceTags_Call) Return 

func (_c *MockTailscale_interfaces_SetDeviceTags_Call) Return(_a0 error) *MockTailscale_interfaces_SetDeviceTags_Call

func (*MockTailscale_interfaces_SetDeviceTags_Call) Run 

func (_c *MockTailscale_interfaces_SetDeviceTags_Call) Run(run func(ctx context.Context, deviceID string, tags []string)) *MockTailscale_interfaces_SetDeviceTags_Call

func (*MockTailscale_interfaces_SetDeviceTags_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_SetDeviceTags_Call) RunAndReturn(run func(context.Context, string, []string) error) *MockTailscale_interfaces_SetDeviceTags_Call

type MockTailscale_interfaces_ValidateACL_Call 

type MockTailscale_interfaces_ValidateACL_Call struct {
	*mock.Call
}

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

func (*MockTailscale_interfaces_ValidateACL_Call) Return 

func (_c *MockTailscale_interfaces_ValidateACL_Call) Return(_a0 error) *MockTailscale_interfaces_ValidateACL_Call

func (*MockTailscale_interfaces_ValidateACL_Call) Run 

func (_c *MockTailscale_interfaces_ValidateACL_Call) Run(run func(ctx context.Context, acl tailscale.ACL)) *MockTailscale_interfaces_ValidateACL_Call

func (*MockTailscale_interfaces_ValidateACL_Call) RunAndReturn 

func (_c *MockTailscale_interfaces_ValidateACL_Call) RunAndReturn(run func(context.Context, tailscale.ACL) error) *MockTailscale_interfaces_ValidateACL_Call

type MockWorkflow_service 

type MockWorkflow_service struct {
	mock.Mock
}

MockWorkflow_service is an autogenerated mock type for the Workflow type

func NewMockWorkflow_service 

func NewMockWorkflow_service(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockWorkflow_service

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

func (_m *MockWorkflow_service) EXPECT() *MockWorkflow_service_Expecter

func (*MockWorkflow_service) GetExecution 

func (_m *MockWorkflow_service) GetExecution(_a0 context.Context, _a1 workflow.ExecutionIdentifier) (*workflow.Execution, error)

GetExecution provides a mock function with given fields: _a0, _a1

func (*MockWorkflow_service) LaunchDeprovisionNodeWorkflow 

func (_m *MockWorkflow_service) LaunchDeprovisionNodeWorkflow(_a0 context.Context, _a1 node.Identifier) (workflow.ExecutionIdentifier, error)

LaunchDeprovisionNodeWorkflow provides a mock function with given fields: _a0, _a1

func (*MockWorkflow_service) LaunchProvisionNodeWorkflow 

func (_m *MockWorkflow_service) LaunchProvisionNodeWorkflow(_a0 context.Context, _a1 *provider.Provider, _a2 provider.Location, _a3 *tailnet.Tailnet, _a4 bool) (workflow.ExecutionIdentifier, error)

LaunchProvisionNodeWorkflow provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4

type MockWorkflow_service_Expecter 

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

func (*MockWorkflow_service_Expecter) GetExecution 

func (_e *MockWorkflow_service_Expecter) GetExecution(_a0 interface{}, _a1 interface{}) *MockWorkflow_service_GetExecution_Call

GetExecution is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 workflow.ExecutionIdentifier

func (*MockWorkflow_service_Expecter) LaunchDeprovisionNodeWorkflow 

func (_e *MockWorkflow_service_Expecter) LaunchDeprovisionNodeWorkflow(_a0 interface{}, _a1 interface{}) *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call

LaunchDeprovisionNodeWorkflow is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 node.Identifier

func (*MockWorkflow_service_Expecter) LaunchProvisionNodeWorkflow 

func (_e *MockWorkflow_service_Expecter) LaunchProvisionNodeWorkflow(_a0 interface{}, _a1 interface{}, _a2 interface{}, _a3 interface{}, _a4 interface{}) *MockWorkflow_service_LaunchProvisionNodeWorkflow_Call

LaunchProvisionNodeWorkflow is a helper method to define mock.On call

  • _a0 context.Context
  • _a1 *provider.Provider
  • _a2 provider.Location
  • _a3 *tailnet.Tailnet
  • _a4 bool

type MockWorkflow_service_GetExecution_Call 

type MockWorkflow_service_GetExecution_Call struct {
	*mock.Call
}

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

func (*MockWorkflow_service_GetExecution_Call) Return 

func (_c *MockWorkflow_service_GetExecution_Call) Return(_a0 *workflow.Execution, _a1 error) *MockWorkflow_service_GetExecution_Call

func (*MockWorkflow_service_GetExecution_Call) Run 

func (_c *MockWorkflow_service_GetExecution_Call) Run(run func(_a0 context.Context, _a1 workflow.ExecutionIdentifier)) *MockWorkflow_service_GetExecution_Call

func (*MockWorkflow_service_GetExecution_Call) RunAndReturn 

func (_c *MockWorkflow_service_GetExecution_Call) RunAndReturn(run func(context.Context, workflow.ExecutionIdentifier) (*workflow.Execution, error)) *MockWorkflow_service_GetExecution_Call

type MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call 

type MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call struct {
	*mock.Call
}

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

func (*MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call) Return 

func (_c *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call) Return(_a0 workflow.ExecutionIdentifier, _a1 error) *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call

func (*MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call) Run 

func (_c *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call) Run(run func(_a0 context.Context, _a1 node.Identifier)) *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call

func (*MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call) RunAndReturn 

func (_c *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call) RunAndReturn(run func(context.Context, node.Identifier) (workflow.ExecutionIdentifier, error)) *MockWorkflow_service_LaunchDeprovisionNodeWorkflow_Call

type MockWorkflow_service_LaunchProvisionNodeWorkflow_Call 

type MockWorkflow_service_LaunchProvisionNodeWorkflow_Call struct {
	*mock.Call
}

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

func (*MockWorkflow_service_LaunchProvisionNodeWorkflow_Call) Return 

func (_c *MockWorkflow_service_LaunchProvisionNodeWorkflow_Call) Return(_a0 workflow.ExecutionIdentifier, _a1 error) *MockWorkflow_service_LaunchProvisionNodeWorkflow_Call

func (*MockWorkflow_service_LaunchProvisionNodeWorkflow_Call) Run 

func (_c *MockWorkflow_service_LaunchProvisionNodeWorkflow_Call) Run(run func(_a0 context.Context, _a1 *provider.Provider, _a2 provider.Location, _a3 *tailnet.Tailnet, _a4 bool)) *MockWorkflow_service_LaunchProvisionNodeWorkflow_Call

func (*MockWorkflow_service_LaunchProvisionNodeWorkflow_Call) RunAndReturn 

func (_c *MockWorkflow_service_LaunchProvisionNodeWorkflow_Call) RunAndReturn(run func(context.Context, *provider.Provider, provider.Location, *tailnet.Tailnet, bool) (workflow.ExecutionIdentifier, error)) *MockWorkflow_service_LaunchProvisionNodeWorkflow_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.