mirror of
https://github.com/SigNoz/signoz.git
synced 2026-02-03 08:33:26 +00:00
6a0ee32616
Some checks failed
build-staging / prepare (push) Has been cancelled
build-staging / js-build (push) Has been cancelled
build-staging / go-build (push) Has been cancelled
build-staging / staging (push) Has been cancelled
Release Drafter / update_release_draft (push) Has been cancelled
## Description - add mocks for tokenizer - rename mocks in alertmanager to alertmanagertest - add makefile command for generating mocks
1837 lines
60 KiB
Go
1837 lines
60 KiB
Go
// Code generated by mockery; DO NOT EDIT.
|
|
// github.com/vektra/mockery
|
|
// template: testify
|
|
|
|
package alertmanagertest
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/SigNoz/signoz/pkg/types/alertmanagertypes"
|
|
"github.com/SigNoz/signoz/pkg/valuer"
|
|
"github.com/prometheus/alertmanager/config"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// NewMockAlertmanager creates a new instance of MockAlertmanager. 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 NewMockAlertmanager(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockAlertmanager {
|
|
mock := &MockAlertmanager{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// MockAlertmanager is an autogenerated mock type for the Alertmanager type
|
|
type MockAlertmanager struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockAlertmanager_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockAlertmanager) EXPECT() *MockAlertmanager_Expecter {
|
|
return &MockAlertmanager_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// Collect provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) Collect(context1 context.Context, uUID valuer.UUID) (map[string]any, error) {
|
|
ret := _mock.Called(context1, uUID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Collect")
|
|
}
|
|
|
|
var r0 map[string]any
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) (map[string]any, error)); ok {
|
|
return returnFunc(context1, uUID)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) map[string]any); ok {
|
|
r0 = returnFunc(context1, uUID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]any)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, valuer.UUID) error); ok {
|
|
r1 = returnFunc(context1, uUID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_Collect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Collect'
|
|
type MockAlertmanager_Collect_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Collect is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - uUID valuer.UUID
|
|
func (_e *MockAlertmanager_Expecter) Collect(context1 interface{}, uUID interface{}) *MockAlertmanager_Collect_Call {
|
|
return &MockAlertmanager_Collect_Call{Call: _e.mock.On("Collect", context1, uUID)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Collect_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockAlertmanager_Collect_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 valuer.UUID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(valuer.UUID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Collect_Call) Return(stringToV map[string]any, err error) *MockAlertmanager_Collect_Call {
|
|
_c.Call.Return(stringToV, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Collect_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (map[string]any, error)) *MockAlertmanager_Collect_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateChannel provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) CreateChannel(context1 context.Context, s string, v alertmanagertypes.Receiver) error {
|
|
ret := _mock.Called(context1, s, v)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateChannel")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) error); ok {
|
|
r0 = returnFunc(context1, s, v)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_CreateChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateChannel'
|
|
type MockAlertmanager_CreateChannel_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateChannel is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - v alertmanagertypes.Receiver
|
|
func (_e *MockAlertmanager_Expecter) CreateChannel(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_CreateChannel_Call {
|
|
return &MockAlertmanager_CreateChannel_Call{Call: _e.mock.On("CreateChannel", context1, s, v)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateChannel_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver)) *MockAlertmanager_CreateChannel_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 alertmanagertypes.Receiver
|
|
if args[2] != nil {
|
|
arg2 = args[2].(alertmanagertypes.Receiver)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateChannel_Call) Return(err error) *MockAlertmanager_CreateChannel_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateChannel_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver) error) *MockAlertmanager_CreateChannel_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateInhibitRules provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) CreateInhibitRules(ctx context.Context, orgID valuer.UUID, rules []config.InhibitRule) error {
|
|
ret := _mock.Called(ctx, orgID, rules)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateInhibitRules")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, []config.InhibitRule) error); ok {
|
|
r0 = returnFunc(ctx, orgID, rules)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_CreateInhibitRules_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateInhibitRules'
|
|
type MockAlertmanager_CreateInhibitRules_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateInhibitRules is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - orgID valuer.UUID
|
|
// - rules []config.InhibitRule
|
|
func (_e *MockAlertmanager_Expecter) CreateInhibitRules(ctx interface{}, orgID interface{}, rules interface{}) *MockAlertmanager_CreateInhibitRules_Call {
|
|
return &MockAlertmanager_CreateInhibitRules_Call{Call: _e.mock.On("CreateInhibitRules", ctx, orgID, rules)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateInhibitRules_Call) Run(run func(ctx context.Context, orgID valuer.UUID, rules []config.InhibitRule)) *MockAlertmanager_CreateInhibitRules_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 valuer.UUID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(valuer.UUID)
|
|
}
|
|
var arg2 []config.InhibitRule
|
|
if args[2] != nil {
|
|
arg2 = args[2].([]config.InhibitRule)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateInhibitRules_Call) Return(err error) *MockAlertmanager_CreateInhibitRules_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateInhibitRules_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, rules []config.InhibitRule) error) *MockAlertmanager_CreateInhibitRules_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateRoutePolicies provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) CreateRoutePolicies(ctx context.Context, routeRequests []*alertmanagertypes.PostableRoutePolicy) ([]*alertmanagertypes.GettableRoutePolicy, error) {
|
|
ret := _mock.Called(ctx, routeRequests)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRoutePolicies")
|
|
}
|
|
|
|
var r0 []*alertmanagertypes.GettableRoutePolicy
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, []*alertmanagertypes.PostableRoutePolicy) ([]*alertmanagertypes.GettableRoutePolicy, error)); ok {
|
|
return returnFunc(ctx, routeRequests)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, []*alertmanagertypes.PostableRoutePolicy) []*alertmanagertypes.GettableRoutePolicy); ok {
|
|
r0 = returnFunc(ctx, routeRequests)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*alertmanagertypes.GettableRoutePolicy)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, []*alertmanagertypes.PostableRoutePolicy) error); ok {
|
|
r1 = returnFunc(ctx, routeRequests)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_CreateRoutePolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoutePolicies'
|
|
type MockAlertmanager_CreateRoutePolicies_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateRoutePolicies is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - routeRequests []*alertmanagertypes.PostableRoutePolicy
|
|
func (_e *MockAlertmanager_Expecter) CreateRoutePolicies(ctx interface{}, routeRequests interface{}) *MockAlertmanager_CreateRoutePolicies_Call {
|
|
return &MockAlertmanager_CreateRoutePolicies_Call{Call: _e.mock.On("CreateRoutePolicies", ctx, routeRequests)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateRoutePolicies_Call) Run(run func(ctx context.Context, routeRequests []*alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_CreateRoutePolicies_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 []*alertmanagertypes.PostableRoutePolicy
|
|
if args[1] != nil {
|
|
arg1 = args[1].([]*alertmanagertypes.PostableRoutePolicy)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateRoutePolicies_Call) Return(gettableRoutePolicys []*alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_CreateRoutePolicies_Call {
|
|
_c.Call.Return(gettableRoutePolicys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateRoutePolicies_Call) RunAndReturn(run func(ctx context.Context, routeRequests []*alertmanagertypes.PostableRoutePolicy) ([]*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_CreateRoutePolicies_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateRoutePolicy provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) CreateRoutePolicy(ctx context.Context, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error) {
|
|
ret := _mock.Called(ctx, route)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateRoutePolicy")
|
|
}
|
|
|
|
var r0 *alertmanagertypes.GettableRoutePolicy
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)); ok {
|
|
return returnFunc(ctx, route)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.PostableRoutePolicy) *alertmanagertypes.GettableRoutePolicy); ok {
|
|
r0 = returnFunc(ctx, route)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*alertmanagertypes.GettableRoutePolicy)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *alertmanagertypes.PostableRoutePolicy) error); ok {
|
|
r1 = returnFunc(ctx, route)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_CreateRoutePolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoutePolicy'
|
|
type MockAlertmanager_CreateRoutePolicy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateRoutePolicy is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - route *alertmanagertypes.PostableRoutePolicy
|
|
func (_e *MockAlertmanager_Expecter) CreateRoutePolicy(ctx interface{}, route interface{}) *MockAlertmanager_CreateRoutePolicy_Call {
|
|
return &MockAlertmanager_CreateRoutePolicy_Call{Call: _e.mock.On("CreateRoutePolicy", ctx, route)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateRoutePolicy_Call) Run(run func(ctx context.Context, route *alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_CreateRoutePolicy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *alertmanagertypes.PostableRoutePolicy
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*alertmanagertypes.PostableRoutePolicy)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateRoutePolicy_Call) Return(gettableRoutePolicy *alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_CreateRoutePolicy_Call {
|
|
_c.Call.Return(gettableRoutePolicy, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_CreateRoutePolicy_Call) RunAndReturn(run func(ctx context.Context, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_CreateRoutePolicy_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteAllInhibitRulesByRuleId provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) DeleteAllInhibitRulesByRuleId(ctx context.Context, orgID valuer.UUID, ruleId string) error {
|
|
ret := _mock.Called(ctx, orgID, ruleId)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteAllInhibitRulesByRuleId")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, string) error); ok {
|
|
r0 = returnFunc(ctx, orgID, ruleId)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllInhibitRulesByRuleId'
|
|
type MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteAllInhibitRulesByRuleId is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - orgID valuer.UUID
|
|
// - ruleId string
|
|
func (_e *MockAlertmanager_Expecter) DeleteAllInhibitRulesByRuleId(ctx interface{}, orgID interface{}, ruleId interface{}) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
|
|
return &MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call{Call: _e.mock.On("DeleteAllInhibitRulesByRuleId", ctx, orgID, ruleId)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call) Run(run func(ctx context.Context, orgID valuer.UUID, ruleId string)) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 valuer.UUID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(valuer.UUID)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call) Return(err error) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, ruleId string) error) *MockAlertmanager_DeleteAllInhibitRulesByRuleId_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteAllRoutePoliciesByRuleId provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) DeleteAllRoutePoliciesByRuleId(ctx context.Context, ruleId string) error {
|
|
ret := _mock.Called(ctx, ruleId)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteAllRoutePoliciesByRuleId")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, ruleId)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllRoutePoliciesByRuleId'
|
|
type MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteAllRoutePoliciesByRuleId is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - ruleId string
|
|
func (_e *MockAlertmanager_Expecter) DeleteAllRoutePoliciesByRuleId(ctx interface{}, ruleId interface{}) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
|
|
return &MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call{Call: _e.mock.On("DeleteAllRoutePoliciesByRuleId", ctx, ruleId)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call) Run(run func(ctx context.Context, ruleId string)) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call) Return(err error) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call) RunAndReturn(run func(ctx context.Context, ruleId string) error) *MockAlertmanager_DeleteAllRoutePoliciesByRuleId_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteChannelByID provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) DeleteChannelByID(context1 context.Context, s string, uUID valuer.UUID) error {
|
|
ret := _mock.Called(context1, s, uUID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteChannelByID")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, valuer.UUID) error); ok {
|
|
r0 = returnFunc(context1, s, uUID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_DeleteChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteChannelByID'
|
|
type MockAlertmanager_DeleteChannelByID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteChannelByID is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - uUID valuer.UUID
|
|
func (_e *MockAlertmanager_Expecter) DeleteChannelByID(context1 interface{}, s interface{}, uUID interface{}) *MockAlertmanager_DeleteChannelByID_Call {
|
|
return &MockAlertmanager_DeleteChannelByID_Call{Call: _e.mock.On("DeleteChannelByID", context1, s, uUID)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteChannelByID_Call) Run(run func(context1 context.Context, s string, uUID valuer.UUID)) *MockAlertmanager_DeleteChannelByID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 valuer.UUID
|
|
if args[2] != nil {
|
|
arg2 = args[2].(valuer.UUID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteChannelByID_Call) Return(err error) *MockAlertmanager_DeleteChannelByID_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteChannelByID_Call) RunAndReturn(run func(context1 context.Context, s string, uUID valuer.UUID) error) *MockAlertmanager_DeleteChannelByID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteNotificationConfig provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) DeleteNotificationConfig(ctx context.Context, orgID valuer.UUID, ruleId string) error {
|
|
ret := _mock.Called(ctx, orgID, ruleId)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteNotificationConfig")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, string) error); ok {
|
|
r0 = returnFunc(ctx, orgID, ruleId)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_DeleteNotificationConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteNotificationConfig'
|
|
type MockAlertmanager_DeleteNotificationConfig_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteNotificationConfig is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - orgID valuer.UUID
|
|
// - ruleId string
|
|
func (_e *MockAlertmanager_Expecter) DeleteNotificationConfig(ctx interface{}, orgID interface{}, ruleId interface{}) *MockAlertmanager_DeleteNotificationConfig_Call {
|
|
return &MockAlertmanager_DeleteNotificationConfig_Call{Call: _e.mock.On("DeleteNotificationConfig", ctx, orgID, ruleId)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteNotificationConfig_Call) Run(run func(ctx context.Context, orgID valuer.UUID, ruleId string)) *MockAlertmanager_DeleteNotificationConfig_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 valuer.UUID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(valuer.UUID)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteNotificationConfig_Call) Return(err error) *MockAlertmanager_DeleteNotificationConfig_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteNotificationConfig_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, ruleId string) error) *MockAlertmanager_DeleteNotificationConfig_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteRoutePolicyByID provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) DeleteRoutePolicyByID(ctx context.Context, routeID string) error {
|
|
ret := _mock.Called(ctx, routeID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteRoutePolicyByID")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(ctx, routeID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_DeleteRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteRoutePolicyByID'
|
|
type MockAlertmanager_DeleteRoutePolicyByID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteRoutePolicyByID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - routeID string
|
|
func (_e *MockAlertmanager_Expecter) DeleteRoutePolicyByID(ctx interface{}, routeID interface{}) *MockAlertmanager_DeleteRoutePolicyByID_Call {
|
|
return &MockAlertmanager_DeleteRoutePolicyByID_Call{Call: _e.mock.On("DeleteRoutePolicyByID", ctx, routeID)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteRoutePolicyByID_Call) Run(run func(ctx context.Context, routeID string)) *MockAlertmanager_DeleteRoutePolicyByID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteRoutePolicyByID_Call) Return(err error) *MockAlertmanager_DeleteRoutePolicyByID_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_DeleteRoutePolicyByID_Call) RunAndReturn(run func(ctx context.Context, routeID string) error) *MockAlertmanager_DeleteRoutePolicyByID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAlerts provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) GetAlerts(context1 context.Context, s string, gettableAlertsParams alertmanagertypes.GettableAlertsParams) (alertmanagertypes.DeprecatedGettableAlerts, error) {
|
|
ret := _mock.Called(context1, s, gettableAlertsParams)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAlerts")
|
|
}
|
|
|
|
var r0 alertmanagertypes.DeprecatedGettableAlerts
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.GettableAlertsParams) (alertmanagertypes.DeprecatedGettableAlerts, error)); ok {
|
|
return returnFunc(context1, s, gettableAlertsParams)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.GettableAlertsParams) alertmanagertypes.DeprecatedGettableAlerts); ok {
|
|
r0 = returnFunc(context1, s, gettableAlertsParams)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(alertmanagertypes.DeprecatedGettableAlerts)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, alertmanagertypes.GettableAlertsParams) error); ok {
|
|
r1 = returnFunc(context1, s, gettableAlertsParams)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_GetAlerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAlerts'
|
|
type MockAlertmanager_GetAlerts_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAlerts is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - gettableAlertsParams alertmanagertypes.GettableAlertsParams
|
|
func (_e *MockAlertmanager_Expecter) GetAlerts(context1 interface{}, s interface{}, gettableAlertsParams interface{}) *MockAlertmanager_GetAlerts_Call {
|
|
return &MockAlertmanager_GetAlerts_Call{Call: _e.mock.On("GetAlerts", context1, s, gettableAlertsParams)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetAlerts_Call) Run(run func(context1 context.Context, s string, gettableAlertsParams alertmanagertypes.GettableAlertsParams)) *MockAlertmanager_GetAlerts_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 alertmanagertypes.GettableAlertsParams
|
|
if args[2] != nil {
|
|
arg2 = args[2].(alertmanagertypes.GettableAlertsParams)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetAlerts_Call) Return(v alertmanagertypes.DeprecatedGettableAlerts, err error) *MockAlertmanager_GetAlerts_Call {
|
|
_c.Call.Return(v, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetAlerts_Call) RunAndReturn(run func(context1 context.Context, s string, gettableAlertsParams alertmanagertypes.GettableAlertsParams) (alertmanagertypes.DeprecatedGettableAlerts, error)) *MockAlertmanager_GetAlerts_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAllRoutePolicies provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) GetAllRoutePolicies(ctx context.Context) ([]*alertmanagertypes.GettableRoutePolicy, error) {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAllRoutePolicies")
|
|
}
|
|
|
|
var r0 []*alertmanagertypes.GettableRoutePolicy
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*alertmanagertypes.GettableRoutePolicy, error)); ok {
|
|
return returnFunc(ctx)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*alertmanagertypes.GettableRoutePolicy); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*alertmanagertypes.GettableRoutePolicy)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_GetAllRoutePolicies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllRoutePolicies'
|
|
type MockAlertmanager_GetAllRoutePolicies_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAllRoutePolicies is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *MockAlertmanager_Expecter) GetAllRoutePolicies(ctx interface{}) *MockAlertmanager_GetAllRoutePolicies_Call {
|
|
return &MockAlertmanager_GetAllRoutePolicies_Call{Call: _e.mock.On("GetAllRoutePolicies", ctx)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetAllRoutePolicies_Call) Run(run func(ctx context.Context)) *MockAlertmanager_GetAllRoutePolicies_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetAllRoutePolicies_Call) Return(gettableRoutePolicys []*alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_GetAllRoutePolicies_Call {
|
|
_c.Call.Return(gettableRoutePolicys, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetAllRoutePolicies_Call) RunAndReturn(run func(ctx context.Context) ([]*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_GetAllRoutePolicies_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetChannelByID provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) GetChannelByID(context1 context.Context, s string, uUID valuer.UUID) (*alertmanagertypes.Channel, error) {
|
|
ret := _mock.Called(context1, s, uUID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetChannelByID")
|
|
}
|
|
|
|
var r0 *alertmanagertypes.Channel
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, valuer.UUID) (*alertmanagertypes.Channel, error)); ok {
|
|
return returnFunc(context1, s, uUID)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, valuer.UUID) *alertmanagertypes.Channel); ok {
|
|
r0 = returnFunc(context1, s, uUID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*alertmanagertypes.Channel)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, valuer.UUID) error); ok {
|
|
r1 = returnFunc(context1, s, uUID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_GetChannelByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetChannelByID'
|
|
type MockAlertmanager_GetChannelByID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetChannelByID is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - uUID valuer.UUID
|
|
func (_e *MockAlertmanager_Expecter) GetChannelByID(context1 interface{}, s interface{}, uUID interface{}) *MockAlertmanager_GetChannelByID_Call {
|
|
return &MockAlertmanager_GetChannelByID_Call{Call: _e.mock.On("GetChannelByID", context1, s, uUID)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetChannelByID_Call) Run(run func(context1 context.Context, s string, uUID valuer.UUID)) *MockAlertmanager_GetChannelByID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 valuer.UUID
|
|
if args[2] != nil {
|
|
arg2 = args[2].(valuer.UUID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetChannelByID_Call) Return(channel *alertmanagertypes.Channel, err error) *MockAlertmanager_GetChannelByID_Call {
|
|
_c.Call.Return(channel, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetChannelByID_Call) RunAndReturn(run func(context1 context.Context, s string, uUID valuer.UUID) (*alertmanagertypes.Channel, error)) *MockAlertmanager_GetChannelByID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetConfig provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) GetConfig(context1 context.Context, s string) (*alertmanagertypes.Config, error) {
|
|
ret := _mock.Called(context1, s)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetConfig")
|
|
}
|
|
|
|
var r0 *alertmanagertypes.Config
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*alertmanagertypes.Config, error)); ok {
|
|
return returnFunc(context1, s)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) *alertmanagertypes.Config); ok {
|
|
r0 = returnFunc(context1, s)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*alertmanagertypes.Config)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(context1, s)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_GetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetConfig'
|
|
type MockAlertmanager_GetConfig_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetConfig is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
func (_e *MockAlertmanager_Expecter) GetConfig(context1 interface{}, s interface{}) *MockAlertmanager_GetConfig_Call {
|
|
return &MockAlertmanager_GetConfig_Call{Call: _e.mock.On("GetConfig", context1, s)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetConfig_Call) Run(run func(context1 context.Context, s string)) *MockAlertmanager_GetConfig_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetConfig_Call) Return(config1 *alertmanagertypes.Config, err error) *MockAlertmanager_GetConfig_Call {
|
|
_c.Call.Return(config1, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetConfig_Call) RunAndReturn(run func(context1 context.Context, s string) (*alertmanagertypes.Config, error)) *MockAlertmanager_GetConfig_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRoutePolicyByID provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) GetRoutePolicyByID(ctx context.Context, routeID string) (*alertmanagertypes.GettableRoutePolicy, error) {
|
|
ret := _mock.Called(ctx, routeID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRoutePolicyByID")
|
|
}
|
|
|
|
var r0 *alertmanagertypes.GettableRoutePolicy
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*alertmanagertypes.GettableRoutePolicy, error)); ok {
|
|
return returnFunc(ctx, routeID)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) *alertmanagertypes.GettableRoutePolicy); ok {
|
|
r0 = returnFunc(ctx, routeID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*alertmanagertypes.GettableRoutePolicy)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, routeID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_GetRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRoutePolicyByID'
|
|
type MockAlertmanager_GetRoutePolicyByID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRoutePolicyByID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - routeID string
|
|
func (_e *MockAlertmanager_Expecter) GetRoutePolicyByID(ctx interface{}, routeID interface{}) *MockAlertmanager_GetRoutePolicyByID_Call {
|
|
return &MockAlertmanager_GetRoutePolicyByID_Call{Call: _e.mock.On("GetRoutePolicyByID", ctx, routeID)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetRoutePolicyByID_Call) Run(run func(ctx context.Context, routeID string)) *MockAlertmanager_GetRoutePolicyByID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetRoutePolicyByID_Call) Return(gettableRoutePolicy *alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_GetRoutePolicyByID_Call {
|
|
_c.Call.Return(gettableRoutePolicy, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_GetRoutePolicyByID_Call) RunAndReturn(run func(ctx context.Context, routeID string) (*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_GetRoutePolicyByID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListAllChannels provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) ListAllChannels(context1 context.Context) ([]*alertmanagertypes.Channel, error) {
|
|
ret := _mock.Called(context1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListAllChannels")
|
|
}
|
|
|
|
var r0 []*alertmanagertypes.Channel
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) ([]*alertmanagertypes.Channel, error)); ok {
|
|
return returnFunc(context1)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) []*alertmanagertypes.Channel); ok {
|
|
r0 = returnFunc(context1)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*alertmanagertypes.Channel)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = returnFunc(context1)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_ListAllChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAllChannels'
|
|
type MockAlertmanager_ListAllChannels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListAllChannels is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
func (_e *MockAlertmanager_Expecter) ListAllChannels(context1 interface{}) *MockAlertmanager_ListAllChannels_Call {
|
|
return &MockAlertmanager_ListAllChannels_Call{Call: _e.mock.On("ListAllChannels", context1)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_ListAllChannels_Call) Run(run func(context1 context.Context)) *MockAlertmanager_ListAllChannels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_ListAllChannels_Call) Return(channels []*alertmanagertypes.Channel, err error) *MockAlertmanager_ListAllChannels_Call {
|
|
_c.Call.Return(channels, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_ListAllChannels_Call) RunAndReturn(run func(context1 context.Context) ([]*alertmanagertypes.Channel, error)) *MockAlertmanager_ListAllChannels_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListChannels provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) ListChannels(context1 context.Context, s string) ([]*alertmanagertypes.Channel, error) {
|
|
ret := _mock.Called(context1, s)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListChannels")
|
|
}
|
|
|
|
var r0 []*alertmanagertypes.Channel
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]*alertmanagertypes.Channel, error)); ok {
|
|
return returnFunc(context1, s)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) []*alertmanagertypes.Channel); ok {
|
|
r0 = returnFunc(context1, s)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*alertmanagertypes.Channel)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(context1, s)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_ListChannels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListChannels'
|
|
type MockAlertmanager_ListChannels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListChannels is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
func (_e *MockAlertmanager_Expecter) ListChannels(context1 interface{}, s interface{}) *MockAlertmanager_ListChannels_Call {
|
|
return &MockAlertmanager_ListChannels_Call{Call: _e.mock.On("ListChannels", context1, s)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_ListChannels_Call) Run(run func(context1 context.Context, s string)) *MockAlertmanager_ListChannels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_ListChannels_Call) Return(channels []*alertmanagertypes.Channel, err error) *MockAlertmanager_ListChannels_Call {
|
|
_c.Call.Return(channels, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_ListChannels_Call) RunAndReturn(run func(context1 context.Context, s string) ([]*alertmanagertypes.Channel, error)) *MockAlertmanager_ListChannels_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PutAlerts provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) PutAlerts(context1 context.Context, s string, v alertmanagertypes.PostableAlerts) error {
|
|
ret := _mock.Called(context1, s, v)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PutAlerts")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.PostableAlerts) error); ok {
|
|
r0 = returnFunc(context1, s, v)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_PutAlerts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutAlerts'
|
|
type MockAlertmanager_PutAlerts_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// PutAlerts is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - v alertmanagertypes.PostableAlerts
|
|
func (_e *MockAlertmanager_Expecter) PutAlerts(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_PutAlerts_Call {
|
|
return &MockAlertmanager_PutAlerts_Call{Call: _e.mock.On("PutAlerts", context1, s, v)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_PutAlerts_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.PostableAlerts)) *MockAlertmanager_PutAlerts_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 alertmanagertypes.PostableAlerts
|
|
if args[2] != nil {
|
|
arg2 = args[2].(alertmanagertypes.PostableAlerts)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_PutAlerts_Call) Return(err error) *MockAlertmanager_PutAlerts_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_PutAlerts_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.PostableAlerts) error) *MockAlertmanager_PutAlerts_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetConfig provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) SetConfig(context1 context.Context, config1 *alertmanagertypes.Config) error {
|
|
ret := _mock.Called(context1, config1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetConfig")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *alertmanagertypes.Config) error); ok {
|
|
r0 = returnFunc(context1, config1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_SetConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetConfig'
|
|
type MockAlertmanager_SetConfig_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetConfig is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - config1 *alertmanagertypes.Config
|
|
func (_e *MockAlertmanager_Expecter) SetConfig(context1 interface{}, config1 interface{}) *MockAlertmanager_SetConfig_Call {
|
|
return &MockAlertmanager_SetConfig_Call{Call: _e.mock.On("SetConfig", context1, config1)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetConfig_Call) Run(run func(context1 context.Context, config1 *alertmanagertypes.Config)) *MockAlertmanager_SetConfig_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *alertmanagertypes.Config
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*alertmanagertypes.Config)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetConfig_Call) Return(err error) *MockAlertmanager_SetConfig_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetConfig_Call) RunAndReturn(run func(context1 context.Context, config1 *alertmanagertypes.Config) error) *MockAlertmanager_SetConfig_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetDefaultConfig provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) SetDefaultConfig(context1 context.Context, s string) error {
|
|
ret := _mock.Called(context1, s)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetDefaultConfig")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = returnFunc(context1, s)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_SetDefaultConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDefaultConfig'
|
|
type MockAlertmanager_SetDefaultConfig_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetDefaultConfig is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
func (_e *MockAlertmanager_Expecter) SetDefaultConfig(context1 interface{}, s interface{}) *MockAlertmanager_SetDefaultConfig_Call {
|
|
return &MockAlertmanager_SetDefaultConfig_Call{Call: _e.mock.On("SetDefaultConfig", context1, s)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetDefaultConfig_Call) Run(run func(context1 context.Context, s string)) *MockAlertmanager_SetDefaultConfig_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetDefaultConfig_Call) Return(err error) *MockAlertmanager_SetDefaultConfig_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetDefaultConfig_Call) RunAndReturn(run func(context1 context.Context, s string) error) *MockAlertmanager_SetDefaultConfig_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetNotificationConfig provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) SetNotificationConfig(ctx context.Context, orgID valuer.UUID, ruleId string, config1 *alertmanagertypes.NotificationConfig) error {
|
|
ret := _mock.Called(ctx, orgID, ruleId, config1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetNotificationConfig")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID, string, *alertmanagertypes.NotificationConfig) error); ok {
|
|
r0 = returnFunc(ctx, orgID, ruleId, config1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_SetNotificationConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNotificationConfig'
|
|
type MockAlertmanager_SetNotificationConfig_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetNotificationConfig is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - orgID valuer.UUID
|
|
// - ruleId string
|
|
// - config1 *alertmanagertypes.NotificationConfig
|
|
func (_e *MockAlertmanager_Expecter) SetNotificationConfig(ctx interface{}, orgID interface{}, ruleId interface{}, config1 interface{}) *MockAlertmanager_SetNotificationConfig_Call {
|
|
return &MockAlertmanager_SetNotificationConfig_Call{Call: _e.mock.On("SetNotificationConfig", ctx, orgID, ruleId, config1)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetNotificationConfig_Call) Run(run func(ctx context.Context, orgID valuer.UUID, ruleId string, config1 *alertmanagertypes.NotificationConfig)) *MockAlertmanager_SetNotificationConfig_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 valuer.UUID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(valuer.UUID)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 *alertmanagertypes.NotificationConfig
|
|
if args[3] != nil {
|
|
arg3 = args[3].(*alertmanagertypes.NotificationConfig)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetNotificationConfig_Call) Return(err error) *MockAlertmanager_SetNotificationConfig_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_SetNotificationConfig_Call) RunAndReturn(run func(ctx context.Context, orgID valuer.UUID, ruleId string, config1 *alertmanagertypes.NotificationConfig) error) *MockAlertmanager_SetNotificationConfig_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) Start(context1 context.Context) error {
|
|
ret := _mock.Called(context1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Start")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = returnFunc(context1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type MockAlertmanager_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
func (_e *MockAlertmanager_Expecter) Start(context1 interface{}) *MockAlertmanager_Start_Call {
|
|
return &MockAlertmanager_Start_Call{Call: _e.mock.On("Start", context1)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Start_Call) Run(run func(context1 context.Context)) *MockAlertmanager_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Start_Call) Return(err error) *MockAlertmanager_Start_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Start_Call) RunAndReturn(run func(context1 context.Context) error) *MockAlertmanager_Start_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Stop provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) Stop(context1 context.Context) error {
|
|
ret := _mock.Called(context1)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Stop")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = returnFunc(context1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop'
|
|
type MockAlertmanager_Stop_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Stop is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
func (_e *MockAlertmanager_Expecter) Stop(context1 interface{}) *MockAlertmanager_Stop_Call {
|
|
return &MockAlertmanager_Stop_Call{Call: _e.mock.On("Stop", context1)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Stop_Call) Run(run func(context1 context.Context)) *MockAlertmanager_Stop_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Stop_Call) Return(err error) *MockAlertmanager_Stop_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_Stop_Call) RunAndReturn(run func(context1 context.Context) error) *MockAlertmanager_Stop_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TestAlert provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) TestAlert(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string) error {
|
|
ret := _mock.Called(ctx, orgID, ruleID, receiversMap)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TestAlert")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, map[*alertmanagertypes.PostableAlert][]string) error); ok {
|
|
r0 = returnFunc(ctx, orgID, ruleID, receiversMap)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_TestAlert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestAlert'
|
|
type MockAlertmanager_TestAlert_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TestAlert is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - orgID string
|
|
// - ruleID string
|
|
// - receiversMap map[*alertmanagertypes.PostableAlert][]string
|
|
func (_e *MockAlertmanager_Expecter) TestAlert(ctx interface{}, orgID interface{}, ruleID interface{}, receiversMap interface{}) *MockAlertmanager_TestAlert_Call {
|
|
return &MockAlertmanager_TestAlert_Call{Call: _e.mock.On("TestAlert", ctx, orgID, ruleID, receiversMap)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_TestAlert_Call) Run(run func(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string)) *MockAlertmanager_TestAlert_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 string
|
|
if args[2] != nil {
|
|
arg2 = args[2].(string)
|
|
}
|
|
var arg3 map[*alertmanagertypes.PostableAlert][]string
|
|
if args[3] != nil {
|
|
arg3 = args[3].(map[*alertmanagertypes.PostableAlert][]string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_TestAlert_Call) Return(err error) *MockAlertmanager_TestAlert_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_TestAlert_Call) RunAndReturn(run func(ctx context.Context, orgID string, ruleID string, receiversMap map[*alertmanagertypes.PostableAlert][]string) error) *MockAlertmanager_TestAlert_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TestReceiver provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) TestReceiver(context1 context.Context, s string, v alertmanagertypes.Receiver) error {
|
|
ret := _mock.Called(context1, s, v)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TestReceiver")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver) error); ok {
|
|
r0 = returnFunc(context1, s, v)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_TestReceiver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TestReceiver'
|
|
type MockAlertmanager_TestReceiver_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TestReceiver is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - v alertmanagertypes.Receiver
|
|
func (_e *MockAlertmanager_Expecter) TestReceiver(context1 interface{}, s interface{}, v interface{}) *MockAlertmanager_TestReceiver_Call {
|
|
return &MockAlertmanager_TestReceiver_Call{Call: _e.mock.On("TestReceiver", context1, s, v)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_TestReceiver_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver)) *MockAlertmanager_TestReceiver_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 alertmanagertypes.Receiver
|
|
if args[2] != nil {
|
|
arg2 = args[2].(alertmanagertypes.Receiver)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_TestReceiver_Call) Return(err error) *MockAlertmanager_TestReceiver_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_TestReceiver_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver) error) *MockAlertmanager_TestReceiver_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateAllRoutePoliciesByRuleId provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) UpdateAllRoutePoliciesByRuleId(ctx context.Context, ruleId string, routes []*alertmanagertypes.PostableRoutePolicy) error {
|
|
ret := _mock.Called(ctx, ruleId, routes)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateAllRoutePoliciesByRuleId")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, []*alertmanagertypes.PostableRoutePolicy) error); ok {
|
|
r0 = returnFunc(ctx, ruleId, routes)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAllRoutePoliciesByRuleId'
|
|
type MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateAllRoutePoliciesByRuleId is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - ruleId string
|
|
// - routes []*alertmanagertypes.PostableRoutePolicy
|
|
func (_e *MockAlertmanager_Expecter) UpdateAllRoutePoliciesByRuleId(ctx interface{}, ruleId interface{}, routes interface{}) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
|
|
return &MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call{Call: _e.mock.On("UpdateAllRoutePoliciesByRuleId", ctx, ruleId, routes)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) Run(run func(ctx context.Context, ruleId string, routes []*alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 []*alertmanagertypes.PostableRoutePolicy
|
|
if args[2] != nil {
|
|
arg2 = args[2].([]*alertmanagertypes.PostableRoutePolicy)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) Return(err error) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call) RunAndReturn(run func(ctx context.Context, ruleId string, routes []*alertmanagertypes.PostableRoutePolicy) error) *MockAlertmanager_UpdateAllRoutePoliciesByRuleId_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateChannelByReceiverAndID provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) UpdateChannelByReceiverAndID(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID) error {
|
|
ret := _mock.Called(context1, s, v, uUID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateChannelByReceiverAndID")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, alertmanagertypes.Receiver, valuer.UUID) error); ok {
|
|
r0 = returnFunc(context1, s, v, uUID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// MockAlertmanager_UpdateChannelByReceiverAndID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateChannelByReceiverAndID'
|
|
type MockAlertmanager_UpdateChannelByReceiverAndID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateChannelByReceiverAndID is a helper method to define mock.On call
|
|
// - context1 context.Context
|
|
// - s string
|
|
// - v alertmanagertypes.Receiver
|
|
// - uUID valuer.UUID
|
|
func (_e *MockAlertmanager_Expecter) UpdateChannelByReceiverAndID(context1 interface{}, s interface{}, v interface{}, uUID interface{}) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
|
|
return &MockAlertmanager_UpdateChannelByReceiverAndID_Call{Call: _e.mock.On("UpdateChannelByReceiverAndID", context1, s, v, uUID)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Run(run func(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID)) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 alertmanagertypes.Receiver
|
|
if args[2] != nil {
|
|
arg2 = args[2].(alertmanagertypes.Receiver)
|
|
}
|
|
var arg3 valuer.UUID
|
|
if args[3] != nil {
|
|
arg3 = args[3].(valuer.UUID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
arg3,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) Return(err error) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateChannelByReceiverAndID_Call) RunAndReturn(run func(context1 context.Context, s string, v alertmanagertypes.Receiver, uUID valuer.UUID) error) *MockAlertmanager_UpdateChannelByReceiverAndID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateRoutePolicyByID provides a mock function for the type MockAlertmanager
|
|
func (_mock *MockAlertmanager) UpdateRoutePolicyByID(ctx context.Context, routeID string, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error) {
|
|
ret := _mock.Called(ctx, routeID, route)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateRoutePolicyByID")
|
|
}
|
|
|
|
var r0 *alertmanagertypes.GettableRoutePolicy
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)); ok {
|
|
return returnFunc(ctx, routeID, route)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string, *alertmanagertypes.PostableRoutePolicy) *alertmanagertypes.GettableRoutePolicy); ok {
|
|
r0 = returnFunc(ctx, routeID, route)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*alertmanagertypes.GettableRoutePolicy)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string, *alertmanagertypes.PostableRoutePolicy) error); ok {
|
|
r1 = returnFunc(ctx, routeID, route)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// MockAlertmanager_UpdateRoutePolicyByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoutePolicyByID'
|
|
type MockAlertmanager_UpdateRoutePolicyByID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateRoutePolicyByID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - routeID string
|
|
// - route *alertmanagertypes.PostableRoutePolicy
|
|
func (_e *MockAlertmanager_Expecter) UpdateRoutePolicyByID(ctx interface{}, routeID interface{}, route interface{}) *MockAlertmanager_UpdateRoutePolicyByID_Call {
|
|
return &MockAlertmanager_UpdateRoutePolicyByID_Call{Call: _e.mock.On("UpdateRoutePolicyByID", ctx, routeID, route)}
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) Run(run func(ctx context.Context, routeID string, route *alertmanagertypes.PostableRoutePolicy)) *MockAlertmanager_UpdateRoutePolicyByID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
var arg2 *alertmanagertypes.PostableRoutePolicy
|
|
if args[2] != nil {
|
|
arg2 = args[2].(*alertmanagertypes.PostableRoutePolicy)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) Return(gettableRoutePolicy *alertmanagertypes.GettableRoutePolicy, err error) *MockAlertmanager_UpdateRoutePolicyByID_Call {
|
|
_c.Call.Return(gettableRoutePolicy, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockAlertmanager_UpdateRoutePolicyByID_Call) RunAndReturn(run func(ctx context.Context, routeID string, route *alertmanagertypes.PostableRoutePolicy) (*alertmanagertypes.GettableRoutePolicy, error)) *MockAlertmanager_UpdateRoutePolicyByID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|