mocks

package

Go to main page

Versions in this module

v0

v0.8.4

Dec 2, 2024

v0.8.3

Nov 21, 2024

v0.8.2

Oct 25, 2024

v0.8.1

Sep 12, 2024

v0.8.0

Aug 20, 2024

v0.7.11-rc1

Nov 21, 2024

v0.7.10

Jul 24, 2024

v0.7.10-beta2

Jul 24, 2024

v0.7.10-beta

Jul 24, 2024

v0.7.9

Jul 18, 2024

v0.7.8

Jul 16, 2024

v0.7.8-rc

Jul 16, 2024

v0.7.7

Jul 9, 2024

v0.7.7-rc1

Jul 9, 2024

v0.7.7-rc

Jul 3, 2024

v0.7.6

Jun 3, 2024

v0.7.6-alpha

May 29, 2024

v0.7.5

May 20, 2024

Changes in this version

type SubscriptionService

+ func (_m *SubscriptionService) CreateV2(_a0 context.Context, _a1 *subscription.Subscription) error

+ func (_m *SubscriptionService) DeleteV2(_a0 context.Context, _a1 uint64) error

+ func (_m *SubscriptionService) GetV2(_a0 context.Context, _a1 uint64) (*subscription.Subscription, error)

+ func (_m *SubscriptionService) ListV2(_a0 context.Context, _a1 subscription.Filter) ([]subscription.Subscription, error)

+ func (_m *SubscriptionService) UpdateV2(_a0 context.Context, _a1 *subscription.Subscription) error

+ type SubscriptionService_CreateV2_Call struct

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

+ func (_c *SubscriptionService_CreateV2_Call) Run(run func(_a0 context.Context, _a1 *subscription.Subscription)) *SubscriptionService_CreateV2_Call

+ func (_c *SubscriptionService_CreateV2_Call) RunAndReturn(run func(context.Context, *subscription.Subscription) error) *SubscriptionService_CreateV2_Call

+ type SubscriptionService_DeleteV2_Call struct

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

+ func (_c *SubscriptionService_DeleteV2_Call) Run(run func(_a0 context.Context, _a1 uint64)) *SubscriptionService_DeleteV2_Call

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

type SubscriptionService_Expecter

+ func (_e *SubscriptionService_Expecter) CreateV2(_a0 interface{}, _a1 interface{}) *SubscriptionService_CreateV2_Call

+ func (_e *SubscriptionService_Expecter) DeleteV2(_a0 interface{}, _a1 interface{}) *SubscriptionService_DeleteV2_Call

+ func (_e *SubscriptionService_Expecter) GetV2(_a0 interface{}, _a1 interface{}) *SubscriptionService_GetV2_Call

+ func (_e *SubscriptionService_Expecter) ListV2(_a0 interface{}, _a1 interface{}) *SubscriptionService_ListV2_Call

+ func (_e *SubscriptionService_Expecter) UpdateV2(_a0 interface{}, _a1 interface{}) *SubscriptionService_UpdateV2_Call

+ type SubscriptionService_GetV2_Call struct

+ func (_c *SubscriptionService_GetV2_Call) Return(_a0 *subscription.Subscription, _a1 error) *SubscriptionService_GetV2_Call

+ func (_c *SubscriptionService_GetV2_Call) Run(run func(_a0 context.Context, _a1 uint64)) *SubscriptionService_GetV2_Call

+ func (_c *SubscriptionService_GetV2_Call) RunAndReturn(run func(context.Context, uint64) (*subscription.Subscription, error)) *SubscriptionService_GetV2_Call

+ type SubscriptionService_ListV2_Call struct

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

+ func (_c *SubscriptionService_ListV2_Call) Run(run func(_a0 context.Context, _a1 subscription.Filter)) *SubscriptionService_ListV2_Call

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

+ type SubscriptionService_UpdateV2_Call struct

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

+ func (_c *SubscriptionService_UpdateV2_Call) Run(run func(_a0 context.Context, _a1 *subscription.Subscription)) *SubscriptionService_UpdateV2_Call

+ func (_c *SubscriptionService_UpdateV2_Call) RunAndReturn(run func(context.Context, *subscription.Subscription) error) *SubscriptionService_UpdateV2_Call

v0.7.5-alpha

May 15, 2024

v0.7.4

Apr 3, 2024

Changes in this version

