Versions in this module Expand all Collapse all v0 v0.2.0 Oct 31, 2023 v0.1.0 Oct 28, 2023 Changes in this version + type MockActionExecutorCreator struct + func NewMockActionExecutorCreator(t interface{ ... }) *MockActionExecutorCreator + func (_m *MockActionExecutorCreator) CreateExecutor(action *domain.HookAction, hookDef *domain.HookDefinition) (domain.EventHandler, error) + func (_m *MockActionExecutorCreator) EXPECT() *MockActionExecutorCreator_Expecter + type MockActionExecutorCreator_CreateExecutor_Call struct + func (_c *MockActionExecutorCreator_CreateExecutor_Call) Return(_a0 domain.EventHandler, _a1 error) *MockActionExecutorCreator_CreateExecutor_Call + func (_c *MockActionExecutorCreator_CreateExecutor_Call) Run(run func(action *domain.HookAction, hookDef *domain.HookDefinition)) *MockActionExecutorCreator_CreateExecutor_Call + func (_c *MockActionExecutorCreator_CreateExecutor_Call) RunAndReturn(...) *MockActionExecutorCreator_CreateExecutor_Call + type MockActionExecutorCreator_Expecter struct + func (_e *MockActionExecutorCreator_Expecter) CreateExecutor(action interface{}, hookDef interface{}) *MockActionExecutorCreator_CreateExecutor_Call + type MockEventHandler struct + func NewMockEventHandler(t interface{ ... }) *MockEventHandler + func (_m *MockEventHandler) Destroy() + func (_m *MockEventHandler) EXPECT() *MockEventHandler_Expecter + func (_m *MockEventHandler) GetNext() domain.EventHandler + func (_m *MockEventHandler) Handle(event *domain.Event) + func (_m *MockEventHandler) SetNext(next domain.EventHandler) + func (next *MockEventHandler) AssertNextHandlerCalled(t *testing.T, ev *domain.Event, number int) + func (next *MockEventHandler) AssertNextHandlerNotCalled(t *testing.T, ev *domain.Event) + type MockEventHandler_Destroy_Call struct + func (_c *MockEventHandler_Destroy_Call) Return() *MockEventHandler_Destroy_Call + func (_c *MockEventHandler_Destroy_Call) Run(run func()) *MockEventHandler_Destroy_Call + func (_c *MockEventHandler_Destroy_Call) RunAndReturn(run func()) *MockEventHandler_Destroy_Call + type MockEventHandler_Expecter struct + func (_e *MockEventHandler_Expecter) Destroy() *MockEventHandler_Destroy_Call + func (_e *MockEventHandler_Expecter) GetNext() *MockEventHandler_GetNext_Call + func (_e *MockEventHandler_Expecter) Handle(event interface{}) *MockEventHandler_Handle_Call + func (_e *MockEventHandler_Expecter) SetNext(next interface{}) *MockEventHandler_SetNext_Call + type MockEventHandler_GetNext_Call struct + func (_c *MockEventHandler_GetNext_Call) Return(_a0 domain.EventHandler) *MockEventHandler_GetNext_Call + func (_c *MockEventHandler_GetNext_Call) Run(run func()) *MockEventHandler_GetNext_Call + func (_c *MockEventHandler_GetNext_Call) RunAndReturn(run func() domain.EventHandler) *MockEventHandler_GetNext_Call + type MockEventHandler_Handle_Call struct + func (_c *MockEventHandler_Handle_Call) Return() *MockEventHandler_Handle_Call + func (_c *MockEventHandler_Handle_Call) Run(run func(event *domain.Event)) *MockEventHandler_Handle_Call + func (_c *MockEventHandler_Handle_Call) RunAndReturn(run func(*domain.Event)) *MockEventHandler_Handle_Call + type MockEventHandler_SetNext_Call struct + func (_c *MockEventHandler_SetNext_Call) Return() *MockEventHandler_SetNext_Call + func (_c *MockEventHandler_SetNext_Call) Run(run func(next domain.EventHandler)) *MockEventHandler_SetNext_Call + func (_c *MockEventHandler_SetNext_Call) RunAndReturn(run func(domain.EventHandler)) *MockEventHandler_SetNext_Call + type MockEventSource struct + func NewMockEventSource(t interface{ ... }) *MockEventSource + func (_m *MockEventSource) EXPECT() *MockEventSource_Expecter + func (_m *MockEventSource) Subscribe(eventType domain.EventType, params *domain.HookParameters, ...) (<-chan *domain.Event, error) + func (_m *MockEventSource) Unsubscribe(eventCh <-chan *domain.Event) + type MockEventSource_Expecter struct + func (_e *MockEventSource_Expecter) Subscribe(eventType interface{}, params interface{}, hookDef interface{}) *MockEventSource_Subscribe_Call + func (_e *MockEventSource_Expecter) Unsubscribe(eventCh interface{}) *MockEventSource_Unsubscribe_Call + type MockEventSource_Subscribe_Call struct + func (_c *MockEventSource_Subscribe_Call) Return(_a0 <-chan *domain.Event, _a1 error) *MockEventSource_Subscribe_Call + func (_c *MockEventSource_Subscribe_Call) Run(run func(eventType domain.EventType, params *domain.HookParameters, ...)) *MockEventSource_Subscribe_Call + func (_c *MockEventSource_Subscribe_Call) RunAndReturn(...) *MockEventSource_Subscribe_Call + type MockEventSource_Unsubscribe_Call struct + func (_c *MockEventSource_Unsubscribe_Call) Return() *MockEventSource_Unsubscribe_Call + func (_c *MockEventSource_Unsubscribe_Call) Run(run func(eventCh <-chan *domain.Event)) *MockEventSource_Unsubscribe_Call + func (_c *MockEventSource_Unsubscribe_Call) RunAndReturn(run func(<-chan *domain.Event)) *MockEventSource_Unsubscribe_Call + type MockHookManager struct + func NewMockHookManager(t interface{ ... }) *MockHookManager + func (_m *MockHookManager) EXPECT() *MockHookManager_Expecter + func (_m *MockHookManager) RegisterHook(hook *domain.Hook, hookDef *domain.HookDefinition) error + func (_m *MockHookManager) UnregisterAll() + type MockHookManager_Expecter struct + func (_e *MockHookManager_Expecter) RegisterHook(hook interface{}, hookDef interface{}) *MockHookManager_RegisterHook_Call + func (_e *MockHookManager_Expecter) UnregisterAll() *MockHookManager_UnregisterAll_Call + type MockHookManager_RegisterHook_Call struct + func (_c *MockHookManager_RegisterHook_Call) Return(_a0 error) *MockHookManager_RegisterHook_Call + func (_c *MockHookManager_RegisterHook_Call) Run(run func(hook *domain.Hook, hookDef *domain.HookDefinition)) *MockHookManager_RegisterHook_Call + func (_c *MockHookManager_RegisterHook_Call) RunAndReturn(run func(*domain.Hook, *domain.HookDefinition) error) *MockHookManager_RegisterHook_Call + type MockHookManager_UnregisterAll_Call struct + func (_c *MockHookManager_UnregisterAll_Call) Return() *MockHookManager_UnregisterAll_Call + func (_c *MockHookManager_UnregisterAll_Call) Run(run func()) *MockHookManager_UnregisterAll_Call + func (_c *MockHookManager_UnregisterAll_Call) RunAndReturn(run func()) *MockHookManager_UnregisterAll_Call + type MockSyncthingClient struct + func NewMockSyncthingClient(t interface{ ... }) *MockSyncthingClient + func (_m *MockSyncthingClient) EXPECT() *MockSyncthingClient_Expecter + func (_m *MockSyncthingClient) GetDiskEvents(since int, timeout int, limit int) ([]events.Event, error) + func (_m *MockSyncthingClient) GetEvents(eventTypes []events.EventType, since int, timeout int, limit int) ([]events.Event, error) + func (_m *MockSyncthingClient) GetSystemStatus() (*domain.SystemStatus, error) + func (_m *MockSyncthingClient) SubscribeEvent(eventTypes []events.EventType, since int) <-chan events.Event + func (_m *MockSyncthingClient) UnsubscribeEvent(eventCh <-chan events.Event) + type MockSyncthingClient_Expecter struct + func (_e *MockSyncthingClient_Expecter) GetDiskEvents(since interface{}, timeout interface{}, limit interface{}) *MockSyncthingClient_GetDiskEvents_Call + func (_e *MockSyncthingClient_Expecter) GetEvents(eventTypes interface{}, since interface{}, timeout interface{}, ...) *MockSyncthingClient_GetEvents_Call + func (_e *MockSyncthingClient_Expecter) GetSystemStatus() *MockSyncthingClient_GetSystemStatus_Call + func (_e *MockSyncthingClient_Expecter) SubscribeEvent(eventTypes interface{}, since interface{}) *MockSyncthingClient_SubscribeEvent_Call + func (_e *MockSyncthingClient_Expecter) UnsubscribeEvent(eventCh interface{}) *MockSyncthingClient_UnsubscribeEvent_Call + type MockSyncthingClient_GetDiskEvents_Call struct + func (_c *MockSyncthingClient_GetDiskEvents_Call) Return(_a0 []events.Event, _a1 error) *MockSyncthingClient_GetDiskEvents_Call + func (_c *MockSyncthingClient_GetDiskEvents_Call) Run(run func(since int, timeout int, limit int)) *MockSyncthingClient_GetDiskEvents_Call + func (_c *MockSyncthingClient_GetDiskEvents_Call) RunAndReturn(run func(int, int, int) ([]events.Event, error)) *MockSyncthingClient_GetDiskEvents_Call + type MockSyncthingClient_GetEvents_Call struct + func (_c *MockSyncthingClient_GetEvents_Call) Return(_a0 []events.Event, _a1 error) *MockSyncthingClient_GetEvents_Call + func (_c *MockSyncthingClient_GetEvents_Call) Run(run func(eventTypes []events.EventType, since int, timeout int, limit int)) *MockSyncthingClient_GetEvents_Call + func (_c *MockSyncthingClient_GetEvents_Call) RunAndReturn(run func([]events.EventType, int, int, int) ([]events.Event, error)) *MockSyncthingClient_GetEvents_Call + type MockSyncthingClient_GetSystemStatus_Call struct + func (_c *MockSyncthingClient_GetSystemStatus_Call) Return(_a0 *domain.SystemStatus, _a1 error) *MockSyncthingClient_GetSystemStatus_Call + func (_c *MockSyncthingClient_GetSystemStatus_Call) Run(run func()) *MockSyncthingClient_GetSystemStatus_Call + func (_c *MockSyncthingClient_GetSystemStatus_Call) RunAndReturn(run func() (*domain.SystemStatus, error)) *MockSyncthingClient_GetSystemStatus_Call + type MockSyncthingClient_SubscribeEvent_Call struct + func (_c *MockSyncthingClient_SubscribeEvent_Call) Return(_a0 <-chan events.Event) *MockSyncthingClient_SubscribeEvent_Call + func (_c *MockSyncthingClient_SubscribeEvent_Call) Run(run func(eventTypes []events.EventType, since int)) *MockSyncthingClient_SubscribeEvent_Call + func (_c *MockSyncthingClient_SubscribeEvent_Call) RunAndReturn(run func([]events.EventType, int) <-chan events.Event) *MockSyncthingClient_SubscribeEvent_Call + type MockSyncthingClient_UnsubscribeEvent_Call struct + func (_c *MockSyncthingClient_UnsubscribeEvent_Call) Return() *MockSyncthingClient_UnsubscribeEvent_Call + func (_c *MockSyncthingClient_UnsubscribeEvent_Call) Run(run func(eventCh <-chan events.Event)) *MockSyncthingClient_UnsubscribeEvent_Call + func (_c *MockSyncthingClient_UnsubscribeEvent_Call) RunAndReturn(run func(<-chan events.Event)) *MockSyncthingClient_UnsubscribeEvent_Call + type MockTimeProvider struct + func NewMockTimeProvider(t interface{ ... }) *MockTimeProvider + func (_m *MockTimeProvider) EXPECT() *MockTimeProvider_Expecter + func (_m *MockTimeProvider) NowUnixMilli() int64 + type MockTimeProvider_Expecter struct + func (_e *MockTimeProvider_Expecter) NowUnixMilli() *MockTimeProvider_NowUnixMilli_Call + type MockTimeProvider_NowUnixMilli_Call struct + func (_c *MockTimeProvider_NowUnixMilli_Call) Return(_a0 int64) *MockTimeProvider_NowUnixMilli_Call + func (_c *MockTimeProvider_NowUnixMilli_Call) Run(run func()) *MockTimeProvider_NowUnixMilli_Call + func (_c *MockTimeProvider_NowUnixMilli_Call) RunAndReturn(run func() int64) *MockTimeProvider_NowUnixMilli_Call
Go to main page