mocks

Jun 3, 2024

Changes in this version

+ type AlertRepository struct

+ func NewAlertRepository(t interface{ ... }) *AlertRepository

+ func (_m *AlertRepository) BulkUpdateSilence(_a0 context.Context, _a1 []int64, _a2 string) error

+ func (_m *AlertRepository) EXPECT() *AlertRepository_Expecter

+ type AlertRepository_BulkUpdateSilence_Call struct

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

+ func (_c *AlertRepository_BulkUpdateSilence_Call) Run(run func(_a0 context.Context, _a1 []int64, _a2 string)) *AlertRepository_BulkUpdateSilence_Call

+ func (_c *AlertRepository_BulkUpdateSilence_Call) RunAndReturn(run func(context.Context, []int64, string) error) *AlertRepository_BulkUpdateSilence_Call

+ type AlertRepository_Expecter struct

+ func (_e *AlertRepository_Expecter) BulkUpdateSilence(_a0 interface{}, _a1 interface{}, _a2 interface{}) *AlertRepository_BulkUpdateSilence_Call

type Dispatcher

+ func (_m *Dispatcher) Dispatch(ctx context.Context, ns []notification.Notification) ([]string, error)

+ type Dispatcher_Dispatch_Call struct

+ func (_c *Dispatcher_Dispatch_Call) Return(_a0 []string, _a1 error) *Dispatcher_Dispatch_Call

+ func (_c *Dispatcher_Dispatch_Call) Run(run func(ctx context.Context, ns []notification.Notification)) *Dispatcher_Dispatch_Call

+ func (_c *Dispatcher_Dispatch_Call) RunAndReturn(run func(context.Context, []notification.Notification) ([]string, error)) *Dispatcher_Dispatch_Call

type Dispatcher_Expecter

+ func (_e *Dispatcher_Expecter) Dispatch(ctx interface{}, ns interface{}) *Dispatcher_Dispatch_Call

type Repository

+ func (_m *Repository) BulkCreate(_a0 context.Context, _a1 []notification.Notification) ([]notification.Notification, error)

+ type Repository_BulkCreate_Call struct

+ func (_c *Repository_BulkCreate_Call) Return(_a0 []notification.Notification, _a1 error) *Repository_BulkCreate_Call

+ func (_c *Repository_BulkCreate_Call) Run(run func(_a0 context.Context, _a1 []notification.Notification)) *Repository_BulkCreate_Call

+ func (_c *Repository_BulkCreate_Call) RunAndReturn(...) *Repository_BulkCreate_Call

type Repository_Expecter

+ func (_e *Repository_Expecter) BulkCreate(_a0 interface{}, _a1 interface{}) *Repository_BulkCreate_Call

+ type Router struct

+ func NewRouter(t interface{ ... }) *Router

+ func (_m *Router) EXPECT() *Router_Expecter

+ func (_m *Router) PrepareMessage(ctx context.Context, n notification.Notification) ([]notification.Message, []log.Notification, bool, error)

+ func (_m *Router) PrepareMessageV2(ctx context.Context, n notification.Notification) ([]notification.Message, []log.Notification, bool, error)

+ func (_m *Router) PrepareMetaMessages(ctx context.Context, n notification.Notification) ([]notification.MetaMessage, []log.Notification, error)

+ type Router_Expecter struct

+ func (_e *Router_Expecter) PrepareMessage(ctx interface{}, n interface{}) *Router_PrepareMessage_Call

+ func (_e *Router_Expecter) PrepareMessageV2(ctx interface{}, n interface{}) *Router_PrepareMessageV2_Call

+ func (_e *Router_Expecter) PrepareMetaMessages(ctx interface{}, n interface{}) *Router_PrepareMetaMessages_Call

+ type Router_PrepareMessageV2_Call struct

+ func (_c *Router_PrepareMessageV2_Call) Return(_a0 []notification.Message, _a1 []log.Notification, _a2 bool, _a3 error) *Router_PrepareMessageV2_Call

+ func (_c *Router_PrepareMessageV2_Call) Run(run func(ctx context.Context, n notification.Notification)) *Router_PrepareMessageV2_Call