type NotificationService

+ func (_m *NotificationService) List(ctx context.Context, flt notification.Filter) ([]notification.Notification, error)

type NotificationService_Expecter

+ func (_e *NotificationService_Expecter) List(ctx interface{}, flt interface{}) *NotificationService_List_Call

+ type NotificationService_List_Call struct

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

+ func (_c *NotificationService_List_Call) Run(run func(ctx context.Context, flt notification.Filter)) *NotificationService_List_Call

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

v0.7.3

Mar 28, 2024

Changes in this version

type NotificationService

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

type NotificationService_Expecter

+ func (_e *NotificationService_Expecter) ListNotificationMessages(ctx interface{}, notificationID interface{}) *NotificationService_ListNotificationMessages_Call

+ type NotificationService_ListNotificationMessages_Call struct

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

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

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

v0.7.2

Mar 27, 2024

v0.7.1

Mar 22, 2024

v0.7.0

Mar 15, 2024

Changes in this version

type NotificationService

+ func (_m *NotificationService) CheckIdempotency(ctx context.Context, scope string, key string) (string, error)

+ func (_m *NotificationService) InsertIdempotency(ctx context.Context, scope string, key string, notificationID string) error

+ type NotificationService_CheckIdempotency_Call struct

+ func (_c *NotificationService_CheckIdempotency_Call) Return(_a0 string, _a1 error) *NotificationService_CheckIdempotency_Call

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

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

type NotificationService_Expecter

+ func (_e *NotificationService_Expecter) CheckIdempotency(ctx interface{}, scope interface{}, key interface{}) *NotificationService_CheckIdempotency_Call

+ func (_e *NotificationService_Expecter) InsertIdempotency(ctx interface{}, scope interface{}, key interface{}, ...) *NotificationService_InsertIdempotency_Call

+ type NotificationService_InsertIdempotency_Call struct

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

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

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

v0.6.12

Feb 2, 2024

v0.6.11

Jan 29, 2024

v0.6.10

Nov 3, 2023

v0.6.10-dev1

Nov 23, 2023

v0.6.9

Oct 26, 2023

v0.6.9-dev

Oct 25, 2023

v0.6.9-cortex-dev

Oct 25, 2023

v0.6.9-cortex

Oct 26, 2023

v0.6.8

Oct 19, 2023

v0.6.8-cortex

Oct 26, 2023

v0.6.7

Sep 18, 2023

v0.6.7-cortex

Sep 19, 2023

v0.6.6

Aug 4, 2023

v0.6.5

Aug 2, 2023

v0.6.4

Jun 20, 2023

v0.6.3

Jun 9, 2023

v0.6.2

May 11, 2023

v0.6.1

Mar 15, 2023

Changes in this version

type AlertService_CreateAlerts_Call

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

type AlertService_List_Call

+ func (_c *AlertService_List_Call) RunAndReturn(run func(context.Context, alert.Filter) ([]alert.Alert, error)) *AlertService_List_Call

type NamespaceService_Create_Call

+ func (_c *NamespaceService_Create_Call) RunAndReturn(run func(context.Context, *namespace.Namespace) error) *NamespaceService_Create_Call

type NamespaceService_Delete_Call

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

type NamespaceService_Get_Call

+ func (_c *NamespaceService_Get_Call) RunAndReturn(run func(context.Context, uint64) (*namespace.Namespace, error)) *NamespaceService_Get_Call

type NamespaceService_List_Call

+ func (_c *NamespaceService_List_Call) RunAndReturn(run func(context.Context) ([]namespace.Namespace, error)) *NamespaceService_List_Call

type NamespaceService_Update_Call

+ func (_c *NamespaceService_Update_Call) RunAndReturn(run func(context.Context, *namespace.Namespace) error) *NamespaceService_Update_Call

type NotificationService

+ func (_m *NotificationService) BuildFromAlerts(alerts []alert.Alert, firingLen int, createdTime time.Time) ([]notification.Notification, error)

+ type NotificationService_BuildFromAlerts_Call struct

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

+ func (_c *NotificationService_BuildFromAlerts_Call) Run(run func(alerts []alert.Alert, firingLen int, createdTime time.Time)) *NotificationService_BuildFromAlerts_Call

+ func (_c *NotificationService_BuildFromAlerts_Call) RunAndReturn(run func([]alert.Alert, int, time.Time) ([]notification.Notification, error)) *NotificationService_BuildFromAlerts_Call

