diff --git a/.mockery.yml b/.mockery.yml index 164fd52a54..6f5a82c8d8 100644 --- a/.mockery.yml +++ b/.mockery.yml @@ -4,7 +4,14 @@ packages: github.com/SigNoz/signoz/pkg/alertmanager: config: all: true - dir: '{{.InterfaceDir}}/mocks' - filename: "mocks.go" + dir: '{{.InterfaceDir}}/alertmanagertest' + filename: "alertmanager.go" structname: 'Mock{{.InterfaceName}}' - pkgname: '{{.SrcPackageName}}mock' + pkgname: '{{.SrcPackageName}}test' + github.com/SigNoz/signoz/pkg/tokenizer: + config: + all: true + dir: '{{.InterfaceDir}}/tokenizertest' + filename: "tokenizer.go" + structname: 'Mock{{.InterfaceName}}' + pkgname: '{{.SrcPackageName}}test' diff --git a/.vscode/settings.json b/.vscode/settings.json index 860a91c9c6..19022660d3 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -5,5 +5,9 @@ "editor.codeActionsOnSave": { "source.fixAll.eslint": "explicit" }, - "prettier.requireConfig": true + "prettier.requireConfig": true, + "[go]": { + "editor.formatOnSave": true, + "editor.defaultFormatter": "golang.go" + } } diff --git a/Makefile b/Makefile index eda355a94b..4452861514 100644 --- a/Makefile +++ b/Makefile @@ -230,3 +230,12 @@ py-clean: ## Clear all pycache and pytest cache from tests directory recursively @find tests -type f -name "*.pyc" -delete 2>/dev/null || true @find tests -type f -name "*.pyo" -delete 2>/dev/null || true @echo ">> python cache cleaned" + + +############################################################## +# generate commands +############################################################## +.PHONY: gen-mocks +gen-mocks: + @echo ">> Generating mocks" + @mockery --config .mockery.yml \ No newline at end of file diff --git a/ee/query-service/rules/manager_test.go b/ee/query-service/rules/manager_test.go index 1d365393ed..077af52c2a 100644 --- a/ee/query-service/rules/manager_test.go +++ b/ee/query-service/rules/manager_test.go @@ -9,7 +9,7 @@ import ( "time" "github.com/SigNoz/signoz/pkg/alertmanager" - alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/mocks" + alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertest" "github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest" "github.com/SigNoz/signoz/pkg/prometheus" "github.com/SigNoz/signoz/pkg/prometheus/prometheustest" diff --git a/pkg/alertmanager/mocks/mocks.go b/pkg/alertmanager/alertmanagertest/alertmanager.go similarity index 99% rename from pkg/alertmanager/mocks/mocks.go rename to pkg/alertmanager/alertmanagertest/alertmanager.go index 3a207d18b7..48de1cdd4d 100644 --- a/pkg/alertmanager/mocks/mocks.go +++ b/pkg/alertmanager/alertmanagertest/alertmanager.go @@ -2,7 +2,7 @@ // github.com/vektra/mockery // template: testify -package alertmanagermock +package alertmanagertest import ( "context" diff --git a/pkg/query-service/rules/manager_test.go b/pkg/query-service/rules/manager_test.go index 681c67dde8..e9e2186b00 100644 --- a/pkg/query-service/rules/manager_test.go +++ b/pkg/query-service/rules/manager_test.go @@ -9,7 +9,7 @@ import ( "time" "github.com/SigNoz/signoz/pkg/alertmanager" - alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/mocks" + alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertest" "github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest" "github.com/SigNoz/signoz/pkg/prometheus" "github.com/SigNoz/signoz/pkg/prometheus/prometheustest" diff --git a/pkg/query-service/rules/managertestfactory.go b/pkg/query-service/rules/managertestfactory.go index 90d1b08fba..7641fb662c 100644 --- a/pkg/query-service/rules/managertestfactory.go +++ b/pkg/query-service/rules/managertestfactory.go @@ -7,7 +7,7 @@ import ( "github.com/DATA-DOG/go-sqlmock" "github.com/SigNoz/signoz/pkg/alertmanager" - alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/mocks" + alertmanagermock "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertest" "github.com/SigNoz/signoz/pkg/cache" "github.com/SigNoz/signoz/pkg/cache/cachetest" "github.com/SigNoz/signoz/pkg/flagger" diff --git a/pkg/query-service/rules/threshold_rule_test.go b/pkg/query-service/rules/threshold_rule_test.go index 6fce480b0a..917c1d30f8 100644 --- a/pkg/query-service/rules/threshold_rule_test.go +++ b/pkg/query-service/rules/threshold_rule_test.go @@ -2222,7 +2222,7 @@ func TestThresholdEval_RequireMinPoints(t *testing.T) { prometheusProvider := prometheustest.New(context.Background(), instrumentationtest.New().ToProviderSettings(), prometheus.Config{}, telemetryStore) reader := clickhouseReader.NewReader(nil, telemetryStore, prometheusProvider, "", time.Second, nil, readerCache, options) - rule, err := NewThresholdRule("some-id", valuer.GenerateUUID(), &postableRule, reader, nil, logger) + rule, err := NewThresholdRule("some-id", valuer.GenerateUUID(), &postableRule, reader, nil, logger) t.Run(fmt.Sprintf("%d Version=%s, %s", idx, version, c.description), func(t *testing.T) { require.NoError(t, err) rule.TemporalityMap = map[string]map[v3.Temporality]bool{ diff --git a/pkg/signoz/handler_test.go b/pkg/signoz/handler_test.go index 7ff1bade2e..021015e3fd 100644 --- a/pkg/signoz/handler_test.go +++ b/pkg/signoz/handler_test.go @@ -35,7 +35,7 @@ func TestNewHandlers(t *testing.T) { require.NoError(t, err) alertmanager, err := signozalertmanager.New(context.TODO(), providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager) require.NoError(t, err) - tokenizer := tokenizertest.New() + tokenizer := tokenizertest.NewMockTokenizer(t) emailing := emailingtest.New() queryParser := queryparser.New(providerSettings) require.NoError(t, err) diff --git a/pkg/signoz/module_test.go b/pkg/signoz/module_test.go index 4da21769e4..50e6e48932 100644 --- a/pkg/signoz/module_test.go +++ b/pkg/signoz/module_test.go @@ -35,7 +35,7 @@ func TestNewModules(t *testing.T) { require.NoError(t, err) alertmanager, err := signozalertmanager.New(context.TODO(), providerSettings, alertmanager.Config{}, sqlstore, orgGetter, notificationManager) require.NoError(t, err) - tokenizer := tokenizertest.New() + tokenizer := tokenizertest.NewMockTokenizer(t) emailing := emailingtest.New() queryParser := queryparser.New(providerSettings) require.NoError(t, err) diff --git a/pkg/signoz/provider_test.go b/pkg/signoz/provider_test.go index c863cecbd7..58d1365cde 100644 --- a/pkg/signoz/provider_test.go +++ b/pkg/signoz/provider_test.go @@ -78,7 +78,7 @@ func TestNewProviderFactories(t *testing.T) { userGetter := impluser.NewGetter(impluser.NewStore(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual), instrumentationtest.New().ToProviderSettings())) orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)), nil) telemetryStore := telemetrystoretest.New(telemetrystore.Config{Provider: "clickhouse"}, sqlmock.QueryMatcherEqual) - NewStatsReporterProviderFactories(telemetryStore, []statsreporter.StatsCollector{}, orgGetter, userGetter, tokenizertest.New(), version.Build{}, analytics.Config{Enabled: true}) + NewStatsReporterProviderFactories(telemetryStore, []statsreporter.StatsCollector{}, orgGetter, userGetter, tokenizertest.NewMockTokenizer(t), version.Build{}, analytics.Config{Enabled: true}) }) assert.NotPanics(t, func() { diff --git a/pkg/tokenizer/tokenizertest/provider.go b/pkg/tokenizer/tokenizertest/provider.go deleted file mode 100644 index 4a4265a07d..0000000000 --- a/pkg/tokenizer/tokenizertest/provider.go +++ /dev/null @@ -1,76 +0,0 @@ -package tokenizertest - -import ( - "context" - "time" - - "github.com/SigNoz/signoz/pkg/tokenizer" - "github.com/SigNoz/signoz/pkg/types/authtypes" - "github.com/SigNoz/signoz/pkg/valuer" -) - -var _ tokenizer.Tokenizer = (*Provider)(nil) - -type Provider struct { - stopC chan struct{} -} - -func New() *Provider { - return &Provider{stopC: make(chan struct{})} -} - -// Collect implements tokenizer.Tokenizer. -func (provider *Provider) Collect(context.Context, valuer.UUID) (map[string]any, error) { - panic("unimplemented") -} - -// CreateToken implements tokenizer.Tokenizer. -func (provider *Provider) CreateToken(context.Context, *authtypes.Identity, map[string]string) (*authtypes.Token, error) { - panic("unimplemented") -} - -// DeleteToken implements tokenizer.Tokenizer. -func (provider *Provider) DeleteToken(context.Context, string) error { - panic("unimplemented") -} - -// GetIdentity implements tokenizer.Tokenizer. -func (provider *Provider) GetIdentity(context.Context, string) (*authtypes.Identity, error) { - panic("unimplemented") -} - -// RotateToken implements tokenizer.Tokenizer. -func (provider *Provider) RotateToken(context.Context, string, string) (*authtypes.Token, error) { - panic("unimplemented") -} - -// Start implements tokenizer.Tokenizer. -func (provider *Provider) Start(context.Context) error { - panic("unimplemented") -} - -// Stop implements tokenizer.Tokenizer. -func (provider *Provider) Stop(context.Context) error { - close(provider.stopC) - return nil -} - -func (provider *Provider) DeleteIdentity(context.Context, valuer.UUID) error { - panic("unimplemented") -} - -func (provider *Provider) DeleteTokensByUserID(context.Context, valuer.UUID) error { - panic("unimplemented") -} - -func (provider *Provider) Config() tokenizer.Config { - panic("unimplemented") -} - -func (provider *Provider) SetLastObservedAt(context.Context, string, time.Time) error { - panic("unimplemented") -} - -func (provider *Provider) ListMaxLastObservedAtByOrgID(context.Context, valuer.UUID) (map[valuer.UUID]time.Time, error) { - panic("unimplemented") -} diff --git a/pkg/tokenizer/tokenizertest/tokenizer.go b/pkg/tokenizer/tokenizertest/tokenizer.go new file mode 100644 index 0000000000..c90e7096cb --- /dev/null +++ b/pkg/tokenizer/tokenizertest/tokenizer.go @@ -0,0 +1,774 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify + +package tokenizertest + +import ( + "context" + "time" + + "github.com/SigNoz/signoz/pkg/tokenizer" + "github.com/SigNoz/signoz/pkg/types/authtypes" + "github.com/SigNoz/signoz/pkg/valuer" + mock "github.com/stretchr/testify/mock" +) + +// NewMockTokenizer creates a new instance of MockTokenizer. 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 NewMockTokenizer(t interface { + mock.TestingT + Cleanup(func()) +}) *MockTokenizer { + mock := &MockTokenizer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + +// MockTokenizer is an autogenerated mock type for the Tokenizer type +type MockTokenizer struct { + mock.Mock +} + +type MockTokenizer_Expecter struct { + mock *mock.Mock +} + +func (_m *MockTokenizer) EXPECT() *MockTokenizer_Expecter { + return &MockTokenizer_Expecter{mock: &_m.Mock} +} + +// Collect provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) 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 +} + +// MockTokenizer_Collect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Collect' +type MockTokenizer_Collect_Call struct { + *mock.Call +} + +// Collect is a helper method to define mock.On call +// - context1 context.Context +// - uUID valuer.UUID +func (_e *MockTokenizer_Expecter) Collect(context1 interface{}, uUID interface{}) *MockTokenizer_Collect_Call { + return &MockTokenizer_Collect_Call{Call: _e.mock.On("Collect", context1, uUID)} +} + +func (_c *MockTokenizer_Collect_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_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 *MockTokenizer_Collect_Call) Return(stringToV map[string]any, err error) *MockTokenizer_Collect_Call { + _c.Call.Return(stringToV, err) + return _c +} + +func (_c *MockTokenizer_Collect_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (map[string]any, error)) *MockTokenizer_Collect_Call { + _c.Call.Return(run) + return _c +} + +// Config provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) Config() tokenizer.Config { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Config") + } + + var r0 tokenizer.Config + if returnFunc, ok := ret.Get(0).(func() tokenizer.Config); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(tokenizer.Config) + } + return r0 +} + +// MockTokenizer_Config_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Config' +type MockTokenizer_Config_Call struct { + *mock.Call +} + +// Config is a helper method to define mock.On call +func (_e *MockTokenizer_Expecter) Config() *MockTokenizer_Config_Call { + return &MockTokenizer_Config_Call{Call: _e.mock.On("Config")} +} + +func (_c *MockTokenizer_Config_Call) Run(run func()) *MockTokenizer_Config_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTokenizer_Config_Call) Return(config tokenizer.Config) *MockTokenizer_Config_Call { + _c.Call.Return(config) + return _c +} + +func (_c *MockTokenizer_Config_Call) RunAndReturn(run func() tokenizer.Config) *MockTokenizer_Config_Call { + _c.Call.Return(run) + return _c +} + +// CreateToken provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) CreateToken(context1 context.Context, identity *authtypes.Identity, stringToString map[string]string) (*authtypes.Token, error) { + ret := _mock.Called(context1, identity, stringToString) + + if len(ret) == 0 { + panic("no return value specified for CreateToken") + } + + var r0 *authtypes.Token + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *authtypes.Identity, map[string]string) (*authtypes.Token, error)); ok { + return returnFunc(context1, identity, stringToString) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *authtypes.Identity, map[string]string) *authtypes.Token); ok { + r0 = returnFunc(context1, identity, stringToString) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*authtypes.Token) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *authtypes.Identity, map[string]string) error); ok { + r1 = returnFunc(context1, identity, stringToString) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockTokenizer_CreateToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateToken' +type MockTokenizer_CreateToken_Call struct { + *mock.Call +} + +// CreateToken is a helper method to define mock.On call +// - context1 context.Context +// - identity *authtypes.Identity +// - stringToString map[string]string +func (_e *MockTokenizer_Expecter) CreateToken(context1 interface{}, identity interface{}, stringToString interface{}) *MockTokenizer_CreateToken_Call { + return &MockTokenizer_CreateToken_Call{Call: _e.mock.On("CreateToken", context1, identity, stringToString)} +} + +func (_c *MockTokenizer_CreateToken_Call) Run(run func(context1 context.Context, identity *authtypes.Identity, stringToString map[string]string)) *MockTokenizer_CreateToken_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *authtypes.Identity + if args[1] != nil { + arg1 = args[1].(*authtypes.Identity) + } + var arg2 map[string]string + if args[2] != nil { + arg2 = args[2].(map[string]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockTokenizer_CreateToken_Call) Return(token *authtypes.Token, err error) *MockTokenizer_CreateToken_Call { + _c.Call.Return(token, err) + return _c +} + +func (_c *MockTokenizer_CreateToken_Call) RunAndReturn(run func(context1 context.Context, identity *authtypes.Identity, stringToString map[string]string) (*authtypes.Token, error)) *MockTokenizer_CreateToken_Call { + _c.Call.Return(run) + return _c +} + +// DeleteIdentity provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) DeleteIdentity(context1 context.Context, uUID valuer.UUID) error { + ret := _mock.Called(context1, uUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteIdentity") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) error); ok { + r0 = returnFunc(context1, uUID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockTokenizer_DeleteIdentity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteIdentity' +type MockTokenizer_DeleteIdentity_Call struct { + *mock.Call +} + +// DeleteIdentity is a helper method to define mock.On call +// - context1 context.Context +// - uUID valuer.UUID +func (_e *MockTokenizer_Expecter) DeleteIdentity(context1 interface{}, uUID interface{}) *MockTokenizer_DeleteIdentity_Call { + return &MockTokenizer_DeleteIdentity_Call{Call: _e.mock.On("DeleteIdentity", context1, uUID)} +} + +func (_c *MockTokenizer_DeleteIdentity_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_DeleteIdentity_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 *MockTokenizer_DeleteIdentity_Call) Return(err error) *MockTokenizer_DeleteIdentity_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockTokenizer_DeleteIdentity_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) error) *MockTokenizer_DeleteIdentity_Call { + _c.Call.Return(run) + return _c +} + +// DeleteToken provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) DeleteToken(context1 context.Context, s string) error { + ret := _mock.Called(context1, s) + + if len(ret) == 0 { + panic("no return value specified for DeleteToken") + } + + 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 +} + +// MockTokenizer_DeleteToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteToken' +type MockTokenizer_DeleteToken_Call struct { + *mock.Call +} + +// DeleteToken is a helper method to define mock.On call +// - context1 context.Context +// - s string +func (_e *MockTokenizer_Expecter) DeleteToken(context1 interface{}, s interface{}) *MockTokenizer_DeleteToken_Call { + return &MockTokenizer_DeleteToken_Call{Call: _e.mock.On("DeleteToken", context1, s)} +} + +func (_c *MockTokenizer_DeleteToken_Call) Run(run func(context1 context.Context, s string)) *MockTokenizer_DeleteToken_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 *MockTokenizer_DeleteToken_Call) Return(err error) *MockTokenizer_DeleteToken_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockTokenizer_DeleteToken_Call) RunAndReturn(run func(context1 context.Context, s string) error) *MockTokenizer_DeleteToken_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTokensByUserID provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) DeleteTokensByUserID(context1 context.Context, uUID valuer.UUID) error { + ret := _mock.Called(context1, uUID) + + if len(ret) == 0 { + panic("no return value specified for DeleteTokensByUserID") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) error); ok { + r0 = returnFunc(context1, uUID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockTokenizer_DeleteTokensByUserID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTokensByUserID' +type MockTokenizer_DeleteTokensByUserID_Call struct { + *mock.Call +} + +// DeleteTokensByUserID is a helper method to define mock.On call +// - context1 context.Context +// - uUID valuer.UUID +func (_e *MockTokenizer_Expecter) DeleteTokensByUserID(context1 interface{}, uUID interface{}) *MockTokenizer_DeleteTokensByUserID_Call { + return &MockTokenizer_DeleteTokensByUserID_Call{Call: _e.mock.On("DeleteTokensByUserID", context1, uUID)} +} + +func (_c *MockTokenizer_DeleteTokensByUserID_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_DeleteTokensByUserID_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 *MockTokenizer_DeleteTokensByUserID_Call) Return(err error) *MockTokenizer_DeleteTokensByUserID_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockTokenizer_DeleteTokensByUserID_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) error) *MockTokenizer_DeleteTokensByUserID_Call { + _c.Call.Return(run) + return _c +} + +// GetIdentity provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) GetIdentity(context1 context.Context, s string) (*authtypes.Identity, error) { + ret := _mock.Called(context1, s) + + if len(ret) == 0 { + panic("no return value specified for GetIdentity") + } + + var r0 *authtypes.Identity + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string) (*authtypes.Identity, error)); ok { + return returnFunc(context1, s) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string) *authtypes.Identity); ok { + r0 = returnFunc(context1, s) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*authtypes.Identity) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = returnFunc(context1, s) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockTokenizer_GetIdentity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetIdentity' +type MockTokenizer_GetIdentity_Call struct { + *mock.Call +} + +// GetIdentity is a helper method to define mock.On call +// - context1 context.Context +// - s string +func (_e *MockTokenizer_Expecter) GetIdentity(context1 interface{}, s interface{}) *MockTokenizer_GetIdentity_Call { + return &MockTokenizer_GetIdentity_Call{Call: _e.mock.On("GetIdentity", context1, s)} +} + +func (_c *MockTokenizer_GetIdentity_Call) Run(run func(context1 context.Context, s string)) *MockTokenizer_GetIdentity_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 *MockTokenizer_GetIdentity_Call) Return(identity *authtypes.Identity, err error) *MockTokenizer_GetIdentity_Call { + _c.Call.Return(identity, err) + return _c +} + +func (_c *MockTokenizer_GetIdentity_Call) RunAndReturn(run func(context1 context.Context, s string) (*authtypes.Identity, error)) *MockTokenizer_GetIdentity_Call { + _c.Call.Return(run) + return _c +} + +// ListMaxLastObservedAtByOrgID provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) ListMaxLastObservedAtByOrgID(context1 context.Context, uUID valuer.UUID) (map[valuer.UUID]time.Time, error) { + ret := _mock.Called(context1, uUID) + + if len(ret) == 0 { + panic("no return value specified for ListMaxLastObservedAtByOrgID") + } + + var r0 map[valuer.UUID]time.Time + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) (map[valuer.UUID]time.Time, error)); ok { + return returnFunc(context1, uUID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) map[valuer.UUID]time.Time); ok { + r0 = returnFunc(context1, uUID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(map[valuer.UUID]time.Time) + } + } + 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 +} + +// MockTokenizer_ListMaxLastObservedAtByOrgID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMaxLastObservedAtByOrgID' +type MockTokenizer_ListMaxLastObservedAtByOrgID_Call struct { + *mock.Call +} + +// ListMaxLastObservedAtByOrgID is a helper method to define mock.On call +// - context1 context.Context +// - uUID valuer.UUID +func (_e *MockTokenizer_Expecter) ListMaxLastObservedAtByOrgID(context1 interface{}, uUID interface{}) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call { + return &MockTokenizer_ListMaxLastObservedAtByOrgID_Call{Call: _e.mock.On("ListMaxLastObservedAtByOrgID", context1, uUID)} +} + +func (_c *MockTokenizer_ListMaxLastObservedAtByOrgID_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_ListMaxLastObservedAtByOrgID_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 *MockTokenizer_ListMaxLastObservedAtByOrgID_Call) Return(uUIDToTime map[valuer.UUID]time.Time, err error) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call { + _c.Call.Return(uUIDToTime, err) + return _c +} + +func (_c *MockTokenizer_ListMaxLastObservedAtByOrgID_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (map[valuer.UUID]time.Time, error)) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call { + _c.Call.Return(run) + return _c +} + +// RotateToken provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) RotateToken(context1 context.Context, s string, s1 string) (*authtypes.Token, error) { + ret := _mock.Called(context1, s, s1) + + if len(ret) == 0 { + panic("no return value specified for RotateToken") + } + + var r0 *authtypes.Token + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*authtypes.Token, error)); ok { + return returnFunc(context1, s, s1) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *authtypes.Token); ok { + r0 = returnFunc(context1, s, s1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*authtypes.Token) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = returnFunc(context1, s, s1) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// MockTokenizer_RotateToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RotateToken' +type MockTokenizer_RotateToken_Call struct { + *mock.Call +} + +// RotateToken is a helper method to define mock.On call +// - context1 context.Context +// - s string +// - s1 string +func (_e *MockTokenizer_Expecter) RotateToken(context1 interface{}, s interface{}, s1 interface{}) *MockTokenizer_RotateToken_Call { + return &MockTokenizer_RotateToken_Call{Call: _e.mock.On("RotateToken", context1, s, s1)} +} + +func (_c *MockTokenizer_RotateToken_Call) Run(run func(context1 context.Context, s string, s1 string)) *MockTokenizer_RotateToken_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) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockTokenizer_RotateToken_Call) Return(token *authtypes.Token, err error) *MockTokenizer_RotateToken_Call { + _c.Call.Return(token, err) + return _c +} + +func (_c *MockTokenizer_RotateToken_Call) RunAndReturn(run func(context1 context.Context, s string, s1 string) (*authtypes.Token, error)) *MockTokenizer_RotateToken_Call { + _c.Call.Return(run) + return _c +} + +// SetLastObservedAt provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) SetLastObservedAt(context1 context.Context, s string, time1 time.Time) error { + ret := _mock.Called(context1, s, time1) + + if len(ret) == 0 { + panic("no return value specified for SetLastObservedAt") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time) error); ok { + r0 = returnFunc(context1, s, time1) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// MockTokenizer_SetLastObservedAt_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLastObservedAt' +type MockTokenizer_SetLastObservedAt_Call struct { + *mock.Call +} + +// SetLastObservedAt is a helper method to define mock.On call +// - context1 context.Context +// - s string +// - time1 time.Time +func (_e *MockTokenizer_Expecter) SetLastObservedAt(context1 interface{}, s interface{}, time1 interface{}) *MockTokenizer_SetLastObservedAt_Call { + return &MockTokenizer_SetLastObservedAt_Call{Call: _e.mock.On("SetLastObservedAt", context1, s, time1)} +} + +func (_c *MockTokenizer_SetLastObservedAt_Call) Run(run func(context1 context.Context, s string, time1 time.Time)) *MockTokenizer_SetLastObservedAt_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 time.Time + if args[2] != nil { + arg2 = args[2].(time.Time) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *MockTokenizer_SetLastObservedAt_Call) Return(err error) *MockTokenizer_SetLastObservedAt_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockTokenizer_SetLastObservedAt_Call) RunAndReturn(run func(context1 context.Context, s string, time1 time.Time) error) *MockTokenizer_SetLastObservedAt_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) 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 +} + +// MockTokenizer_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type MockTokenizer_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - context1 context.Context +func (_e *MockTokenizer_Expecter) Start(context1 interface{}) *MockTokenizer_Start_Call { + return &MockTokenizer_Start_Call{Call: _e.mock.On("Start", context1)} +} + +func (_c *MockTokenizer_Start_Call) Run(run func(context1 context.Context)) *MockTokenizer_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 *MockTokenizer_Start_Call) Return(err error) *MockTokenizer_Start_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockTokenizer_Start_Call) RunAndReturn(run func(context1 context.Context) error) *MockTokenizer_Start_Call { + _c.Call.Return(run) + return _c +} + +// Stop provides a mock function for the type MockTokenizer +func (_mock *MockTokenizer) 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 +} + +// MockTokenizer_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type MockTokenizer_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +// - context1 context.Context +func (_e *MockTokenizer_Expecter) Stop(context1 interface{}) *MockTokenizer_Stop_Call { + return &MockTokenizer_Stop_Call{Call: _e.mock.On("Stop", context1)} +} + +func (_c *MockTokenizer_Stop_Call) Run(run func(context1 context.Context)) *MockTokenizer_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 *MockTokenizer_Stop_Call) Return(err error) *MockTokenizer_Stop_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockTokenizer_Stop_Call) RunAndReturn(run func(context1 context.Context) error) *MockTokenizer_Stop_Call { + _c.Call.Return(run) + return _c +}