Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

22.9 KB
Raw Blame
// 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
}