type NotificationService_CheckAndInsertIdempotency_Call

+ func (_c *NotificationService_CheckAndInsertIdempotency_Call) RunAndReturn(run func(context.Context, string, string) (uint64, error)) *NotificationService_CheckAndInsertIdempotency_Call

type NotificationService_Dispatch_Call

+ func (_c *NotificationService_Dispatch_Call) RunAndReturn(run func(context.Context, notification.Notification) error) *NotificationService_Dispatch_Call

type NotificationService_Expecter

+ func (_e *NotificationService_Expecter) BuildFromAlerts(alerts interface{}, firingLen interface{}, createdTime interface{}) *NotificationService_BuildFromAlerts_Call

type NotificationService_MarkIdempotencyAsSuccess_Call

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

type NotificationService_RemoveIdempotencies_Call

+ func (_c *NotificationService_RemoveIdempotencies_Call) RunAndReturn(run func(context.Context, time.Duration) error) *NotificationService_RemoveIdempotencies_Call

type ProviderService_Create_Call

+ func (_c *ProviderService_Create_Call) RunAndReturn(run func(context.Context, *provider.Provider) error) *ProviderService_Create_Call

type ProviderService_Delete_Call

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

type ProviderService_Get_Call

+ func (_c *ProviderService_Get_Call) RunAndReturn(run func(context.Context, uint64) (*provider.Provider, error)) *ProviderService_Get_Call

type ProviderService_List_Call

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

type ProviderService_Update_Call

+ func (_c *ProviderService_Update_Call) RunAndReturn(run func(context.Context, *provider.Provider) error) *ProviderService_Update_Call

type ReceiverService_Create_Call

+ func (_c *ReceiverService_Create_Call) RunAndReturn(run func(context.Context, *receiver.Receiver) error) *ReceiverService_Create_Call

type ReceiverService_Delete_Call

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

type ReceiverService_Get_Call

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

type ReceiverService_List_Call

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

type ReceiverService_Update_Call

+ func (_c *ReceiverService_Update_Call) RunAndReturn(run func(context.Context, *receiver.Receiver) error) *ReceiverService_Update_Call

type RuleService_List_Call

+ func (_c *RuleService_List_Call) RunAndReturn(run func(context.Context, rule.Filter) ([]rule.Rule, error)) *RuleService_List_Call

type RuleService_Upsert_Call

+ func (_c *RuleService_Upsert_Call) RunAndReturn(run func(context.Context, *rule.Rule) error) *RuleService_Upsert_Call

type SilenceService_Create_Call

+ func (_c *SilenceService_Create_Call) RunAndReturn(run func(context.Context, silence.Silence) (string, error)) *SilenceService_Create_Call

type SilenceService_Delete_Call

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

type SilenceService_Get_Call

+ func (_c *SilenceService_Get_Call) RunAndReturn(run func(context.Context, string) (silence.Silence, error)) *SilenceService_Get_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_Create_Call

+ func (_c *SubscriptionService_Create_Call) RunAndReturn(run func(context.Context, *subscription.Subscription) error) *SubscriptionService_Create_Call

type SubscriptionService_Delete_Call

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

type SubscriptionService_Get_Call

+ func (_c *SubscriptionService_Get_Call) RunAndReturn(run func(context.Context, uint64) (*subscription.Subscription, error)) *SubscriptionService_Get_Call

type SubscriptionService_List_Call

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

type SubscriptionService_Update_Call

+ func (_c *SubscriptionService_Update_Call) RunAndReturn(run func(context.Context, *subscription.Subscription) error) *SubscriptionService_Update_Call

type TemplateService_Delete_Call

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

type TemplateService_GetByName_Call

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

type TemplateService_List_Call

+ func (_c *TemplateService_List_Call) RunAndReturn(run func(context.Context, template.Filter) ([]template.Template, error)) *TemplateService_List_Call

type TemplateService_Render_Call

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

type TemplateService_Upsert_Call

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

v0.6.0

Mar 15, 2023

Changes in this version

+ type AlertService struct

+ func NewAlertService(t mockConstructorTestingTNewAlertService) *AlertService

+ func (_m *AlertService) CreateAlerts(ctx context.Context, providerType string, providerID uint64, ...) ([]alert.Alert, int, error)

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