+ func (_c *Router_PrepareMessageV2_Call) RunAndReturn(...) *Router_PrepareMessageV2_Call

+ type Router_PrepareMessage_Call struct

+ func (_c *Router_PrepareMessage_Call) Return(_a0 []notification.Message, _a1 []log.Notification, _a2 bool, _a3 error) *Router_PrepareMessage_Call

+ func (_c *Router_PrepareMessage_Call) Run(run func(ctx context.Context, n notification.Notification)) *Router_PrepareMessage_Call

+ func (_c *Router_PrepareMessage_Call) RunAndReturn(...) *Router_PrepareMessage_Call

+ type Router_PrepareMetaMessages_Call struct

+ func (_c *Router_PrepareMetaMessages_Call) Return(metaMessages []notification.MetaMessage, notificationLogs []log.Notification, ...) *Router_PrepareMetaMessages_Call

+ func (_c *Router_PrepareMetaMessages_Call) Run(run func(ctx context.Context, n notification.Notification)) *Router_PrepareMetaMessages_Call

+ func (_c *Router_PrepareMetaMessages_Call) RunAndReturn(...) *Router_PrepareMetaMessages_Call

May 20, 2024

Changes in this version

type Dispatcher

+ func (_m *Dispatcher) PrepareMessageV2(ctx context.Context, n notification.Notification) ([]notification.Message, []log.Notification, bool, error)

type Dispatcher_Expecter

+ func (_e *Dispatcher_Expecter) PrepareMessageV2(ctx interface{}, n interface{}) *Dispatcher_PrepareMessageV2_Call

+ type Dispatcher_PrepareMessageV2_Call struct

+ func (_c *Dispatcher_PrepareMessageV2_Call) Return(_a0 []notification.Message, _a1 []log.Notification, _a2 bool, _a3 error) *Dispatcher_PrepareMessageV2_Call

+ func (_c *Dispatcher_PrepareMessageV2_Call) Run(run func(ctx context.Context, n notification.Notification)) *Dispatcher_PrepareMessageV2_Call

+ func (_c *Dispatcher_PrepareMessageV2_Call) RunAndReturn(...) *Dispatcher_PrepareMessageV2_Call

type SubscriptionService

+ func (_m *SubscriptionService) MatchByLabelsV2(ctx context.Context, namespaceID uint64, labels map[string]string) ([]subscription.ReceiverView, error)

type SubscriptionService_Expecter

+ func (_e *SubscriptionService_Expecter) MatchByLabelsV2(ctx interface{}, namespaceID interface{}, labels interface{}) *SubscriptionService_MatchByLabelsV2_Call

+ type SubscriptionService_MatchByLabelsV2_Call struct

+ func (_c *SubscriptionService_MatchByLabelsV2_Call) Return(_a0 []subscription.ReceiverView, _a1 error) *SubscriptionService_MatchByLabelsV2_Call

+ func (_c *SubscriptionService_MatchByLabelsV2_Call) Run(run func(ctx context.Context, namespaceID uint64, labels map[string]string)) *SubscriptionService_MatchByLabelsV2_Call

+ func (_c *SubscriptionService_MatchByLabelsV2_Call) RunAndReturn(...) *SubscriptionService_MatchByLabelsV2_Call

Apr 3, 2024

Changes in this version

type Repository

+ func (_m *Repository) List(_a0 context.Context, _a1 notification.Filter) ([]notification.Notification, error)

type Repository_Expecter

+ func (_e *Repository_Expecter) List(_a0 interface{}, _a1 interface{}) *Repository_List_Call

+ type Repository_List_Call struct

+ func (_c *Repository_List_Call) Return(_a0 []notification.Notification, _a1 error) *Repository_List_Call

+ func (_c *Repository_List_Call) Run(run func(_a0 context.Context, _a1 notification.Filter)) *Repository_List_Call

+ func (_c *Repository_List_Call) RunAndReturn(...) *Repository_List_Call

Mar 28, 2024

Changes in this version

type Queuer

