mocks

package

Go to main page

Versions in this module

v0

v0.2.0

Mar 1, 2023

v0.1.5

Jan 27, 2023

v0.1.4

Jan 12, 2023

v0.1.3

Nov 24, 2022

Changes in this version

type LoggableModule

+ func (_m *LoggableModule) Output(ctx context.Context, res module.ExpandedResource) (json.RawMessage, error)

type LoggableModule_Expecter

+ func (_e *LoggableModule_Expecter) Output(ctx interface{}, res interface{}) *LoggableModule_Output_Call

+ type LoggableModule_Output_Call struct

+ func (_c *LoggableModule_Output_Call) Return(_a0 json.RawMessage, _a1 error) *LoggableModule_Output_Call

+ func (_c *LoggableModule_Output_Call) Run(run func(ctx context.Context, res module.ExpandedResource)) *LoggableModule_Output_Call

+ type ModuleDriver struct

+ func (_m *ModuleDriver) EXPECT() *ModuleDriver_Expecter

+ func (_m *ModuleDriver) Output(ctx context.Context, res module.ExpandedResource) (json.RawMessage, error)

+ func (_m *ModuleDriver) Plan(ctx context.Context, res module.ExpandedResource, act module.ActionRequest) (*module.Plan, error)

+ func (_m *ModuleDriver) Sync(ctx context.Context, res module.ExpandedResource) (*resource.State, error)

+ type ModuleDriver_Expecter struct

+ func (_e *ModuleDriver_Expecter) Output(ctx interface{}, res interface{}) *ModuleDriver_Output_Call

+ func (_e *ModuleDriver_Expecter) Plan(ctx interface{}, res interface{}, act interface{}) *ModuleDriver_Plan_Call

+ func (_e *ModuleDriver_Expecter) Sync(ctx interface{}, res interface{}) *ModuleDriver_Sync_Call

+ type ModuleDriver_Output_Call struct

+ func (_c *ModuleDriver_Output_Call) Return(_a0 json.RawMessage, _a1 error) *ModuleDriver_Output_Call

+ func (_c *ModuleDriver_Output_Call) Run(run func(ctx context.Context, res module.ExpandedResource)) *ModuleDriver_Output_Call

+ type ModuleDriver_Plan_Call struct

+ func (_c *ModuleDriver_Plan_Call) Return(_a0 *module.Plan, _a1 error) *ModuleDriver_Plan_Call

+ func (_c *ModuleDriver_Plan_Call) Run(...) *ModuleDriver_Plan_Call

+ type ModuleDriver_Sync_Call struct

+ func (_c *ModuleDriver_Sync_Call) Return(_a0 *resource.State, _a1 error) *ModuleDriver_Sync_Call

+ func (_c *ModuleDriver_Sync_Call) Run(run func(ctx context.Context, res module.ExpandedResource)) *ModuleDriver_Sync_Call

+ type ModuleRegistry struct

+ func (_m *ModuleRegistry) EXPECT() *ModuleRegistry_Expecter

+ func (_m *ModuleRegistry) GetDriver(ctx context.Context, mod module.Module) (module.Driver, module.Descriptor, error)

+ type ModuleRegistry_Expecter struct

+ func (_e *ModuleRegistry_Expecter) GetDriver(ctx interface{}, mod interface{}) *ModuleRegistry_GetDriver_Call

+ type ModuleRegistry_GetDriver_Call struct

+ func (_c *ModuleRegistry_GetDriver_Call) Return(_a0 module.Driver, _a1 module.Descriptor, _a2 error) *ModuleRegistry_GetDriver_Call

+ func (_c *ModuleRegistry_GetDriver_Call) Run(run func(ctx context.Context, mod module.Module)) *ModuleRegistry_GetDriver_Call

+ type ModuleService struct

+ func (_m *ModuleService) EXPECT() *ModuleService_Expecter

+ func (_m *ModuleService) GetOutput(ctx context.Context, res module.ExpandedResource) (json.RawMessage, error)

+ func (_m *ModuleService) PlanAction(ctx context.Context, res module.ExpandedResource, act module.ActionRequest) (*module.Plan, error)

+ func (_m *ModuleService) StreamLogs(ctx context.Context, res module.ExpandedResource, filter map[string]string) (<-chan module.LogChunk, error)