+ func (_m *AlertService) List(_a0 context.Context, _a1 alert.Filter) ([]alert.Alert, error)

+ type AlertService_CreateAlerts_Call struct

+ func (_c *AlertService_CreateAlerts_Call) Return(_a0 []alert.Alert, _a1 int, _a2 error) *AlertService_CreateAlerts_Call

+ func (_c *AlertService_CreateAlerts_Call) Run(run func(ctx context.Context, providerType string, providerID uint64, ...)) *AlertService_CreateAlerts_Call

+ type AlertService_Expecter struct

+ func (_e *AlertService_Expecter) CreateAlerts(ctx interface{}, providerType interface{}, providerID interface{}, ...) *AlertService_CreateAlerts_Call

+ func (_e *AlertService_Expecter) List(_a0 interface{}, _a1 interface{}) *AlertService_List_Call

+ type AlertService_List_Call struct

+ func (_c *AlertService_List_Call) Return(_a0 []alert.Alert, _a1 error) *AlertService_List_Call

+ func (_c *AlertService_List_Call) Run(run func(_a0 context.Context, _a1 alert.Filter)) *AlertService_List_Call

+ type NamespaceService struct

+ func NewNamespaceService(t mockConstructorTestingTNewNamespaceService) *NamespaceService

+ func (_m *NamespaceService) Create(_a0 context.Context, _a1 *namespace.Namespace) error

+ func (_m *NamespaceService) Delete(_a0 context.Context, _a1 uint64) error

+ func (_m *NamespaceService) EXPECT() *NamespaceService_Expecter

+ func (_m *NamespaceService) Get(_a0 context.Context, _a1 uint64) (*namespace.Namespace, error)

+ func (_m *NamespaceService) List(_a0 context.Context) ([]namespace.Namespace, error)

+ func (_m *NamespaceService) Update(_a0 context.Context, _a1 *namespace.Namespace) error

+ type NamespaceService_Create_Call struct

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

+ func (_c *NamespaceService_Create_Call) Run(run func(_a0 context.Context, _a1 *namespace.Namespace)) *NamespaceService_Create_Call

+ type NamespaceService_Delete_Call struct

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

+ func (_c *NamespaceService_Delete_Call) Run(run func(_a0 context.Context, _a1 uint64)) *NamespaceService_Delete_Call

+ type NamespaceService_Expecter struct

+ func (_e *NamespaceService_Expecter) Create(_a0 interface{}, _a1 interface{}) *NamespaceService_Create_Call

+ func (_e *NamespaceService_Expecter) Delete(_a0 interface{}, _a1 interface{}) *NamespaceService_Delete_Call

+ func (_e *NamespaceService_Expecter) Get(_a0 interface{}, _a1 interface{}) *NamespaceService_Get_Call

+ func (_e *NamespaceService_Expecter) List(_a0 interface{}) *NamespaceService_List_Call

+ func (_e *NamespaceService_Expecter) Update(_a0 interface{}, _a1 interface{}) *NamespaceService_Update_Call

+ type NamespaceService_Get_Call struct

+ func (_c *NamespaceService_Get_Call) Return(_a0 *namespace.Namespace, _a1 error) *NamespaceService_Get_Call

+ func (_c *NamespaceService_Get_Call) Run(run func(_a0 context.Context, _a1 uint64)) *NamespaceService_Get_Call

+ type NamespaceService_List_Call struct

+ func (_c *NamespaceService_List_Call) Return(_a0 []namespace.Namespace, _a1 error) *NamespaceService_List_Call

+ func (_c *NamespaceService_List_Call) Run(run func(_a0 context.Context)) *NamespaceService_List_Call

+ type NamespaceService_Update_Call struct

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

+ func (_c *NamespaceService_Update_Call) Run(run func(_a0 context.Context, _a1 *namespace.Namespace)) *NamespaceService_Update_Call

+ type NotificationService struct

+ func NewNotificationService(t mockConstructorTestingTNewNotificationService) *NotificationService

+ func (_m *NotificationService) CheckAndInsertIdempotency(ctx context.Context, scope string, key string) (uint64, error)

+ func (_m *NotificationService) Dispatch(ctx context.Context, n notification.Notification) error

+ func (_m *NotificationService) EXPECT() *NotificationService_Expecter

+ func (_m *NotificationService) MarkIdempotencyAsSuccess(ctx context.Context, id uint64) error