+ func (_m *Queuer) ListMessages(ctx context.Context, notificationID string) ([]notification.Message, error)

type Queuer_Expecter

+ func (_e *Queuer_Expecter) ListMessages(ctx interface{}, notificationID interface{}) *Queuer_ListMessages_Call

+ type Queuer_ListMessages_Call struct

+ func (_c *Queuer_ListMessages_Call) Return(_a0 []notification.Message, _a1 error) *Queuer_ListMessages_Call

+ func (_c *Queuer_ListMessages_Call) Run(run func(ctx context.Context, notificationID string)) *Queuer_ListMessages_Call

+ func (_c *Queuer_ListMessages_Call) RunAndReturn(run func(context.Context, string) ([]notification.Message, error)) *Queuer_ListMessages_Call

Mar 22, 2024

Changes in this version

+ type TemplateService struct

+ func NewTemplateService(t interface{ ... }) *TemplateService

+ func (_m *TemplateService) EXPECT() *TemplateService_Expecter

+ func (_m *TemplateService) GetByName(ctx context.Context, name string) (*template.Template, error)

+ type TemplateService_Expecter struct

+ func (_e *TemplateService_Expecter) GetByName(ctx interface{}, name interface{}) *TemplateService_GetByName_Call

+ type TemplateService_GetByName_Call struct

+ func (_c *TemplateService_GetByName_Call) Return(_a0 *template.Template, _a1 error) *TemplateService_GetByName_Call

+ func (_c *TemplateService_GetByName_Call) Run(run func(ctx context.Context, name string)) *TemplateService_GetByName_Call

+ func (_c *TemplateService_GetByName_Call) RunAndReturn(run func(context.Context, string) (*template.Template, error)) *TemplateService_GetByName_Call

Mar 15, 2024

Changes in this version

type IdempotencyRepository

+ func (_m *IdempotencyRepository) Check(ctx context.Context, scope string, key string) (*notification.Idempotency, error)

+ func (_m *IdempotencyRepository) Create(ctx context.Context, scope string, key string, notificationID string) (*notification.Idempotency, error)

+ type IdempotencyRepository_Check_Call struct

+ func (_c *IdempotencyRepository_Check_Call) Return(_a0 *notification.Idempotency, _a1 error) *IdempotencyRepository_Check_Call

+ func (_c *IdempotencyRepository_Check_Call) Run(run func(ctx context.Context, scope string, key string)) *IdempotencyRepository_Check_Call

+ func (_c *IdempotencyRepository_Check_Call) RunAndReturn(run func(context.Context, string, string) (*notification.Idempotency, error)) *IdempotencyRepository_Check_Call

+ type IdempotencyRepository_Create_Call struct

+ func (_c *IdempotencyRepository_Create_Call) Return(_a0 *notification.Idempotency, _a1 error) *IdempotencyRepository_Create_Call

+ func (_c *IdempotencyRepository_Create_Call) Run(run func(ctx context.Context, scope string, key string, notificationID string)) *IdempotencyRepository_Create_Call

+ func (_c *IdempotencyRepository_Create_Call) RunAndReturn(...) *IdempotencyRepository_Create_Call

type IdempotencyRepository_Expecter

+ func (_e *IdempotencyRepository_Expecter) Check(ctx interface{}, scope interface{}, key interface{}) *IdempotencyRepository_Check_Call

+ func (_e *IdempotencyRepository_Expecter) Create(ctx interface{}, scope interface{}, key interface{}, ...) *IdempotencyRepository_Create_Call

type ReceiverService

+ func (_m *ReceiverService) List(ctx context.Context, flt receiver.Filter) ([]receiver.Receiver, error)

type ReceiverService_Expecter

+ func (_e *ReceiverService_Expecter) List(ctx interface{}, flt interface{}) *ReceiverService_List_Call

+ type ReceiverService_List_Call struct

+ func (_c *ReceiverService_List_Call) Return(_a0 []receiver.Receiver, _a1 error) *ReceiverService_List_Call

+ func (_c *ReceiverService_List_Call) Run(run func(ctx context.Context, flt receiver.Filter)) *ReceiverService_List_Call