+ func (_m *ModuleService) SyncState(ctx context.Context, res module.ExpandedResource) (*resource.State, error)

+ type ModuleService_Expecter struct

+ func (_e *ModuleService_Expecter) GetOutput(ctx interface{}, res interface{}) *ModuleService_GetOutput_Call

+ func (_e *ModuleService_Expecter) PlanAction(ctx interface{}, res interface{}, act interface{}) *ModuleService_PlanAction_Call

+ func (_e *ModuleService_Expecter) StreamLogs(ctx interface{}, res interface{}, filter interface{}) *ModuleService_StreamLogs_Call

+ func (_e *ModuleService_Expecter) SyncState(ctx interface{}, res interface{}) *ModuleService_SyncState_Call

+ type ModuleService_GetOutput_Call struct

+ func (_c *ModuleService_GetOutput_Call) Return(_a0 json.RawMessage, _a1 error) *ModuleService_GetOutput_Call

+ func (_c *ModuleService_GetOutput_Call) Run(run func(ctx context.Context, res module.ExpandedResource)) *ModuleService_GetOutput_Call

+ type ModuleService_PlanAction_Call struct

+ func (_c *ModuleService_PlanAction_Call) Return(_a0 *module.Plan, _a1 error) *ModuleService_PlanAction_Call

+ func (_c *ModuleService_PlanAction_Call) Run(...) *ModuleService_PlanAction_Call

+ type ModuleService_StreamLogs_Call struct

+ func (_c *ModuleService_StreamLogs_Call) Return(_a0 <-chan module.LogChunk, _a1 error) *ModuleService_StreamLogs_Call

+ func (_c *ModuleService_StreamLogs_Call) Run(...) *ModuleService_StreamLogs_Call

+ type ModuleService_SyncState_Call struct

+ func (_c *ModuleService_SyncState_Call) Return(_a0 *resource.State, _a1 error) *ModuleService_SyncState_Call

+ func (_c *ModuleService_SyncState_Call) Run(run func(ctx context.Context, res module.ExpandedResource)) *ModuleService_SyncState_Call

+ type ModuleStore struct

+ func (_m *ModuleStore) CreateModule(ctx context.Context, m module.Module) error

+ func (_m *ModuleStore) DeleteModule(ctx context.Context, urn string) error

+ func (_m *ModuleStore) EXPECT() *ModuleStore_Expecter

+ func (_m *ModuleStore) GetModule(ctx context.Context, urn string) (*module.Module, error)

+ func (_m *ModuleStore) ListModules(ctx context.Context, project string) ([]module.Module, error)

+ func (_m *ModuleStore) UpdateModule(ctx context.Context, m module.Module) error

+ type ModuleStore_CreateModule_Call struct

+ func (_c *ModuleStore_CreateModule_Call) Return(_a0 error) *ModuleStore_CreateModule_Call

+ func (_c *ModuleStore_CreateModule_Call) Run(run func(ctx context.Context, m module.Module)) *ModuleStore_CreateModule_Call

+ type ModuleStore_DeleteModule_Call struct

+ func (_c *ModuleStore_DeleteModule_Call) Return(_a0 error) *ModuleStore_DeleteModule_Call

+ func (_c *ModuleStore_DeleteModule_Call) Run(run func(ctx context.Context, urn string)) *ModuleStore_DeleteModule_Call

+ type ModuleStore_Expecter struct

+ func (_e *ModuleStore_Expecter) CreateModule(ctx interface{}, m interface{}) *ModuleStore_CreateModule_Call

+ func (_e *ModuleStore_Expecter) DeleteModule(ctx interface{}, urn interface{}) *ModuleStore_DeleteModule_Call

+ func (_e *ModuleStore_Expecter) GetModule(ctx interface{}, urn interface{}) *ModuleStore_GetModule_Call

+ func (_e *ModuleStore_Expecter) ListModules(ctx interface{}, project interface{}) *ModuleStore_ListModules_Call

+ func (_e *ModuleStore_Expecter) UpdateModule(ctx interface{}, m interface{}) *ModuleStore_UpdateModule_Call

+ type ModuleStore_GetModule_Call struct

+ func (_c *ModuleStore_GetModule_Call) Return(_a0 *module.Module, _a1 error) *ModuleStore_GetModule_Call