+ func (_m *NotificationService) RemoveIdempotencies(ctx context.Context, TTL time.Duration) error

+ type NotificationService_CheckAndInsertIdempotency_Call struct

+ func (_c *NotificationService_CheckAndInsertIdempotency_Call) Return(_a0 uint64, _a1 error) *NotificationService_CheckAndInsertIdempotency_Call

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

+ type NotificationService_Dispatch_Call struct

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

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

+ type NotificationService_Expecter struct

+ func (_e *NotificationService_Expecter) CheckAndInsertIdempotency(ctx interface{}, scope interface{}, key interface{}) *NotificationService_CheckAndInsertIdempotency_Call

+ func (_e *NotificationService_Expecter) Dispatch(ctx interface{}, n interface{}) *NotificationService_Dispatch_Call

+ func (_e *NotificationService_Expecter) MarkIdempotencyAsSuccess(ctx interface{}, id interface{}) *NotificationService_MarkIdempotencyAsSuccess_Call

+ func (_e *NotificationService_Expecter) RemoveIdempotencies(ctx interface{}, TTL interface{}) *NotificationService_RemoveIdempotencies_Call

+ type NotificationService_MarkIdempotencyAsSuccess_Call struct

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

+ func (_c *NotificationService_MarkIdempotencyAsSuccess_Call) Run(run func(ctx context.Context, id uint64)) *NotificationService_MarkIdempotencyAsSuccess_Call

+ type NotificationService_RemoveIdempotencies_Call struct

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

+ func (_c *NotificationService_RemoveIdempotencies_Call) Run(run func(ctx context.Context, TTL time.Duration)) *NotificationService_RemoveIdempotencies_Call

+ type ProviderService struct

+ func NewProviderService(t mockConstructorTestingTNewProviderService) *ProviderService

+ func (_m *ProviderService) Create(_a0 context.Context, _a1 *provider.Provider) error

+ func (_m *ProviderService) Delete(_a0 context.Context, _a1 uint64) error

+ func (_m *ProviderService) EXPECT() *ProviderService_Expecter

+ func (_m *ProviderService) Get(_a0 context.Context, _a1 uint64) (*provider.Provider, error)

+ func (_m *ProviderService) List(_a0 context.Context, _a1 provider.Filter) ([]provider.Provider, error)

+ func (_m *ProviderService) Update(_a0 context.Context, _a1 *provider.Provider) error

+ type ProviderService_Create_Call struct

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

+ func (_c *ProviderService_Create_Call) Run(run func(_a0 context.Context, _a1 *provider.Provider)) *ProviderService_Create_Call

+ type ProviderService_Delete_Call struct

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

+ func (_c *ProviderService_Delete_Call) Run(run func(_a0 context.Context, _a1 uint64)) *ProviderService_Delete_Call

+ type ProviderService_Expecter struct

+ func (_e *ProviderService_Expecter) Create(_a0 interface{}, _a1 interface{}) *ProviderService_Create_Call

+ func (_e *ProviderService_Expecter) Delete(_a0 interface{}, _a1 interface{}) *ProviderService_Delete_Call

+ func (_e *ProviderService_Expecter) Get(_a0 interface{}, _a1 interface{}) *ProviderService_Get_Call

+ func (_e *ProviderService_Expecter) List(_a0 interface{}, _a1 interface{}) *ProviderService_List_Call

+ func (_e *ProviderService_Expecter) Update(_a0 interface{}, _a1 interface{}) *ProviderService_Update_Call

+ type ProviderService_Get_Call struct

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

+ func (_c *ProviderService_Get_Call) Run(run func(_a0 context.Context, _a1 uint64)) *ProviderService_Get_Call

+ type ProviderService_List_Call struct

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

+ func (_c *ProviderService_List_Call) Run(run func(_a0 context.Context, _a1 provider.Filter)) *ProviderService_List_Call

+ type ProviderService_Update_Call struct

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

+ func (_c *ProviderService_Update_Call) Run(run func(_a0 context.Context, _a1 *provider.Provider)) *ProviderService_Update_Call

+ type ReceiverService struct

+ func NewReceiverService(t mockConstructorTestingTNewReceiverService) *ReceiverService

+ func (_m *ReceiverService) Create(ctx context.Context, rcv *receiver.Receiver) error