+ func (_c *ReceiverService_List_Call) RunAndReturn(run func(context.Context, receiver.Filter) ([]receiver.Receiver, error)) *ReceiverService_List_Call

type Repository

+ func (_m *Repository) Commit(ctx context.Context) error

+ func (_m *Repository) Rollback(ctx context.Context, err error) error

+ func (_m *Repository) WithTransaction(ctx context.Context) context.Context

+ type Repository_Commit_Call struct

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

+ func (_c *Repository_Commit_Call) Run(run func(ctx context.Context)) *Repository_Commit_Call

+ func (_c *Repository_Commit_Call) RunAndReturn(run func(context.Context) error) *Repository_Commit_Call

type Repository_Expecter

+ func (_e *Repository_Expecter) Commit(ctx interface{}) *Repository_Commit_Call

+ func (_e *Repository_Expecter) Rollback(ctx interface{}, err interface{}) *Repository_Rollback_Call

+ func (_e *Repository_Expecter) WithTransaction(ctx interface{}) *Repository_WithTransaction_Call

+ type Repository_Rollback_Call struct

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

+ func (_c *Repository_Rollback_Call) Run(run func(ctx context.Context, err error)) *Repository_Rollback_Call

+ func (_c *Repository_Rollback_Call) RunAndReturn(run func(context.Context, error) error) *Repository_Rollback_Call

+ type Repository_WithTransaction_Call struct

+ func (_c *Repository_WithTransaction_Call) Return(_a0 context.Context) *Repository_WithTransaction_Call

+ func (_c *Repository_WithTransaction_Call) Run(run func(ctx context.Context)) *Repository_WithTransaction_Call

+ func (_c *Repository_WithTransaction_Call) RunAndReturn(run func(context.Context) context.Context) *Repository_WithTransaction_Call

Mar 15, 2023

Changes in this version

type AlertService_UpdateSilenceStatus_Call

+ func (_c *AlertService_UpdateSilenceStatus_Call) RunAndReturn(run func(context.Context, []int64, bool, bool) error) *AlertService_UpdateSilenceStatus_Call

type Dispatcher_PrepareMessage_Call

+ func (_c *Dispatcher_PrepareMessage_Call) RunAndReturn(...) *Dispatcher_PrepareMessage_Call

type IdempotencyRepository_Delete_Call

+ func (_c *IdempotencyRepository_Delete_Call) RunAndReturn(run func(context.Context, notification.IdempotencyFilter) error) *IdempotencyRepository_Delete_Call

type IdempotencyRepository_InsertOnConflictReturning_Call

+ func (_c *IdempotencyRepository_InsertOnConflictReturning_Call) RunAndReturn(run func(context.Context, string, string) (*notification.Idempotency, error)) *IdempotencyRepository_InsertOnConflictReturning_Call

type IdempotencyRepository_UpdateSuccess_Call

+ func (_c *IdempotencyRepository_UpdateSuccess_Call) RunAndReturn(run func(context.Context, uint64, bool) error) *IdempotencyRepository_UpdateSuccess_Call

type LogService_LogNotifications_Call

+ func (_c *LogService_LogNotifications_Call) RunAndReturn(run func(context.Context, ...log.Notification) error) *LogService_LogNotifications_Call

type Notifier_GetSystemDefaultTemplate_Call

+ func (_c *Notifier_GetSystemDefaultTemplate_Call) RunAndReturn(run func() string) *Notifier_GetSystemDefaultTemplate_Call

type Notifier_PostHookQueueTransformConfigs_Call

+ func (_c *Notifier_PostHookQueueTransformConfigs_Call) RunAndReturn(...) *Notifier_PostHookQueueTransformConfigs_Call

type Notifier_PreHookQueueTransformConfigs_Call

+ func (_c *Notifier_PreHookQueueTransformConfigs_Call) RunAndReturn(...) *Notifier_PreHookQueueTransformConfigs_Call

type Notifier_Send_Call

+ func (_c *Notifier_Send_Call) RunAndReturn(run func(context.Context, notification.Message) (bool, error)) *Notifier_Send_Call