+ func (_c *ModuleStore_GetModule_Call) Run(run func(ctx context.Context, urn string)) *ModuleStore_GetModule_Call

+ type ModuleStore_ListModules_Call struct

+ func (_c *ModuleStore_ListModules_Call) Return(_a0 []module.Module, _a1 error) *ModuleStore_ListModules_Call

+ func (_c *ModuleStore_ListModules_Call) Run(run func(ctx context.Context, project string)) *ModuleStore_ListModules_Call

+ type ModuleStore_UpdateModule_Call struct

+ func (_c *ModuleStore_UpdateModule_Call) Return(_a0 error) *ModuleStore_UpdateModule_Call

+ func (_c *ModuleStore_UpdateModule_Call) Run(run func(ctx context.Context, m module.Module)) *ModuleStore_UpdateModule_Call

v0.1.2

Jul 14, 2022

Changes in this version

type ResourceStore

+ func (_m *ResourceStore) Revisions(ctx context.Context, selector resource.RevisionsSelector) ([]resource.Revision, error)

type ResourceStore_Expecter

+ func (_e *ResourceStore_Expecter) Revisions(ctx interface{}, selector interface{}) *ResourceStore_Revisions_Call

+ type ResourceStore_Revisions_Call struct

+ func (_c *ResourceStore_Revisions_Call) Return(_a0 []resource.Revision, _a1 error) *ResourceStore_Revisions_Call

+ func (_c *ResourceStore_Revisions_Call) Run(run func(ctx context.Context, selector resource.RevisionsSelector)) *ResourceStore_Revisions_Call

v0.1.1

Jul 11, 2022

v0.1.0

Jul 8, 2022

Changes in this version

+ type AsyncWorker struct

+ func (_m *AsyncWorker) EXPECT() *AsyncWorker_Expecter

+ func (_m *AsyncWorker) Enqueue(ctx context.Context, jobs ...worker.Job) error

+ type AsyncWorker_Enqueue_Call struct

+ func (_c *AsyncWorker_Enqueue_Call) Return(_a0 error) *AsyncWorker_Enqueue_Call

+ func (_c *AsyncWorker_Enqueue_Call) Run(run func(ctx context.Context, jobs ...worker.Job)) *AsyncWorker_Enqueue_Call

+ type AsyncWorker_Expecter struct

+ func (_e *AsyncWorker_Expecter) Enqueue(ctx interface{}, jobs ...interface{}) *AsyncWorker_Enqueue_Call

+ type LoggableModule struct

+ func (_m *LoggableModule) EXPECT() *LoggableModule_Expecter

+ func (_m *LoggableModule) Log(ctx context.Context, spec module.Spec, filter map[string]string) (<-chan module.LogChunk, error)

+ func (_m *LoggableModule) Plan(ctx context.Context, spec module.Spec, act module.ActionRequest) (*resource.Resource, error)

+ func (_m *LoggableModule) Sync(ctx context.Context, spec module.Spec) (*resource.State, error)

+ type LoggableModule_Expecter struct

+ func (_e *LoggableModule_Expecter) Log(ctx interface{}, spec interface{}, filter interface{}) *LoggableModule_Log_Call

+ func (_e *LoggableModule_Expecter) Plan(ctx interface{}, spec interface{}, act interface{}) *LoggableModule_Plan_Call

+ func (_e *LoggableModule_Expecter) Sync(ctx interface{}, spec interface{}) *LoggableModule_Sync_Call

+ type LoggableModule_Log_Call struct

+ func (_c *LoggableModule_Log_Call) Return(_a0 <-chan module.LogChunk, _a1 error) *LoggableModule_Log_Call

+ func (_c *LoggableModule_Log_Call) Run(run func(ctx context.Context, spec module.Spec, filter map[string]string)) *LoggableModule_Log_Call

+ type LoggableModule_Plan_Call struct

+ func (_c *LoggableModule_Plan_Call) Return(_a0 *resource.Resource, _a1 error) *LoggableModule_Plan_Call

+ func (_c *LoggableModule_Plan_Call) Run(run func(ctx context.Context, spec module.Spec, act module.ActionRequest)) *LoggableModule_Plan_Call

+ type LoggableModule_Sync_Call struct

+ func (_c *LoggableModule_Sync_Call) Return(_a0 *resource.State, _a1 error) *LoggableModule_Sync_Call