+ func (_m *ReceiverService) Delete(ctx context.Context, id uint64) error

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

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

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

+ func (_m *ReceiverService) Update(ctx context.Context, rcv *receiver.Receiver) error

+ type ReceiverService_Create_Call struct

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

+ func (_c *ReceiverService_Create_Call) Run(run func(ctx context.Context, rcv *receiver.Receiver)) *ReceiverService_Create_Call

+ type ReceiverService_Delete_Call struct

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

+ func (_c *ReceiverService_Delete_Call) Run(run func(ctx context.Context, id uint64)) *ReceiverService_Delete_Call

+ type ReceiverService_Expecter struct

+ func (_e *ReceiverService_Expecter) Create(ctx interface{}, rcv interface{}) *ReceiverService_Create_Call

+ func (_e *ReceiverService_Expecter) Delete(ctx interface{}, id interface{}) *ReceiverService_Delete_Call

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

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

+ func (_e *ReceiverService_Expecter) Update(ctx interface{}, rcv interface{}) *ReceiverService_Update_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 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

+ type ReceiverService_Update_Call struct

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

+ func (_c *ReceiverService_Update_Call) Run(run func(ctx context.Context, rcv *receiver.Receiver)) *ReceiverService_Update_Call

+ type RuleService struct

+ func NewRuleService(t mockConstructorTestingTNewRuleService) *RuleService

+ func (_m *RuleService) EXPECT() *RuleService_Expecter

+ func (_m *RuleService) List(_a0 context.Context, _a1 rule.Filter) ([]rule.Rule, error)

+ func (_m *RuleService) Upsert(_a0 context.Context, _a1 *rule.Rule) error

+ type RuleService_Expecter struct

+ func (_e *RuleService_Expecter) List(_a0 interface{}, _a1 interface{}) *RuleService_List_Call

+ func (_e *RuleService_Expecter) Upsert(_a0 interface{}, _a1 interface{}) *RuleService_Upsert_Call

+ type RuleService_List_Call struct

+ func (_c *RuleService_List_Call) Return(_a0 []rule.Rule, _a1 error) *RuleService_List_Call

+ func (_c *RuleService_List_Call) Run(run func(_a0 context.Context, _a1 rule.Filter)) *RuleService_List_Call

+ type RuleService_Upsert_Call struct

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

+ func (_c *RuleService_Upsert_Call) Run(run func(_a0 context.Context, _a1 *rule.Rule)) *RuleService_Upsert_Call

+ type SilenceService struct

+ func NewSilenceService(t mockConstructorTestingTNewSilenceService) *SilenceService

+ func (_m *SilenceService) Create(ctx context.Context, sil silence.Silence) (string, error)

+ func (_m *SilenceService) Delete(ctx context.Context, id string) error

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

+ func (_m *SilenceService) Get(ctx context.Context, id string) (silence.Silence, error)

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

+ type SilenceService_Create_Call struct

+ func (_c *SilenceService_Create_Call) Return(_a0 string, _a1 error) *SilenceService_Create_Call

+ func (_c *SilenceService_Create_Call) Run(run func(ctx context.Context, sil silence.Silence)) *SilenceService_Create_Call

+ type SilenceService_Delete_Call struct

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

+ func (_c *SilenceService_Delete_Call) Run(run func(ctx context.Context, id string)) *SilenceService_Delete_Call

+ type SilenceService_Expecter struct

+ func (_e *SilenceService_Expecter) Create(ctx interface{}, sil interface{}) *SilenceService_Create_Call

+ func (_e *SilenceService_Expecter) Delete(ctx interface{}, id interface{}) *SilenceService_Delete_Call

+ func (_e *SilenceService_Expecter) Get(ctx interface{}, id interface{}) *SilenceService_Get_Call

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

+ type SilenceService_Get_Call struct

+ func (_c *SilenceService_Get_Call) Return(_a0 silence.Silence, _a1 error) *SilenceService_Get_Call

+ func (_c *SilenceService_Get_Call) Run(run func(ctx context.Context, id string)) *SilenceService_Get_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) Create(_a0 context.Context, _a1 *subscription.Subscription) error

+ func (_m *SubscriptionService) Delete(_a0 context.Context, _a1 uint64) error

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

+ func (_m *SubscriptionService) Get(_a0 context.Context, _a1 uint64) (*subscription.Subscription, error)

+ func (_m *SubscriptionService) List(_a0 context.Context, _a1 subscription.Filter) ([]subscription.Subscription, error)

+ func (_m *SubscriptionService) Update(_a0 context.Context, _a1 *subscription.Subscription) error

+ type SubscriptionService_Create_Call struct

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

+ func (_c *SubscriptionService_Create_Call) Run(run func(_a0 context.Context, _a1 *subscription.Subscription)) *SubscriptionService_Create_Call

+ type SubscriptionService_Delete_Call struct

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

+ func (_c *SubscriptionService_Delete_Call) Run(run func(_a0 context.Context, _a1 uint64)) *SubscriptionService_Delete_Call

+ type SubscriptionService_Expecter struct

+ func (_e *SubscriptionService_Expecter) Create(_a0 interface{}, _a1 interface{}) *SubscriptionService_Create_Call

+ func (_e *SubscriptionService_Expecter) Delete(_a0 interface{}, _a1 interface{}) *SubscriptionService_Delete_Call

+ func (_e *SubscriptionService_Expecter) Get(_a0 interface{}, _a1 interface{}) *SubscriptionService_Get_Call

+ func (_e *SubscriptionService_Expecter) List(_a0 interface{}, _a1 interface{}) *SubscriptionService_List_Call

+ func (_e *SubscriptionService_Expecter) Update(_a0 interface{}, _a1 interface{}) *SubscriptionService_Update_Call

+ type SubscriptionService_Get_Call struct

+ func (_c *SubscriptionService_Get_Call) Return(_a0 *subscription.Subscription, _a1 error) *SubscriptionService_Get_Call

+ func (_c *SubscriptionService_Get_Call) Run(run func(_a0 context.Context, _a1 uint64)) *SubscriptionService_Get_Call

+ type SubscriptionService_List_Call struct

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

+ func (_c *SubscriptionService_List_Call) Run(run func(_a0 context.Context, _a1 subscription.Filter)) *SubscriptionService_List_Call

+ type SubscriptionService_Update_Call struct

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

+ func (_c *SubscriptionService_Update_Call) Run(run func(_a0 context.Context, _a1 *subscription.Subscription)) *SubscriptionService_Update_Call

+ type TemplateService struct

+ func NewTemplateService(t mockConstructorTestingTNewTemplateService) *TemplateService

+ func (_m *TemplateService) Delete(_a0 context.Context, _a1 string) error

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

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

+ func (_m *TemplateService) List(_a0 context.Context, _a1 template.Filter) ([]template.Template, error)

+ func (_m *TemplateService) Render(_a0 context.Context, _a1 string, _a2 map[string]string) (string, error)

+ func (_m *TemplateService) Upsert(_a0 context.Context, _a1 *template.Template) error

+ type TemplateService_Delete_Call struct

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

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

+ type TemplateService_Expecter struct

+ func (_e *TemplateService_Expecter) Delete(_a0 interface{}, _a1 interface{}) *TemplateService_Delete_Call

+ func (_e *TemplateService_Expecter) GetByName(_a0 interface{}, _a1 interface{}) *TemplateService_GetByName_Call

+ func (_e *TemplateService_Expecter) List(_a0 interface{}, _a1 interface{}) *TemplateService_List_Call

+ func (_e *TemplateService_Expecter) Render(_a0 interface{}, _a1 interface{}, _a2 interface{}) *TemplateService_Render_Call

+ func (_e *TemplateService_Expecter) Upsert(_a0 interface{}, _a1 interface{}) *TemplateService_Upsert_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(_a0 context.Context, _a1 string)) *TemplateService_GetByName_Call

+ type TemplateService_List_Call struct

+ func (_c *TemplateService_List_Call) Return(_a0 []template.Template, _a1 error) *TemplateService_List_Call

+ func (_c *TemplateService_List_Call) Run(run func(_a0 context.Context, _a1 template.Filter)) *TemplateService_List_Call

+ type TemplateService_Render_Call struct

+ func (_c *TemplateService_Render_Call) Return(_a0 string, _a1 error) *TemplateService_Render_Call

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

+ type TemplateService_Upsert_Call struct

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

+ func (_c *TemplateService_Upsert_Call) Run(run func(_a0 context.Context, _a1 *template.Template)) *TemplateService_Upsert_Call

v0.0.1-cortex

Sep 11, 2023

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