type Queuer_Cleanup_Call

+ func (_c *Queuer_Cleanup_Call) RunAndReturn(run func(context.Context, queues.FilterCleanup) error) *Queuer_Cleanup_Call

type Queuer_Dequeue_Call

+ func (_c *Queuer_Dequeue_Call) RunAndReturn(run func(context.Context, []string, int, ...) error) *Queuer_Dequeue_Call

type Queuer_Enqueue_Call

+ func (_c *Queuer_Enqueue_Call) RunAndReturn(run func(context.Context, ...notification.Message) error) *Queuer_Enqueue_Call

type Queuer_ErrorCallback_Call

+ func (_c *Queuer_ErrorCallback_Call) RunAndReturn(run func(context.Context, notification.Message) error) *Queuer_ErrorCallback_Call

type Queuer_Stop_Call

+ func (_c *Queuer_Stop_Call) RunAndReturn(run func(context.Context) error) *Queuer_Stop_Call

type Queuer_SuccessCallback_Call

+ func (_c *Queuer_SuccessCallback_Call) RunAndReturn(run func(context.Context, notification.Message) error) *Queuer_SuccessCallback_Call

type Queuer_Type_Call

+ func (_c *Queuer_Type_Call) RunAndReturn(run func() string) *Queuer_Type_Call

type ReceiverService_Get_Call

+ func (_c *ReceiverService_Get_Call) RunAndReturn(...) *ReceiverService_Get_Call

type Repository_Create_Call

+ func (_c *Repository_Create_Call) RunAndReturn(...) *Repository_Create_Call

type SilenceService_List_Call

+ func (_c *SilenceService_List_Call) RunAndReturn(run func(context.Context, silence.Filter) ([]silence.Silence, error)) *SilenceService_List_Call

type SubscriptionService_MatchByLabels_Call

+ func (_c *SubscriptionService_MatchByLabels_Call) RunAndReturn(...) *SubscriptionService_MatchByLabels_Call

Mar 15, 2023

Changes in this version

+ type AlertService struct

+ func NewAlertService(t mockConstructorTestingTNewAlertService) *AlertService

+ func (_m *AlertService) EXPECT() *AlertService_Expecter

+ func (_m *AlertService) UpdateSilenceStatus(ctx context.Context, alertIDs []int64, hasSilenced bool, hasNonSilenced bool) error

+ type AlertService_Expecter struct

+ func (_e *AlertService_Expecter) UpdateSilenceStatus(ctx interface{}, alertIDs interface{}, hasSilenced interface{}, ...) *AlertService_UpdateSilenceStatus_Call

+ type AlertService_UpdateSilenceStatus_Call struct

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

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

+ type Dispatcher struct

+ func NewDispatcher(t mockConstructorTestingTNewDispatcher) *Dispatcher

+ func (_m *Dispatcher) EXPECT() *Dispatcher_Expecter

+ func (_m *Dispatcher) PrepareMessage(ctx context.Context, n notification.Notification) ([]notification.Message, []log.Notification, bool, error)

+ type Dispatcher_Expecter struct

+ func (_e *Dispatcher_Expecter) PrepareMessage(ctx interface{}, n interface{}) *Dispatcher_PrepareMessage_Call

+ type Dispatcher_PrepareMessage_Call struct

+ func (_c *Dispatcher_PrepareMessage_Call) Return(_a0 []notification.Message, _a1 []log.Notification, _a2 bool, _a3 error) *Dispatcher_PrepareMessage_Call

+ func (_c *Dispatcher_PrepareMessage_Call) Run(run func(ctx context.Context, n notification.Notification)) *Dispatcher_PrepareMessage_Call

+ type IdempotencyRepository struct

+ func NewIdempotencyRepository(t mockConstructorTestingTNewIdempotencyRepository) *IdempotencyRepository

+ func (_m *IdempotencyRepository) Delete(_a0 context.Context, _a1 notification.IdempotencyFilter) error

+ func (_m *IdempotencyRepository) EXPECT() *IdempotencyRepository_Expecter

+ func (_m *IdempotencyRepository) InsertOnConflictReturning(_a0 context.Context, _a1 string, _a2 string) (*notification.Idempotency, error)

+ func (_m *IdempotencyRepository) UpdateSuccess(_a0 context.Context, _a1 uint64, _a2 bool) error

+ type IdempotencyRepository_Delete_Call struct

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

+ func (_c *IdempotencyRepository_Delete_Call) Run(run func(_a0 context.Context, _a1 notification.IdempotencyFilter)) *IdempotencyRepository_Delete_Call

+ type IdempotencyRepository_Expecter struct

+ func (_e *IdempotencyRepository_Expecter) Delete(_a0 interface{}, _a1 interface{}) *IdempotencyRepository_Delete_Call

+ func (_e *IdempotencyRepository_Expecter) InsertOnConflictReturning(_a0 interface{}, _a1 interface{}, _a2 interface{}) *IdempotencyRepository_InsertOnConflictReturning_Call

+ func (_e *IdempotencyRepository_Expecter) UpdateSuccess(_a0 interface{}, _a1 interface{}, _a2 interface{}) *IdempotencyRepository_UpdateSuccess_Call

+ type IdempotencyRepository_InsertOnConflictReturning_Call struct

+ func (_c *IdempotencyRepository_InsertOnConflictReturning_Call) Return(_a0 *notification.Idempotency, _a1 error) *IdempotencyRepository_InsertOnConflictReturning_Call

+ func (_c *IdempotencyRepository_InsertOnConflictReturning_Call) Run(run func(_a0 context.Context, _a1 string, _a2 string)) *IdempotencyRepository_InsertOnConflictReturning_Call

+ type IdempotencyRepository_UpdateSuccess_Call struct

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

+ func (_c *IdempotencyRepository_UpdateSuccess_Call) Run(run func(_a0 context.Context, _a1 uint64, _a2 bool)) *IdempotencyRepository_UpdateSuccess_Call

+ type LogService struct

+ func NewLogService(t mockConstructorTestingTNewLogService) *LogService

+ func (_m *LogService) EXPECT() *LogService_Expecter

+ func (_m *LogService) LogNotifications(ctx context.Context, nlogs ...log.Notification) error

+ type LogService_Expecter struct

+ func (_e *LogService_Expecter) LogNotifications(ctx interface{}, nlogs ...interface{}) *LogService_LogNotifications_Call

+ type LogService_LogNotifications_Call struct

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

+ func (_c *LogService_LogNotifications_Call) Run(run func(ctx context.Context, nlogs ...log.Notification)) *LogService_LogNotifications_Call

+ type Notifier struct

+ func NewNotifier(t mockConstructorTestingTNewNotifier) *Notifier

+ func (_m *Notifier) EXPECT() *Notifier_Expecter

+ func (_m *Notifier) GetSystemDefaultTemplate() string

+ func (_m *Notifier) PostHookQueueTransformConfigs(ctx context.Context, notificationConfigMap map[string]interface{}) (map[string]interface{}, error)

+ func (_m *Notifier) PreHookQueueTransformConfigs(ctx context.Context, notificationConfigMap map[string]interface{}) (map[string]interface{}, error)

+ func (_m *Notifier) Send(ctx context.Context, message notification.Message) (bool, error)

+ type Notifier_Expecter struct

+ func (_e *Notifier_Expecter) GetSystemDefaultTemplate() *Notifier_GetSystemDefaultTemplate_Call

+ func (_e *Notifier_Expecter) PostHookQueueTransformConfigs(ctx interface{}, notificationConfigMap interface{}) *Notifier_PostHookQueueTransformConfigs_Call

+ func (_e *Notifier_Expecter) PreHookQueueTransformConfigs(ctx interface{}, notificationConfigMap interface{}) *Notifier_PreHookQueueTransformConfigs_Call

+ func (_e *Notifier_Expecter) Send(ctx interface{}, message interface{}) *Notifier_Send_Call

+ type Notifier_GetSystemDefaultTemplate_Call struct

+ func (_c *Notifier_GetSystemDefaultTemplate_Call) Return(_a0 string) *Notifier_GetSystemDefaultTemplate_Call

+ func (_c *Notifier_GetSystemDefaultTemplate_Call) Run(run func()) *Notifier_GetSystemDefaultTemplate_Call

+ type Notifier_PostHookQueueTransformConfigs_Call struct

+ func (_c *Notifier_PostHookQueueTransformConfigs_Call) Return(_a0 map[string]interface{}, _a1 error) *Notifier_PostHookQueueTransformConfigs_Call

+ func (_c *Notifier_PostHookQueueTransformConfigs_Call) Run(run func(ctx context.Context, notificationConfigMap map[string]interface{})) *Notifier_PostHookQueueTransformConfigs_Call

+ type Notifier_PreHookQueueTransformConfigs_Call struct

+ func (_c *Notifier_PreHookQueueTransformConfigs_Call) Return(_a0 map[string]interface{}, _a1 error) *Notifier_PreHookQueueTransformConfigs_Call

+ func (_c *Notifier_PreHookQueueTransformConfigs_Call) Run(run func(ctx context.Context, notificationConfigMap map[string]interface{})) *Notifier_PreHookQueueTransformConfigs_Call

+ type Notifier_Send_Call struct

+ func (_c *Notifier_Send_Call) Return(_a0 bool, _a1 error) *Notifier_Send_Call

+ func (_c *Notifier_Send_Call) Run(run func(ctx context.Context, message notification.Message)) *Notifier_Send_Call

+ type Queuer struct

+ func NewQueuer(t mockConstructorTestingTNewQueuer) *Queuer

+ func (_m *Queuer) Cleanup(ctx context.Context, filter queues.FilterCleanup) error

+ func (_m *Queuer) Dequeue(ctx context.Context, receiverTypes []string, batchSize int, ...) error

+ func (_m *Queuer) EXPECT() *Queuer_Expecter

+ func (_m *Queuer) Enqueue(ctx context.Context, ms ...notification.Message) error

+ func (_m *Queuer) ErrorCallback(ctx context.Context, ms notification.Message) error

+ func (_m *Queuer) Stop(ctx context.Context) error

+ func (_m *Queuer) SuccessCallback(ctx context.Context, ms notification.Message) error

+ func (_m *Queuer) Type() string

+ type Queuer_Cleanup_Call struct

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

+ func (_c *Queuer_Cleanup_Call) Run(run func(ctx context.Context, filter queues.FilterCleanup)) *Queuer_Cleanup_Call

+ type Queuer_Dequeue_Call struct

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

+ func (_c *Queuer_Dequeue_Call) Run(run func(ctx context.Context, receiverTypes []string, batchSize int, ...)) *Queuer_Dequeue_Call

+ type Queuer_Enqueue_Call struct

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

+ func (_c *Queuer_Enqueue_Call) Run(run func(ctx context.Context, ms ...notification.Message)) *Queuer_Enqueue_Call

+ type Queuer_ErrorCallback_Call struct

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

+ func (_c *Queuer_ErrorCallback_Call) Run(run func(ctx context.Context, ms notification.Message)) *Queuer_ErrorCallback_Call

+ type Queuer_Expecter struct

+ func (_e *Queuer_Expecter) Cleanup(ctx interface{}, filter interface{}) *Queuer_Cleanup_Call

+ func (_e *Queuer_Expecter) Dequeue(ctx interface{}, receiverTypes interface{}, batchSize interface{}, ...) *Queuer_Dequeue_Call

+ func (_e *Queuer_Expecter) Enqueue(ctx interface{}, ms ...interface{}) *Queuer_Enqueue_Call

+ func (_e *Queuer_Expecter) ErrorCallback(ctx interface{}, ms interface{}) *Queuer_ErrorCallback_Call

+ func (_e *Queuer_Expecter) Stop(ctx interface{}) *Queuer_Stop_Call

+ func (_e *Queuer_Expecter) SuccessCallback(ctx interface{}, ms interface{}) *Queuer_SuccessCallback_Call

+ func (_e *Queuer_Expecter) Type() *Queuer_Type_Call

+ type Queuer_Stop_Call struct

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

+ func (_c *Queuer_Stop_Call) Run(run func(ctx context.Context)) *Queuer_Stop_Call

+ type Queuer_SuccessCallback_Call struct

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

+ func (_c *Queuer_SuccessCallback_Call) Run(run func(ctx context.Context, ms notification.Message)) *Queuer_SuccessCallback_Call

+ type Queuer_Type_Call struct

+ func (_c *Queuer_Type_Call) Return(_a0 string) *Queuer_Type_Call

+ func (_c *Queuer_Type_Call) Run(run func()) *Queuer_Type_Call

+ type ReceiverService struct

+ func NewReceiverService(t mockConstructorTestingTNewReceiverService) *ReceiverService

+ func (_m *ReceiverService) EXPECT() *ReceiverService_Expecter

+ func (_m *ReceiverService) Get(ctx context.Context, id uint64, gopts ...receiver.GetOption) (*receiver.Receiver, error)

+ type ReceiverService_Expecter struct

+ func (_e *ReceiverService_Expecter) Get(ctx interface{}, id interface{}, gopts ...interface{}) *ReceiverService_Get_Call

+ type ReceiverService_Get_Call struct

+ func (_c *ReceiverService_Get_Call) Return(_a0 *receiver.Receiver, _a1 error) *ReceiverService_Get_Call

+ func (_c *ReceiverService_Get_Call) Run(run func(ctx context.Context, id uint64, gopts ...receiver.GetOption)) *ReceiverService_Get_Call

+ type Repository struct

+ func NewRepository(t mockConstructorTestingTNewRepository) *Repository

+ func (_m *Repository) Create(_a0 context.Context, _a1 notification.Notification) (notification.Notification, error)

+ func (_m *Repository) EXPECT() *Repository_Expecter

+ type Repository_Create_Call struct

+ func (_c *Repository_Create_Call) Return(_a0 notification.Notification, _a1 error) *Repository_Create_Call

+ func (_c *Repository_Create_Call) Run(run func(_a0 context.Context, _a1 notification.Notification)) *Repository_Create_Call

+ type Repository_Expecter struct

+ func (_e *Repository_Expecter) Create(_a0 interface{}, _a1 interface{}) *Repository_Create_Call

+ type SilenceService struct

+ func NewSilenceService(t mockConstructorTestingTNewSilenceService) *SilenceService

+ func (_m *SilenceService) EXPECT() *SilenceService_Expecter

+ func (_m *SilenceService) List(ctx context.Context, filter silence.Filter) ([]silence.Silence, error)

+ type SilenceService_Expecter struct

+ func (_e *SilenceService_Expecter) List(ctx interface{}, filter interface{}) *SilenceService_List_Call

+ type SilenceService_List_Call struct

+ func (_c *SilenceService_List_Call) Return(_a0 []silence.Silence, _a1 error) *SilenceService_List_Call

+ func (_c *SilenceService_List_Call) Run(run func(ctx context.Context, filter silence.Filter)) *SilenceService_List_Call

+ type SubscriptionService struct

+ func NewSubscriptionService(t mockConstructorTestingTNewSubscriptionService) *SubscriptionService

+ func (_m *SubscriptionService) EXPECT() *SubscriptionService_Expecter

+ func (_m *SubscriptionService) MatchByLabels(ctx context.Context, namespaceID uint64, labels map[string]string) ([]subscription.Subscription, error)

+ type SubscriptionService_Expecter struct

+ func (_e *SubscriptionService_Expecter) MatchByLabels(ctx interface{}, namespaceID interface{}, labels interface{}) *SubscriptionService_MatchByLabels_Call

+ type SubscriptionService_MatchByLabels_Call struct

+ func (_c *SubscriptionService_MatchByLabels_Call) Return(_a0 []subscription.Subscription, _a1 error) *SubscriptionService_MatchByLabels_Call

+ func (_c *SubscriptionService_MatchByLabels_Call) Run(run func(ctx context.Context, namespaceID uint64, labels map[string]string)) *SubscriptionService_MatchByLabels_Call