+ func (_c *LoggableModule_Sync_Call) Run(run func(ctx context.Context, spec module.Spec)) *LoggableModule_Sync_Call

+ type Module struct

+ func (_m *Module) EXPECT() *Module_Expecter

+ func (_m *Module) Plan(ctx context.Context, spec module.Spec, act module.ActionRequest) (*resource.Resource, error)

+ func (_m *Module) Sync(ctx context.Context, spec module.Spec) (*resource.State, error)

+ type Module_Expecter struct

+ func (_e *Module_Expecter) Plan(ctx interface{}, spec interface{}, act interface{}) *Module_Plan_Call

+ func (_e *Module_Expecter) Sync(ctx interface{}, spec interface{}) *Module_Sync_Call

+ type Module_Plan_Call struct

+ func (_c *Module_Plan_Call) Return(_a0 *resource.Resource, _a1 error) *Module_Plan_Call

+ func (_c *Module_Plan_Call) Run(run func(ctx context.Context, spec module.Spec, act module.ActionRequest)) *Module_Plan_Call

+ type Module_Sync_Call struct

+ func (_c *Module_Sync_Call) Return(_a0 *resource.State, _a1 error) *Module_Sync_Call

+ func (_c *Module_Sync_Call) Run(run func(ctx context.Context, spec module.Spec)) *Module_Sync_Call

+ type ResourceStore struct

+ func (_m *ResourceStore) Create(ctx context.Context, r resource.Resource, hooks ...resource.MutationHook) error

+ func (_m *ResourceStore) Delete(ctx context.Context, urn string, hooks ...resource.MutationHook) error

+ func (_m *ResourceStore) EXPECT() *ResourceStore_Expecter

+ func (_m *ResourceStore) GetByURN(ctx context.Context, urn string) (*resource.Resource, error)

+ func (_m *ResourceStore) List(ctx context.Context, filter resource.Filter) ([]resource.Resource, error)

+ func (_m *ResourceStore) Update(ctx context.Context, r resource.Resource, hooks ...resource.MutationHook) error

+ type ResourceStore_Create_Call struct

+ func (_c *ResourceStore_Create_Call) Return(_a0 error) *ResourceStore_Create_Call

+ func (_c *ResourceStore_Create_Call) Run(...) *ResourceStore_Create_Call

+ type ResourceStore_Delete_Call struct

+ func (_c *ResourceStore_Delete_Call) Return(_a0 error) *ResourceStore_Delete_Call

+ func (_c *ResourceStore_Delete_Call) Run(run func(ctx context.Context, urn string, hooks ...resource.MutationHook)) *ResourceStore_Delete_Call

+ type ResourceStore_Expecter struct

+ func (_e *ResourceStore_Expecter) Create(ctx interface{}, r interface{}, hooks ...interface{}) *ResourceStore_Create_Call

+ func (_e *ResourceStore_Expecter) Delete(ctx interface{}, urn interface{}, hooks ...interface{}) *ResourceStore_Delete_Call

+ func (_e *ResourceStore_Expecter) GetByURN(ctx interface{}, urn interface{}) *ResourceStore_GetByURN_Call

+ func (_e *ResourceStore_Expecter) List(ctx interface{}, filter interface{}) *ResourceStore_List_Call

+ func (_e *ResourceStore_Expecter) Update(ctx interface{}, r interface{}, hooks ...interface{}) *ResourceStore_Update_Call

+ type ResourceStore_GetByURN_Call struct

+ func (_c *ResourceStore_GetByURN_Call) Return(_a0 *resource.Resource, _a1 error) *ResourceStore_GetByURN_Call

+ func (_c *ResourceStore_GetByURN_Call) Run(run func(ctx context.Context, urn string)) *ResourceStore_GetByURN_Call

+ type ResourceStore_List_Call struct

+ func (_c *ResourceStore_List_Call) Return(_a0 []resource.Resource, _a1 error) *ResourceStore_List_Call

+ func (_c *ResourceStore_List_Call) Run(run func(ctx context.Context, filter resource.Filter)) *ResourceStore_List_Call

+ type ResourceStore_Update_Call struct

+ func (_c *ResourceStore_Update_Call) Return(_a0 error) *ResourceStore_Update_Call

+ func (_c *ResourceStore_Update_Call) Run(...) *ResourceStore_Update_Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL