test: add mocks for tokenizer (#10081)

## Description

- add mocks for tokenizer
- rename mocks in alertmanager to alertmanagertest
- add makefile command for generating mocks

.mockery.yml

@@ -4,7 +4,14 @@ packages:
   github.com/SigNoz/signoz/pkg/alertmanager:
     config:
       all: true
-      dir: '{{.InterfaceDir}}/mocks'
+      dir: '{{.InterfaceDir}}/alertmanagertest'
-      filename: "mocks.go"
+      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'

.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"
+	}
 }

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

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"

pkg/alertmanager/alertmanagertest/alertmanager.go

@@ -2,7 +2,7 @@
 // github.com/vektra/mockery
 // template: testify
 
-package alertmanagermock
+package alertmanagertest
 
 import (
 	"context"

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"

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"

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)

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)

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() {

pkg/tokenizer/tokenizertest/provider.go

@@ -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")
-}

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
+}