add service

internal/mocks/invite_service_mock.go

@@ -0,0 +1,836 @@
+// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.
+
+package mocks
+
+//go:generate minimock -i smart-search-back/internal/service.InviteService -o invite_service_mock.go -n InviteServiceMock -p mocks
+
+import (
+	"context"
+	"smart-search-back/internal/model"
+	"sync"
+	mm_atomic "sync/atomic"
+	mm_time "time"
+
+	"github.com/gojuno/minimock/v3"
+)
+
+// InviteServiceMock implements mm_service.InviteService
+type InviteServiceMock struct {
+	t          minimock.Tester
+	finishOnce sync.Once
+
+	funcGenerate          func(ctx context.Context, userID int, maxUses int, ttlDays int) (ip1 *model.InviteCode, err error)
+	funcGenerateOrigin    string
+	inspectFuncGenerate   func(ctx context.Context, userID int, maxUses int, ttlDays int)
+	afterGenerateCounter  uint64
+	beforeGenerateCounter uint64
+	GenerateMock          mInviteServiceMockGenerate
+
+	funcGetInfo          func(ctx context.Context, code int64) (ip1 *model.InviteCode, err error)
+	funcGetInfoOrigin    string
+	inspectFuncGetInfo   func(ctx context.Context, code int64)
+	afterGetInfoCounter  uint64
+	beforeGetInfoCounter uint64
+	GetInfoMock          mInviteServiceMockGetInfo
+}
+
+// NewInviteServiceMock returns a mock for mm_service.InviteService
+func NewInviteServiceMock(t minimock.Tester) *InviteServiceMock {
+	m := &InviteServiceMock{t: t}
+
+	if controller, ok := t.(minimock.MockController); ok {
+		controller.RegisterMocker(m)
+	}
+
+	m.GenerateMock = mInviteServiceMockGenerate{mock: m}
+	m.GenerateMock.callArgs = []*InviteServiceMockGenerateParams{}
+
+	m.GetInfoMock = mInviteServiceMockGetInfo{mock: m}
+	m.GetInfoMock.callArgs = []*InviteServiceMockGetInfoParams{}
+
+	t.Cleanup(m.MinimockFinish)
+
+	return m
+}
+
+type mInviteServiceMockGenerate struct {
+	optional           bool
+	mock               *InviteServiceMock
+	defaultExpectation *InviteServiceMockGenerateExpectation
+	expectations       []*InviteServiceMockGenerateExpectation
+
+	callArgs []*InviteServiceMockGenerateParams
+	mutex    sync.RWMutex
+
+	expectedInvocations       uint64
+	expectedInvocationsOrigin string
+}
+
+// InviteServiceMockGenerateExpectation specifies expectation struct of the InviteService.Generate
+type InviteServiceMockGenerateExpectation struct {
+	mock               *InviteServiceMock
+	params             *InviteServiceMockGenerateParams
+	paramPtrs          *InviteServiceMockGenerateParamPtrs
+	expectationOrigins InviteServiceMockGenerateExpectationOrigins
+	results            *InviteServiceMockGenerateResults
+	returnOrigin       string
+	Counter            uint64
+}
+
+// InviteServiceMockGenerateParams contains parameters of the InviteService.Generate
+type InviteServiceMockGenerateParams struct {
+	ctx     context.Context
+	userID  int
+	maxUses int
+	ttlDays int
+}
+
+// InviteServiceMockGenerateParamPtrs contains pointers to parameters of the InviteService.Generate
+type InviteServiceMockGenerateParamPtrs struct {
+	ctx     *context.Context
+	userID  *int
+	maxUses *int
+	ttlDays *int
+}
+
+// InviteServiceMockGenerateResults contains results of the InviteService.Generate
+type InviteServiceMockGenerateResults struct {
+	ip1 *model.InviteCode
+	err error
+}
+
+// InviteServiceMockGenerateOrigins contains origins of expectations of the InviteService.Generate
+type InviteServiceMockGenerateExpectationOrigins struct {
+	origin        string
+	originCtx     string
+	originUserID  string
+	originMaxUses string
+	originTtlDays string
+}
+
+// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
+// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
+// Optional() makes method check to work in '0 or more' mode.
+// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
+// catch the problems when the expected method call is totally skipped during test run.
+func (mmGenerate *mInviteServiceMockGenerate) Optional() *mInviteServiceMockGenerate {
+	mmGenerate.optional = true
+	return mmGenerate
+}
+
+// Expect sets up expected params for InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) Expect(ctx context.Context, userID int, maxUses int, ttlDays int) *mInviteServiceMockGenerate {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	if mmGenerate.defaultExpectation == nil {
+		mmGenerate.defaultExpectation = &InviteServiceMockGenerateExpectation{}
+	}
+
+	if mmGenerate.defaultExpectation.paramPtrs != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by ExpectParams functions")
+	}
+
+	mmGenerate.defaultExpectation.params = &InviteServiceMockGenerateParams{ctx, userID, maxUses, ttlDays}
+	mmGenerate.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
+	for _, e := range mmGenerate.expectations {
+		if minimock.Equal(e.params, mmGenerate.defaultExpectation.params) {
+			mmGenerate.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGenerate.defaultExpectation.params)
+		}
+	}
+
+	return mmGenerate
+}
+
+// ExpectCtxParam1 sets up expected param ctx for InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) ExpectCtxParam1(ctx context.Context) *mInviteServiceMockGenerate {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	if mmGenerate.defaultExpectation == nil {
+		mmGenerate.defaultExpectation = &InviteServiceMockGenerateExpectation{}
+	}
+
+	if mmGenerate.defaultExpectation.params != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Expect")
+	}
+
+	if mmGenerate.defaultExpectation.paramPtrs == nil {
+		mmGenerate.defaultExpectation.paramPtrs = &InviteServiceMockGenerateParamPtrs{}
+	}
+	mmGenerate.defaultExpectation.paramPtrs.ctx = &ctx
+	mmGenerate.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
+
+	return mmGenerate
+}
+
+// ExpectUserIDParam2 sets up expected param userID for InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) ExpectUserIDParam2(userID int) *mInviteServiceMockGenerate {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	if mmGenerate.defaultExpectation == nil {
+		mmGenerate.defaultExpectation = &InviteServiceMockGenerateExpectation{}
+	}
+
+	if mmGenerate.defaultExpectation.params != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Expect")
+	}
+
+	if mmGenerate.defaultExpectation.paramPtrs == nil {
+		mmGenerate.defaultExpectation.paramPtrs = &InviteServiceMockGenerateParamPtrs{}
+	}
+	mmGenerate.defaultExpectation.paramPtrs.userID = &userID
+	mmGenerate.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
+
+	return mmGenerate
+}
+
+// ExpectMaxUsesParam3 sets up expected param maxUses for InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) ExpectMaxUsesParam3(maxUses int) *mInviteServiceMockGenerate {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	if mmGenerate.defaultExpectation == nil {
+		mmGenerate.defaultExpectation = &InviteServiceMockGenerateExpectation{}
+	}
+
+	if mmGenerate.defaultExpectation.params != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Expect")
+	}
+
+	if mmGenerate.defaultExpectation.paramPtrs == nil {
+		mmGenerate.defaultExpectation.paramPtrs = &InviteServiceMockGenerateParamPtrs{}
+	}
+	mmGenerate.defaultExpectation.paramPtrs.maxUses = &maxUses
+	mmGenerate.defaultExpectation.expectationOrigins.originMaxUses = minimock.CallerInfo(1)
+
+	return mmGenerate
+}
+
+// ExpectTtlDaysParam4 sets up expected param ttlDays for InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) ExpectTtlDaysParam4(ttlDays int) *mInviteServiceMockGenerate {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	if mmGenerate.defaultExpectation == nil {
+		mmGenerate.defaultExpectation = &InviteServiceMockGenerateExpectation{}
+	}
+
+	if mmGenerate.defaultExpectation.params != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Expect")
+	}
+
+	if mmGenerate.defaultExpectation.paramPtrs == nil {
+		mmGenerate.defaultExpectation.paramPtrs = &InviteServiceMockGenerateParamPtrs{}
+	}
+	mmGenerate.defaultExpectation.paramPtrs.ttlDays = &ttlDays
+	mmGenerate.defaultExpectation.expectationOrigins.originTtlDays = minimock.CallerInfo(1)
+
+	return mmGenerate
+}
+
+// Inspect accepts an inspector function that has same arguments as the InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) Inspect(f func(ctx context.Context, userID int, maxUses int, ttlDays int)) *mInviteServiceMockGenerate {
+	if mmGenerate.mock.inspectFuncGenerate != nil {
+		mmGenerate.mock.t.Fatalf("Inspect function is already set for InviteServiceMock.Generate")
+	}
+
+	mmGenerate.mock.inspectFuncGenerate = f
+
+	return mmGenerate
+}
+
+// Return sets up results that will be returned by InviteService.Generate
+func (mmGenerate *mInviteServiceMockGenerate) Return(ip1 *model.InviteCode, err error) *InviteServiceMock {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	if mmGenerate.defaultExpectation == nil {
+		mmGenerate.defaultExpectation = &InviteServiceMockGenerateExpectation{mock: mmGenerate.mock}
+	}
+	mmGenerate.defaultExpectation.results = &InviteServiceMockGenerateResults{ip1, err}
+	mmGenerate.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
+	return mmGenerate.mock
+}
+
+// Set uses given function f to mock the InviteService.Generate method
+func (mmGenerate *mInviteServiceMockGenerate) Set(f func(ctx context.Context, userID int, maxUses int, ttlDays int) (ip1 *model.InviteCode, err error)) *InviteServiceMock {
+	if mmGenerate.defaultExpectation != nil {
+		mmGenerate.mock.t.Fatalf("Default expectation is already set for the InviteService.Generate method")
+	}
+
+	if len(mmGenerate.expectations) > 0 {
+		mmGenerate.mock.t.Fatalf("Some expectations are already set for the InviteService.Generate method")
+	}
+
+	mmGenerate.mock.funcGenerate = f
+	mmGenerate.mock.funcGenerateOrigin = minimock.CallerInfo(1)
+	return mmGenerate.mock
+}
+
+// When sets expectation for the InviteService.Generate which will trigger the result defined by the following
+// Then helper
+func (mmGenerate *mInviteServiceMockGenerate) When(ctx context.Context, userID int, maxUses int, ttlDays int) *InviteServiceMockGenerateExpectation {
+	if mmGenerate.mock.funcGenerate != nil {
+		mmGenerate.mock.t.Fatalf("InviteServiceMock.Generate mock is already set by Set")
+	}
+
+	expectation := &InviteServiceMockGenerateExpectation{
+		mock:               mmGenerate.mock,
+		params:             &InviteServiceMockGenerateParams{ctx, userID, maxUses, ttlDays},
+		expectationOrigins: InviteServiceMockGenerateExpectationOrigins{origin: minimock.CallerInfo(1)},
+	}
+	mmGenerate.expectations = append(mmGenerate.expectations, expectation)
+	return expectation
+}
+
+// Then sets up InviteService.Generate return parameters for the expectation previously defined by the When method
+func (e *InviteServiceMockGenerateExpectation) Then(ip1 *model.InviteCode, err error) *InviteServiceMock {
+	e.results = &InviteServiceMockGenerateResults{ip1, err}
+	return e.mock
+}
+
+// Times sets number of times InviteService.Generate should be invoked
+func (mmGenerate *mInviteServiceMockGenerate) Times(n uint64) *mInviteServiceMockGenerate {
+	if n == 0 {
+		mmGenerate.mock.t.Fatalf("Times of InviteServiceMock.Generate mock can not be zero")
+	}
+	mm_atomic.StoreUint64(&mmGenerate.expectedInvocations, n)
+	mmGenerate.expectedInvocationsOrigin = minimock.CallerInfo(1)
+	return mmGenerate
+}
+
+func (mmGenerate *mInviteServiceMockGenerate) invocationsDone() bool {
+	if len(mmGenerate.expectations) == 0 && mmGenerate.defaultExpectation == nil && mmGenerate.mock.funcGenerate == nil {
+		return true
+	}
+
+	totalInvocations := mm_atomic.LoadUint64(&mmGenerate.mock.afterGenerateCounter)
+	expectedInvocations := mm_atomic.LoadUint64(&mmGenerate.expectedInvocations)
+
+	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
+}
+
+// Generate implements mm_service.InviteService
+func (mmGenerate *InviteServiceMock) Generate(ctx context.Context, userID int, maxUses int, ttlDays int) (ip1 *model.InviteCode, err error) {
+	mm_atomic.AddUint64(&mmGenerate.beforeGenerateCounter, 1)
+	defer mm_atomic.AddUint64(&mmGenerate.afterGenerateCounter, 1)
+
+	mmGenerate.t.Helper()
+
+	if mmGenerate.inspectFuncGenerate != nil {
+		mmGenerate.inspectFuncGenerate(ctx, userID, maxUses, ttlDays)
+	}
+
+	mm_params := InviteServiceMockGenerateParams{ctx, userID, maxUses, ttlDays}
+
+	// Record call args
+	mmGenerate.GenerateMock.mutex.Lock()
+	mmGenerate.GenerateMock.callArgs = append(mmGenerate.GenerateMock.callArgs, &mm_params)
+	mmGenerate.GenerateMock.mutex.Unlock()
+
+	for _, e := range mmGenerate.GenerateMock.expectations {
+		if minimock.Equal(*e.params, mm_params) {
+			mm_atomic.AddUint64(&e.Counter, 1)
+			return e.results.ip1, e.results.err
+		}
+	}
+
+	if mmGenerate.GenerateMock.defaultExpectation != nil {
+		mm_atomic.AddUint64(&mmGenerate.GenerateMock.defaultExpectation.Counter, 1)
+		mm_want := mmGenerate.GenerateMock.defaultExpectation.params
+		mm_want_ptrs := mmGenerate.GenerateMock.defaultExpectation.paramPtrs
+
+		mm_got := InviteServiceMockGenerateParams{ctx, userID, maxUses, ttlDays}
+
+		if mm_want_ptrs != nil {
+
+			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
+				mmGenerate.t.Errorf("InviteServiceMock.Generate got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGenerate.GenerateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
+			}
+
+			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
+				mmGenerate.t.Errorf("InviteServiceMock.Generate got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGenerate.GenerateMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
+			}
+
+			if mm_want_ptrs.maxUses != nil && !minimock.Equal(*mm_want_ptrs.maxUses, mm_got.maxUses) {
+				mmGenerate.t.Errorf("InviteServiceMock.Generate got unexpected parameter maxUses, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGenerate.GenerateMock.defaultExpectation.expectationOrigins.originMaxUses, *mm_want_ptrs.maxUses, mm_got.maxUses, minimock.Diff(*mm_want_ptrs.maxUses, mm_got.maxUses))
+			}
+
+			if mm_want_ptrs.ttlDays != nil && !minimock.Equal(*mm_want_ptrs.ttlDays, mm_got.ttlDays) {
+				mmGenerate.t.Errorf("InviteServiceMock.Generate got unexpected parameter ttlDays, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGenerate.GenerateMock.defaultExpectation.expectationOrigins.originTtlDays, *mm_want_ptrs.ttlDays, mm_got.ttlDays, minimock.Diff(*mm_want_ptrs.ttlDays, mm_got.ttlDays))
+			}
+
+		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
+			mmGenerate.t.Errorf("InviteServiceMock.Generate got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+				mmGenerate.GenerateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
+		}
+
+		mm_results := mmGenerate.GenerateMock.defaultExpectation.results
+		if mm_results == nil {
+			mmGenerate.t.Fatal("No results are set for the InviteServiceMock.Generate")
+		}
+		return (*mm_results).ip1, (*mm_results).err
+	}
+	if mmGenerate.funcGenerate != nil {
+		return mmGenerate.funcGenerate(ctx, userID, maxUses, ttlDays)
+	}
+	mmGenerate.t.Fatalf("Unexpected call to InviteServiceMock.Generate. %v %v %v %v", ctx, userID, maxUses, ttlDays)
+	return
+}
+
+// GenerateAfterCounter returns a count of finished InviteServiceMock.Generate invocations
+func (mmGenerate *InviteServiceMock) GenerateAfterCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmGenerate.afterGenerateCounter)
+}
+
+// GenerateBeforeCounter returns a count of InviteServiceMock.Generate invocations
+func (mmGenerate *InviteServiceMock) GenerateBeforeCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmGenerate.beforeGenerateCounter)
+}
+
+// Calls returns a list of arguments used in each call to InviteServiceMock.Generate.
+// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
+func (mmGenerate *mInviteServiceMockGenerate) Calls() []*InviteServiceMockGenerateParams {
+	mmGenerate.mutex.RLock()
+
+	argCopy := make([]*InviteServiceMockGenerateParams, len(mmGenerate.callArgs))
+	copy(argCopy, mmGenerate.callArgs)
+
+	mmGenerate.mutex.RUnlock()
+
+	return argCopy
+}
+
+// MinimockGenerateDone returns true if the count of the Generate invocations corresponds
+// the number of defined expectations
+func (m *InviteServiceMock) MinimockGenerateDone() bool {
+	if m.GenerateMock.optional {
+		// Optional methods provide '0 or more' call count restriction.
+		return true
+	}
+
+	for _, e := range m.GenerateMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			return false
+		}
+	}
+
+	return m.GenerateMock.invocationsDone()
+}
+
+// MinimockGenerateInspect logs each unmet expectation
+func (m *InviteServiceMock) MinimockGenerateInspect() {
+	for _, e := range m.GenerateMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			m.t.Errorf("Expected call to InviteServiceMock.Generate at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
+		}
+	}
+
+	afterGenerateCounter := mm_atomic.LoadUint64(&m.afterGenerateCounter)
+	// if default expectation was set then invocations count should be greater than zero
+	if m.GenerateMock.defaultExpectation != nil && afterGenerateCounter < 1 {
+		if m.GenerateMock.defaultExpectation.params == nil {
+			m.t.Errorf("Expected call to InviteServiceMock.Generate at\n%s", m.GenerateMock.defaultExpectation.returnOrigin)
+		} else {
+			m.t.Errorf("Expected call to InviteServiceMock.Generate at\n%s with params: %#v", m.GenerateMock.defaultExpectation.expectationOrigins.origin, *m.GenerateMock.defaultExpectation.params)
+		}
+	}
+	// if func was set then invocations count should be greater than zero
+	if m.funcGenerate != nil && afterGenerateCounter < 1 {
+		m.t.Errorf("Expected call to InviteServiceMock.Generate at\n%s", m.funcGenerateOrigin)
+	}
+
+	if !m.GenerateMock.invocationsDone() && afterGenerateCounter > 0 {
+		m.t.Errorf("Expected %d calls to InviteServiceMock.Generate at\n%s but found %d calls",
+			mm_atomic.LoadUint64(&m.GenerateMock.expectedInvocations), m.GenerateMock.expectedInvocationsOrigin, afterGenerateCounter)
+	}
+}
+
+type mInviteServiceMockGetInfo struct {
+	optional           bool
+	mock               *InviteServiceMock
+	defaultExpectation *InviteServiceMockGetInfoExpectation
+	expectations       []*InviteServiceMockGetInfoExpectation
+
+	callArgs []*InviteServiceMockGetInfoParams
+	mutex    sync.RWMutex
+
+	expectedInvocations       uint64
+	expectedInvocationsOrigin string
+}
+
+// InviteServiceMockGetInfoExpectation specifies expectation struct of the InviteService.GetInfo
+type InviteServiceMockGetInfoExpectation struct {
+	mock               *InviteServiceMock
+	params             *InviteServiceMockGetInfoParams
+	paramPtrs          *InviteServiceMockGetInfoParamPtrs
+	expectationOrigins InviteServiceMockGetInfoExpectationOrigins
+	results            *InviteServiceMockGetInfoResults
+	returnOrigin       string
+	Counter            uint64
+}
+
+// InviteServiceMockGetInfoParams contains parameters of the InviteService.GetInfo
+type InviteServiceMockGetInfoParams struct {
+	ctx  context.Context
+	code int64
+}
+
+// InviteServiceMockGetInfoParamPtrs contains pointers to parameters of the InviteService.GetInfo
+type InviteServiceMockGetInfoParamPtrs struct {
+	ctx  *context.Context
+	code *int64
+}
+
+// InviteServiceMockGetInfoResults contains results of the InviteService.GetInfo
+type InviteServiceMockGetInfoResults struct {
+	ip1 *model.InviteCode
+	err error
+}
+
+// InviteServiceMockGetInfoOrigins contains origins of expectations of the InviteService.GetInfo
+type InviteServiceMockGetInfoExpectationOrigins struct {
+	origin     string
+	originCtx  string
+	originCode string
+}
+
+// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
+// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
+// Optional() makes method check to work in '0 or more' mode.
+// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
+// catch the problems when the expected method call is totally skipped during test run.
+func (mmGetInfo *mInviteServiceMockGetInfo) Optional() *mInviteServiceMockGetInfo {
+	mmGetInfo.optional = true
+	return mmGetInfo
+}
+
+// Expect sets up expected params for InviteService.GetInfo
+func (mmGetInfo *mInviteServiceMockGetInfo) Expect(ctx context.Context, code int64) *mInviteServiceMockGetInfo {
+	if mmGetInfo.mock.funcGetInfo != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Set")
+	}
+
+	if mmGetInfo.defaultExpectation == nil {
+		mmGetInfo.defaultExpectation = &InviteServiceMockGetInfoExpectation{}
+	}
+
+	if mmGetInfo.defaultExpectation.paramPtrs != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by ExpectParams functions")
+	}
+
+	mmGetInfo.defaultExpectation.params = &InviteServiceMockGetInfoParams{ctx, code}
+	mmGetInfo.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
+	for _, e := range mmGetInfo.expectations {
+		if minimock.Equal(e.params, mmGetInfo.defaultExpectation.params) {
+			mmGetInfo.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetInfo.defaultExpectation.params)
+		}
+	}
+
+	return mmGetInfo
+}
+
+// ExpectCtxParam1 sets up expected param ctx for InviteService.GetInfo
+func (mmGetInfo *mInviteServiceMockGetInfo) ExpectCtxParam1(ctx context.Context) *mInviteServiceMockGetInfo {
+	if mmGetInfo.mock.funcGetInfo != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Set")
+	}
+
+	if mmGetInfo.defaultExpectation == nil {
+		mmGetInfo.defaultExpectation = &InviteServiceMockGetInfoExpectation{}
+	}
+
+	if mmGetInfo.defaultExpectation.params != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Expect")
+	}
+
+	if mmGetInfo.defaultExpectation.paramPtrs == nil {
+		mmGetInfo.defaultExpectation.paramPtrs = &InviteServiceMockGetInfoParamPtrs{}
+	}
+	mmGetInfo.defaultExpectation.paramPtrs.ctx = &ctx
+	mmGetInfo.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
+
+	return mmGetInfo
+}
+
+// ExpectCodeParam2 sets up expected param code for InviteService.GetInfo
+func (mmGetInfo *mInviteServiceMockGetInfo) ExpectCodeParam2(code int64) *mInviteServiceMockGetInfo {
+	if mmGetInfo.mock.funcGetInfo != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Set")
+	}
+
+	if mmGetInfo.defaultExpectation == nil {
+		mmGetInfo.defaultExpectation = &InviteServiceMockGetInfoExpectation{}
+	}
+
+	if mmGetInfo.defaultExpectation.params != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Expect")
+	}
+
+	if mmGetInfo.defaultExpectation.paramPtrs == nil {
+		mmGetInfo.defaultExpectation.paramPtrs = &InviteServiceMockGetInfoParamPtrs{}
+	}
+	mmGetInfo.defaultExpectation.paramPtrs.code = &code
+	mmGetInfo.defaultExpectation.expectationOrigins.originCode = minimock.CallerInfo(1)
+
+	return mmGetInfo
+}
+
+// Inspect accepts an inspector function that has same arguments as the InviteService.GetInfo
+func (mmGetInfo *mInviteServiceMockGetInfo) Inspect(f func(ctx context.Context, code int64)) *mInviteServiceMockGetInfo {
+	if mmGetInfo.mock.inspectFuncGetInfo != nil {
+		mmGetInfo.mock.t.Fatalf("Inspect function is already set for InviteServiceMock.GetInfo")
+	}
+
+	mmGetInfo.mock.inspectFuncGetInfo = f
+
+	return mmGetInfo
+}
+
+// Return sets up results that will be returned by InviteService.GetInfo
+func (mmGetInfo *mInviteServiceMockGetInfo) Return(ip1 *model.InviteCode, err error) *InviteServiceMock {
+	if mmGetInfo.mock.funcGetInfo != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Set")
+	}
+
+	if mmGetInfo.defaultExpectation == nil {
+		mmGetInfo.defaultExpectation = &InviteServiceMockGetInfoExpectation{mock: mmGetInfo.mock}
+	}
+	mmGetInfo.defaultExpectation.results = &InviteServiceMockGetInfoResults{ip1, err}
+	mmGetInfo.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
+	return mmGetInfo.mock
+}
+
+// Set uses given function f to mock the InviteService.GetInfo method
+func (mmGetInfo *mInviteServiceMockGetInfo) Set(f func(ctx context.Context, code int64) (ip1 *model.InviteCode, err error)) *InviteServiceMock {
+	if mmGetInfo.defaultExpectation != nil {
+		mmGetInfo.mock.t.Fatalf("Default expectation is already set for the InviteService.GetInfo method")
+	}
+
+	if len(mmGetInfo.expectations) > 0 {
+		mmGetInfo.mock.t.Fatalf("Some expectations are already set for the InviteService.GetInfo method")
+	}
+
+	mmGetInfo.mock.funcGetInfo = f
+	mmGetInfo.mock.funcGetInfoOrigin = minimock.CallerInfo(1)
+	return mmGetInfo.mock
+}
+
+// When sets expectation for the InviteService.GetInfo which will trigger the result defined by the following
+// Then helper
+func (mmGetInfo *mInviteServiceMockGetInfo) When(ctx context.Context, code int64) *InviteServiceMockGetInfoExpectation {
+	if mmGetInfo.mock.funcGetInfo != nil {
+		mmGetInfo.mock.t.Fatalf("InviteServiceMock.GetInfo mock is already set by Set")
+	}
+
+	expectation := &InviteServiceMockGetInfoExpectation{
+		mock:               mmGetInfo.mock,
+		params:             &InviteServiceMockGetInfoParams{ctx, code},
+		expectationOrigins: InviteServiceMockGetInfoExpectationOrigins{origin: minimock.CallerInfo(1)},
+	}
+	mmGetInfo.expectations = append(mmGetInfo.expectations, expectation)
+	return expectation
+}
+
+// Then sets up InviteService.GetInfo return parameters for the expectation previously defined by the When method
+func (e *InviteServiceMockGetInfoExpectation) Then(ip1 *model.InviteCode, err error) *InviteServiceMock {
+	e.results = &InviteServiceMockGetInfoResults{ip1, err}
+	return e.mock
+}
+
+// Times sets number of times InviteService.GetInfo should be invoked
+func (mmGetInfo *mInviteServiceMockGetInfo) Times(n uint64) *mInviteServiceMockGetInfo {
+	if n == 0 {
+		mmGetInfo.mock.t.Fatalf("Times of InviteServiceMock.GetInfo mock can not be zero")
+	}
+	mm_atomic.StoreUint64(&mmGetInfo.expectedInvocations, n)
+	mmGetInfo.expectedInvocationsOrigin = minimock.CallerInfo(1)
+	return mmGetInfo
+}
+
+func (mmGetInfo *mInviteServiceMockGetInfo) invocationsDone() bool {
+	if len(mmGetInfo.expectations) == 0 && mmGetInfo.defaultExpectation == nil && mmGetInfo.mock.funcGetInfo == nil {
+		return true
+	}
+
+	totalInvocations := mm_atomic.LoadUint64(&mmGetInfo.mock.afterGetInfoCounter)
+	expectedInvocations := mm_atomic.LoadUint64(&mmGetInfo.expectedInvocations)
+
+	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
+}
+
+// GetInfo implements mm_service.InviteService
+func (mmGetInfo *InviteServiceMock) GetInfo(ctx context.Context, code int64) (ip1 *model.InviteCode, err error) {
+	mm_atomic.AddUint64(&mmGetInfo.beforeGetInfoCounter, 1)
+	defer mm_atomic.AddUint64(&mmGetInfo.afterGetInfoCounter, 1)
+
+	mmGetInfo.t.Helper()
+
+	if mmGetInfo.inspectFuncGetInfo != nil {
+		mmGetInfo.inspectFuncGetInfo(ctx, code)
+	}
+
+	mm_params := InviteServiceMockGetInfoParams{ctx, code}
+
+	// Record call args
+	mmGetInfo.GetInfoMock.mutex.Lock()
+	mmGetInfo.GetInfoMock.callArgs = append(mmGetInfo.GetInfoMock.callArgs, &mm_params)
+	mmGetInfo.GetInfoMock.mutex.Unlock()
+
+	for _, e := range mmGetInfo.GetInfoMock.expectations {
+		if minimock.Equal(*e.params, mm_params) {
+			mm_atomic.AddUint64(&e.Counter, 1)
+			return e.results.ip1, e.results.err
+		}
+	}
+
+	if mmGetInfo.GetInfoMock.defaultExpectation != nil {
+		mm_atomic.AddUint64(&mmGetInfo.GetInfoMock.defaultExpectation.Counter, 1)
+		mm_want := mmGetInfo.GetInfoMock.defaultExpectation.params
+		mm_want_ptrs := mmGetInfo.GetInfoMock.defaultExpectation.paramPtrs
+
+		mm_got := InviteServiceMockGetInfoParams{ctx, code}
+
+		if mm_want_ptrs != nil {
+
+			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
+				mmGetInfo.t.Errorf("InviteServiceMock.GetInfo got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetInfo.GetInfoMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
+			}
+
+			if mm_want_ptrs.code != nil && !minimock.Equal(*mm_want_ptrs.code, mm_got.code) {
+				mmGetInfo.t.Errorf("InviteServiceMock.GetInfo got unexpected parameter code, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmGetInfo.GetInfoMock.defaultExpectation.expectationOrigins.originCode, *mm_want_ptrs.code, mm_got.code, minimock.Diff(*mm_want_ptrs.code, mm_got.code))
+			}
+
+		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
+			mmGetInfo.t.Errorf("InviteServiceMock.GetInfo got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+				mmGetInfo.GetInfoMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
+		}
+
+		mm_results := mmGetInfo.GetInfoMock.defaultExpectation.results
+		if mm_results == nil {
+			mmGetInfo.t.Fatal("No results are set for the InviteServiceMock.GetInfo")
+		}
+		return (*mm_results).ip1, (*mm_results).err
+	}
+	if mmGetInfo.funcGetInfo != nil {
+		return mmGetInfo.funcGetInfo(ctx, code)
+	}
+	mmGetInfo.t.Fatalf("Unexpected call to InviteServiceMock.GetInfo. %v %v", ctx, code)
+	return
+}
+
+// GetInfoAfterCounter returns a count of finished InviteServiceMock.GetInfo invocations
+func (mmGetInfo *InviteServiceMock) GetInfoAfterCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmGetInfo.afterGetInfoCounter)
+}
+
+// GetInfoBeforeCounter returns a count of InviteServiceMock.GetInfo invocations
+func (mmGetInfo *InviteServiceMock) GetInfoBeforeCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmGetInfo.beforeGetInfoCounter)
+}
+
+// Calls returns a list of arguments used in each call to InviteServiceMock.GetInfo.
+// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
+func (mmGetInfo *mInviteServiceMockGetInfo) Calls() []*InviteServiceMockGetInfoParams {
+	mmGetInfo.mutex.RLock()
+
+	argCopy := make([]*InviteServiceMockGetInfoParams, len(mmGetInfo.callArgs))
+	copy(argCopy, mmGetInfo.callArgs)
+
+	mmGetInfo.mutex.RUnlock()
+
+	return argCopy
+}
+
+// MinimockGetInfoDone returns true if the count of the GetInfo invocations corresponds
+// the number of defined expectations
+func (m *InviteServiceMock) MinimockGetInfoDone() bool {
+	if m.GetInfoMock.optional {
+		// Optional methods provide '0 or more' call count restriction.
+		return true
+	}
+
+	for _, e := range m.GetInfoMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			return false
+		}
+	}
+
+	return m.GetInfoMock.invocationsDone()
+}
+
+// MinimockGetInfoInspect logs each unmet expectation
+func (m *InviteServiceMock) MinimockGetInfoInspect() {
+	for _, e := range m.GetInfoMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			m.t.Errorf("Expected call to InviteServiceMock.GetInfo at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
+		}
+	}
+
+	afterGetInfoCounter := mm_atomic.LoadUint64(&m.afterGetInfoCounter)
+	// if default expectation was set then invocations count should be greater than zero
+	if m.GetInfoMock.defaultExpectation != nil && afterGetInfoCounter < 1 {
+		if m.GetInfoMock.defaultExpectation.params == nil {
+			m.t.Errorf("Expected call to InviteServiceMock.GetInfo at\n%s", m.GetInfoMock.defaultExpectation.returnOrigin)
+		} else {
+			m.t.Errorf("Expected call to InviteServiceMock.GetInfo at\n%s with params: %#v", m.GetInfoMock.defaultExpectation.expectationOrigins.origin, *m.GetInfoMock.defaultExpectation.params)
+		}
+	}
+	// if func was set then invocations count should be greater than zero
+	if m.funcGetInfo != nil && afterGetInfoCounter < 1 {
+		m.t.Errorf("Expected call to InviteServiceMock.GetInfo at\n%s", m.funcGetInfoOrigin)
+	}
+
+	if !m.GetInfoMock.invocationsDone() && afterGetInfoCounter > 0 {
+		m.t.Errorf("Expected %d calls to InviteServiceMock.GetInfo at\n%s but found %d calls",
+			mm_atomic.LoadUint64(&m.GetInfoMock.expectedInvocations), m.GetInfoMock.expectedInvocationsOrigin, afterGetInfoCounter)
+	}
+}
+
+// MinimockFinish checks that all mocked methods have been called the expected number of times
+func (m *InviteServiceMock) MinimockFinish() {
+	m.finishOnce.Do(func() {
+		if !m.minimockDone() {
+			m.MinimockGenerateInspect()
+
+			m.MinimockGetInfoInspect()
+		}
+	})
+}
+
+// MinimockWait waits for all mocked methods to be called the expected number of times
+func (m *InviteServiceMock) MinimockWait(timeout mm_time.Duration) {
+	timeoutCh := mm_time.After(timeout)
+	for {
+		if m.minimockDone() {
+			return
+		}
+		select {
+		case <-timeoutCh:
+			m.MinimockFinish()
+			return
+		case <-mm_time.After(10 * mm_time.Millisecond):
+		}
+	}
+}
+
+func (m *InviteServiceMock) minimockDone() bool {
+	done := true
+	return done &&
+		m.MinimockGenerateDone() &&
+		m.MinimockGetInfoDone()
+}

internal/mocks/supplier_service_mock.go

@@ -0,0 +1,418 @@
+// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.
+
+package mocks
+
+//go:generate minimock -i smart-search-back/internal/service.SupplierService -o supplier_service_mock.go -n SupplierServiceMock -p mocks
+
+import (
+	"context"
+	"sync"
+	mm_atomic "sync/atomic"
+	mm_time "time"
+
+	"github.com/gojuno/minimock/v3"
+	"github.com/google/uuid"
+)
+
+// SupplierServiceMock implements mm_service.SupplierService
+type SupplierServiceMock struct {
+	t          minimock.Tester
+	finishOnce sync.Once
+
+	funcExportExcel          func(ctx context.Context, requestID uuid.UUID) (ba1 []byte, err error)
+	funcExportExcelOrigin    string
+	inspectFuncExportExcel   func(ctx context.Context, requestID uuid.UUID)
+	afterExportExcelCounter  uint64
+	beforeExportExcelCounter uint64
+	ExportExcelMock          mSupplierServiceMockExportExcel
+}
+
+// NewSupplierServiceMock returns a mock for mm_service.SupplierService
+func NewSupplierServiceMock(t minimock.Tester) *SupplierServiceMock {
+	m := &SupplierServiceMock{t: t}
+
+	if controller, ok := t.(minimock.MockController); ok {
+		controller.RegisterMocker(m)
+	}
+
+	m.ExportExcelMock = mSupplierServiceMockExportExcel{mock: m}
+	m.ExportExcelMock.callArgs = []*SupplierServiceMockExportExcelParams{}
+
+	t.Cleanup(m.MinimockFinish)
+
+	return m
+}
+
+type mSupplierServiceMockExportExcel struct {
+	optional           bool
+	mock               *SupplierServiceMock
+	defaultExpectation *SupplierServiceMockExportExcelExpectation
+	expectations       []*SupplierServiceMockExportExcelExpectation
+
+	callArgs []*SupplierServiceMockExportExcelParams
+	mutex    sync.RWMutex
+
+	expectedInvocations       uint64
+	expectedInvocationsOrigin string
+}
+
+// SupplierServiceMockExportExcelExpectation specifies expectation struct of the SupplierService.ExportExcel
+type SupplierServiceMockExportExcelExpectation struct {
+	mock               *SupplierServiceMock
+	params             *SupplierServiceMockExportExcelParams
+	paramPtrs          *SupplierServiceMockExportExcelParamPtrs
+	expectationOrigins SupplierServiceMockExportExcelExpectationOrigins
+	results            *SupplierServiceMockExportExcelResults
+	returnOrigin       string
+	Counter            uint64
+}
+
+// SupplierServiceMockExportExcelParams contains parameters of the SupplierService.ExportExcel
+type SupplierServiceMockExportExcelParams struct {
+	ctx       context.Context
+	requestID uuid.UUID
+}
+
+// SupplierServiceMockExportExcelParamPtrs contains pointers to parameters of the SupplierService.ExportExcel
+type SupplierServiceMockExportExcelParamPtrs struct {
+	ctx       *context.Context
+	requestID *uuid.UUID
+}
+
+// SupplierServiceMockExportExcelResults contains results of the SupplierService.ExportExcel
+type SupplierServiceMockExportExcelResults struct {
+	ba1 []byte
+	err error
+}
+
+// SupplierServiceMockExportExcelOrigins contains origins of expectations of the SupplierService.ExportExcel
+type SupplierServiceMockExportExcelExpectationOrigins struct {
+	origin          string
+	originCtx       string
+	originRequestID string
+}
+
+// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
+// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
+// Optional() makes method check to work in '0 or more' mode.
+// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
+// catch the problems when the expected method call is totally skipped during test run.
+func (mmExportExcel *mSupplierServiceMockExportExcel) Optional() *mSupplierServiceMockExportExcel {
+	mmExportExcel.optional = true
+	return mmExportExcel
+}
+
+// Expect sets up expected params for SupplierService.ExportExcel
+func (mmExportExcel *mSupplierServiceMockExportExcel) Expect(ctx context.Context, requestID uuid.UUID) *mSupplierServiceMockExportExcel {
+	if mmExportExcel.mock.funcExportExcel != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
+	}
+
+	if mmExportExcel.defaultExpectation == nil {
+		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
+	}
+
+	if mmExportExcel.defaultExpectation.paramPtrs != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by ExpectParams functions")
+	}
+
+	mmExportExcel.defaultExpectation.params = &SupplierServiceMockExportExcelParams{ctx, requestID}
+	mmExportExcel.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
+	for _, e := range mmExportExcel.expectations {
+		if minimock.Equal(e.params, mmExportExcel.defaultExpectation.params) {
+			mmExportExcel.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmExportExcel.defaultExpectation.params)
+		}
+	}
+
+	return mmExportExcel
+}
+
+// ExpectCtxParam1 sets up expected param ctx for SupplierService.ExportExcel
+func (mmExportExcel *mSupplierServiceMockExportExcel) ExpectCtxParam1(ctx context.Context) *mSupplierServiceMockExportExcel {
+	if mmExportExcel.mock.funcExportExcel != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
+	}
+
+	if mmExportExcel.defaultExpectation == nil {
+		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
+	}
+
+	if mmExportExcel.defaultExpectation.params != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Expect")
+	}
+
+	if mmExportExcel.defaultExpectation.paramPtrs == nil {
+		mmExportExcel.defaultExpectation.paramPtrs = &SupplierServiceMockExportExcelParamPtrs{}
+	}
+	mmExportExcel.defaultExpectation.paramPtrs.ctx = &ctx
+	mmExportExcel.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
+
+	return mmExportExcel
+}
+
+// ExpectRequestIDParam2 sets up expected param requestID for SupplierService.ExportExcel
+func (mmExportExcel *mSupplierServiceMockExportExcel) ExpectRequestIDParam2(requestID uuid.UUID) *mSupplierServiceMockExportExcel {
+	if mmExportExcel.mock.funcExportExcel != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
+	}
+
+	if mmExportExcel.defaultExpectation == nil {
+		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
+	}
+
+	if mmExportExcel.defaultExpectation.params != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Expect")
+	}
+
+	if mmExportExcel.defaultExpectation.paramPtrs == nil {
+		mmExportExcel.defaultExpectation.paramPtrs = &SupplierServiceMockExportExcelParamPtrs{}
+	}
+	mmExportExcel.defaultExpectation.paramPtrs.requestID = &requestID
+	mmExportExcel.defaultExpectation.expectationOrigins.originRequestID = minimock.CallerInfo(1)
+
+	return mmExportExcel
+}
+
+// Inspect accepts an inspector function that has same arguments as the SupplierService.ExportExcel
+func (mmExportExcel *mSupplierServiceMockExportExcel) Inspect(f func(ctx context.Context, requestID uuid.UUID)) *mSupplierServiceMockExportExcel {
+	if mmExportExcel.mock.inspectFuncExportExcel != nil {
+		mmExportExcel.mock.t.Fatalf("Inspect function is already set for SupplierServiceMock.ExportExcel")
+	}
+
+	mmExportExcel.mock.inspectFuncExportExcel = f
+
+	return mmExportExcel
+}
+
+// Return sets up results that will be returned by SupplierService.ExportExcel
+func (mmExportExcel *mSupplierServiceMockExportExcel) Return(ba1 []byte, err error) *SupplierServiceMock {
+	if mmExportExcel.mock.funcExportExcel != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
+	}
+
+	if mmExportExcel.defaultExpectation == nil {
+		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{mock: mmExportExcel.mock}
+	}
+	mmExportExcel.defaultExpectation.results = &SupplierServiceMockExportExcelResults{ba1, err}
+	mmExportExcel.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
+	return mmExportExcel.mock
+}
+
+// Set uses given function f to mock the SupplierService.ExportExcel method
+func (mmExportExcel *mSupplierServiceMockExportExcel) Set(f func(ctx context.Context, requestID uuid.UUID) (ba1 []byte, err error)) *SupplierServiceMock {
+	if mmExportExcel.defaultExpectation != nil {
+		mmExportExcel.mock.t.Fatalf("Default expectation is already set for the SupplierService.ExportExcel method")
+	}
+
+	if len(mmExportExcel.expectations) > 0 {
+		mmExportExcel.mock.t.Fatalf("Some expectations are already set for the SupplierService.ExportExcel method")
+	}
+
+	mmExportExcel.mock.funcExportExcel = f
+	mmExportExcel.mock.funcExportExcelOrigin = minimock.CallerInfo(1)
+	return mmExportExcel.mock
+}
+
+// When sets expectation for the SupplierService.ExportExcel which will trigger the result defined by the following
+// Then helper
+func (mmExportExcel *mSupplierServiceMockExportExcel) When(ctx context.Context, requestID uuid.UUID) *SupplierServiceMockExportExcelExpectation {
+	if mmExportExcel.mock.funcExportExcel != nil {
+		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
+	}
+
+	expectation := &SupplierServiceMockExportExcelExpectation{
+		mock:               mmExportExcel.mock,
+		params:             &SupplierServiceMockExportExcelParams{ctx, requestID},
+		expectationOrigins: SupplierServiceMockExportExcelExpectationOrigins{origin: minimock.CallerInfo(1)},
+	}
+	mmExportExcel.expectations = append(mmExportExcel.expectations, expectation)
+	return expectation
+}
+
+// Then sets up SupplierService.ExportExcel return parameters for the expectation previously defined by the When method
+func (e *SupplierServiceMockExportExcelExpectation) Then(ba1 []byte, err error) *SupplierServiceMock {
+	e.results = &SupplierServiceMockExportExcelResults{ba1, err}
+	return e.mock
+}
+
+// Times sets number of times SupplierService.ExportExcel should be invoked
+func (mmExportExcel *mSupplierServiceMockExportExcel) Times(n uint64) *mSupplierServiceMockExportExcel {
+	if n == 0 {
+		mmExportExcel.mock.t.Fatalf("Times of SupplierServiceMock.ExportExcel mock can not be zero")
+	}
+	mm_atomic.StoreUint64(&mmExportExcel.expectedInvocations, n)
+	mmExportExcel.expectedInvocationsOrigin = minimock.CallerInfo(1)
+	return mmExportExcel
+}
+
+func (mmExportExcel *mSupplierServiceMockExportExcel) invocationsDone() bool {
+	if len(mmExportExcel.expectations) == 0 && mmExportExcel.defaultExpectation == nil && mmExportExcel.mock.funcExportExcel == nil {
+		return true
+	}
+
+	totalInvocations := mm_atomic.LoadUint64(&mmExportExcel.mock.afterExportExcelCounter)
+	expectedInvocations := mm_atomic.LoadUint64(&mmExportExcel.expectedInvocations)
+
+	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
+}
+
+// ExportExcel implements mm_service.SupplierService
+func (mmExportExcel *SupplierServiceMock) ExportExcel(ctx context.Context, requestID uuid.UUID) (ba1 []byte, err error) {
+	mm_atomic.AddUint64(&mmExportExcel.beforeExportExcelCounter, 1)
+	defer mm_atomic.AddUint64(&mmExportExcel.afterExportExcelCounter, 1)
+
+	mmExportExcel.t.Helper()
+
+	if mmExportExcel.inspectFuncExportExcel != nil {
+		mmExportExcel.inspectFuncExportExcel(ctx, requestID)
+	}
+
+	mm_params := SupplierServiceMockExportExcelParams{ctx, requestID}
+
+	// Record call args
+	mmExportExcel.ExportExcelMock.mutex.Lock()
+	mmExportExcel.ExportExcelMock.callArgs = append(mmExportExcel.ExportExcelMock.callArgs, &mm_params)
+	mmExportExcel.ExportExcelMock.mutex.Unlock()
+
+	for _, e := range mmExportExcel.ExportExcelMock.expectations {
+		if minimock.Equal(*e.params, mm_params) {
+			mm_atomic.AddUint64(&e.Counter, 1)
+			return e.results.ba1, e.results.err
+		}
+	}
+
+	if mmExportExcel.ExportExcelMock.defaultExpectation != nil {
+		mm_atomic.AddUint64(&mmExportExcel.ExportExcelMock.defaultExpectation.Counter, 1)
+		mm_want := mmExportExcel.ExportExcelMock.defaultExpectation.params
+		mm_want_ptrs := mmExportExcel.ExportExcelMock.defaultExpectation.paramPtrs
+
+		mm_got := SupplierServiceMockExportExcelParams{ctx, requestID}
+
+		if mm_want_ptrs != nil {
+
+			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
+				mmExportExcel.t.Errorf("SupplierServiceMock.ExportExcel got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmExportExcel.ExportExcelMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
+			}
+
+			if mm_want_ptrs.requestID != nil && !minimock.Equal(*mm_want_ptrs.requestID, mm_got.requestID) {
+				mmExportExcel.t.Errorf("SupplierServiceMock.ExportExcel got unexpected parameter requestID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmExportExcel.ExportExcelMock.defaultExpectation.expectationOrigins.originRequestID, *mm_want_ptrs.requestID, mm_got.requestID, minimock.Diff(*mm_want_ptrs.requestID, mm_got.requestID))
+			}
+
+		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
+			mmExportExcel.t.Errorf("SupplierServiceMock.ExportExcel got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+				mmExportExcel.ExportExcelMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
+		}
+
+		mm_results := mmExportExcel.ExportExcelMock.defaultExpectation.results
+		if mm_results == nil {
+			mmExportExcel.t.Fatal("No results are set for the SupplierServiceMock.ExportExcel")
+		}
+		return (*mm_results).ba1, (*mm_results).err
+	}
+	if mmExportExcel.funcExportExcel != nil {
+		return mmExportExcel.funcExportExcel(ctx, requestID)
+	}
+	mmExportExcel.t.Fatalf("Unexpected call to SupplierServiceMock.ExportExcel. %v %v", ctx, requestID)
+	return
+}
+
+// ExportExcelAfterCounter returns a count of finished SupplierServiceMock.ExportExcel invocations
+func (mmExportExcel *SupplierServiceMock) ExportExcelAfterCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmExportExcel.afterExportExcelCounter)
+}
+
+// ExportExcelBeforeCounter returns a count of SupplierServiceMock.ExportExcel invocations
+func (mmExportExcel *SupplierServiceMock) ExportExcelBeforeCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmExportExcel.beforeExportExcelCounter)
+}
+
+// Calls returns a list of arguments used in each call to SupplierServiceMock.ExportExcel.
+// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
+func (mmExportExcel *mSupplierServiceMockExportExcel) Calls() []*SupplierServiceMockExportExcelParams {
+	mmExportExcel.mutex.RLock()
+
+	argCopy := make([]*SupplierServiceMockExportExcelParams, len(mmExportExcel.callArgs))
+	copy(argCopy, mmExportExcel.callArgs)
+
+	mmExportExcel.mutex.RUnlock()
+
+	return argCopy
+}
+
+// MinimockExportExcelDone returns true if the count of the ExportExcel invocations corresponds
+// the number of defined expectations
+func (m *SupplierServiceMock) MinimockExportExcelDone() bool {
+	if m.ExportExcelMock.optional {
+		// Optional methods provide '0 or more' call count restriction.
+		return true
+	}
+
+	for _, e := range m.ExportExcelMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			return false
+		}
+	}
+
+	return m.ExportExcelMock.invocationsDone()
+}
+
+// MinimockExportExcelInspect logs each unmet expectation
+func (m *SupplierServiceMock) MinimockExportExcelInspect() {
+	for _, e := range m.ExportExcelMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			m.t.Errorf("Expected call to SupplierServiceMock.ExportExcel at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
+		}
+	}
+
+	afterExportExcelCounter := mm_atomic.LoadUint64(&m.afterExportExcelCounter)
+	// if default expectation was set then invocations count should be greater than zero
+	if m.ExportExcelMock.defaultExpectation != nil && afterExportExcelCounter < 1 {
+		if m.ExportExcelMock.defaultExpectation.params == nil {
+			m.t.Errorf("Expected call to SupplierServiceMock.ExportExcel at\n%s", m.ExportExcelMock.defaultExpectation.returnOrigin)
+		} else {
+			m.t.Errorf("Expected call to SupplierServiceMock.ExportExcel at\n%s with params: %#v", m.ExportExcelMock.defaultExpectation.expectationOrigins.origin, *m.ExportExcelMock.defaultExpectation.params)
+		}
+	}
+	// if func was set then invocations count should be greater than zero
+	if m.funcExportExcel != nil && afterExportExcelCounter < 1 {
+		m.t.Errorf("Expected call to SupplierServiceMock.ExportExcel at\n%s", m.funcExportExcelOrigin)
+	}
+
+	if !m.ExportExcelMock.invocationsDone() && afterExportExcelCounter > 0 {
+		m.t.Errorf("Expected %d calls to SupplierServiceMock.ExportExcel at\n%s but found %d calls",
+			mm_atomic.LoadUint64(&m.ExportExcelMock.expectedInvocations), m.ExportExcelMock.expectedInvocationsOrigin, afterExportExcelCounter)
+	}
+}
+
+// MinimockFinish checks that all mocked methods have been called the expected number of times
+func (m *SupplierServiceMock) MinimockFinish() {
+	m.finishOnce.Do(func() {
+		if !m.minimockDone() {
+			m.MinimockExportExcelInspect()
+		}
+	})
+}
+
+// MinimockWait waits for all mocked methods to be called the expected number of times
+func (m *SupplierServiceMock) MinimockWait(timeout mm_time.Duration) {
+	timeoutCh := mm_time.After(timeout)
+	for {
+		if m.minimockDone() {
+			return
+		}
+		select {
+		case <-timeoutCh:
+			m.MinimockFinish()
+			return
+		case <-mm_time.After(10 * mm_time.Millisecond):
+		}
+	}
+}
+
+func (m *SupplierServiceMock) minimockDone() bool {
+	done := true
+	return done &&
+		m.MinimockExportExcelDone()
+}

internal/mocks/token_usage_repository_mock.go

@@ -0,0 +1,417 @@
+// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.
+
+package mocks
+
+//go:generate minimock -i smart-search-back/internal/repository.TokenUsageRepository -o token_usage_repository_mock.go -n TokenUsageRepositoryMock -p mocks
+
+import (
+	"context"
+	"smart-search-back/internal/model"
+	"sync"
+	mm_atomic "sync/atomic"
+	mm_time "time"
+
+	"github.com/gojuno/minimock/v3"
+)
+
+// TokenUsageRepositoryMock implements mm_repository.TokenUsageRepository
+type TokenUsageRepositoryMock struct {
+	t          minimock.Tester
+	finishOnce sync.Once
+
+	funcCreate          func(ctx context.Context, usage *model.TokenUsage) (err error)
+	funcCreateOrigin    string
+	inspectFuncCreate   func(ctx context.Context, usage *model.TokenUsage)
+	afterCreateCounter  uint64
+	beforeCreateCounter uint64
+	CreateMock          mTokenUsageRepositoryMockCreate
+}
+
+// NewTokenUsageRepositoryMock returns a mock for mm_repository.TokenUsageRepository
+func NewTokenUsageRepositoryMock(t minimock.Tester) *TokenUsageRepositoryMock {
+	m := &TokenUsageRepositoryMock{t: t}
+
+	if controller, ok := t.(minimock.MockController); ok {
+		controller.RegisterMocker(m)
+	}
+
+	m.CreateMock = mTokenUsageRepositoryMockCreate{mock: m}
+	m.CreateMock.callArgs = []*TokenUsageRepositoryMockCreateParams{}
+
+	t.Cleanup(m.MinimockFinish)
+
+	return m
+}
+
+type mTokenUsageRepositoryMockCreate struct {
+	optional           bool
+	mock               *TokenUsageRepositoryMock
+	defaultExpectation *TokenUsageRepositoryMockCreateExpectation
+	expectations       []*TokenUsageRepositoryMockCreateExpectation
+
+	callArgs []*TokenUsageRepositoryMockCreateParams
+	mutex    sync.RWMutex
+
+	expectedInvocations       uint64
+	expectedInvocationsOrigin string
+}
+
+// TokenUsageRepositoryMockCreateExpectation specifies expectation struct of the TokenUsageRepository.Create
+type TokenUsageRepositoryMockCreateExpectation struct {
+	mock               *TokenUsageRepositoryMock
+	params             *TokenUsageRepositoryMockCreateParams
+	paramPtrs          *TokenUsageRepositoryMockCreateParamPtrs
+	expectationOrigins TokenUsageRepositoryMockCreateExpectationOrigins
+	results            *TokenUsageRepositoryMockCreateResults
+	returnOrigin       string
+	Counter            uint64
+}
+
+// TokenUsageRepositoryMockCreateParams contains parameters of the TokenUsageRepository.Create
+type TokenUsageRepositoryMockCreateParams struct {
+	ctx   context.Context
+	usage *model.TokenUsage
+}
+
+// TokenUsageRepositoryMockCreateParamPtrs contains pointers to parameters of the TokenUsageRepository.Create
+type TokenUsageRepositoryMockCreateParamPtrs struct {
+	ctx   *context.Context
+	usage **model.TokenUsage
+}
+
+// TokenUsageRepositoryMockCreateResults contains results of the TokenUsageRepository.Create
+type TokenUsageRepositoryMockCreateResults struct {
+	err error
+}
+
+// TokenUsageRepositoryMockCreateOrigins contains origins of expectations of the TokenUsageRepository.Create
+type TokenUsageRepositoryMockCreateExpectationOrigins struct {
+	origin      string
+	originCtx   string
+	originUsage string
+}
+
+// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
+// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
+// Optional() makes method check to work in '0 or more' mode.
+// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
+// catch the problems when the expected method call is totally skipped during test run.
+func (mmCreate *mTokenUsageRepositoryMockCreate) Optional() *mTokenUsageRepositoryMockCreate {
+	mmCreate.optional = true
+	return mmCreate
+}
+
+// Expect sets up expected params for TokenUsageRepository.Create
+func (mmCreate *mTokenUsageRepositoryMockCreate) Expect(ctx context.Context, usage *model.TokenUsage) *mTokenUsageRepositoryMockCreate {
+	if mmCreate.mock.funcCreate != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Set")
+	}
+
+	if mmCreate.defaultExpectation == nil {
+		mmCreate.defaultExpectation = &TokenUsageRepositoryMockCreateExpectation{}
+	}
+
+	if mmCreate.defaultExpectation.paramPtrs != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by ExpectParams functions")
+	}
+
+	mmCreate.defaultExpectation.params = &TokenUsageRepositoryMockCreateParams{ctx, usage}
+	mmCreate.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
+	for _, e := range mmCreate.expectations {
+		if minimock.Equal(e.params, mmCreate.defaultExpectation.params) {
+			mmCreate.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreate.defaultExpectation.params)
+		}
+	}
+
+	return mmCreate
+}
+
+// ExpectCtxParam1 sets up expected param ctx for TokenUsageRepository.Create
+func (mmCreate *mTokenUsageRepositoryMockCreate) ExpectCtxParam1(ctx context.Context) *mTokenUsageRepositoryMockCreate {
+	if mmCreate.mock.funcCreate != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Set")
+	}
+
+	if mmCreate.defaultExpectation == nil {
+		mmCreate.defaultExpectation = &TokenUsageRepositoryMockCreateExpectation{}
+	}
+
+	if mmCreate.defaultExpectation.params != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Expect")
+	}
+
+	if mmCreate.defaultExpectation.paramPtrs == nil {
+		mmCreate.defaultExpectation.paramPtrs = &TokenUsageRepositoryMockCreateParamPtrs{}
+	}
+	mmCreate.defaultExpectation.paramPtrs.ctx = &ctx
+	mmCreate.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
+
+	return mmCreate
+}
+
+// ExpectUsageParam2 sets up expected param usage for TokenUsageRepository.Create
+func (mmCreate *mTokenUsageRepositoryMockCreate) ExpectUsageParam2(usage *model.TokenUsage) *mTokenUsageRepositoryMockCreate {
+	if mmCreate.mock.funcCreate != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Set")
+	}
+
+	if mmCreate.defaultExpectation == nil {
+		mmCreate.defaultExpectation = &TokenUsageRepositoryMockCreateExpectation{}
+	}
+
+	if mmCreate.defaultExpectation.params != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Expect")
+	}
+
+	if mmCreate.defaultExpectation.paramPtrs == nil {
+		mmCreate.defaultExpectation.paramPtrs = &TokenUsageRepositoryMockCreateParamPtrs{}
+	}
+	mmCreate.defaultExpectation.paramPtrs.usage = &usage
+	mmCreate.defaultExpectation.expectationOrigins.originUsage = minimock.CallerInfo(1)
+
+	return mmCreate
+}
+
+// Inspect accepts an inspector function that has same arguments as the TokenUsageRepository.Create
+func (mmCreate *mTokenUsageRepositoryMockCreate) Inspect(f func(ctx context.Context, usage *model.TokenUsage)) *mTokenUsageRepositoryMockCreate {
+	if mmCreate.mock.inspectFuncCreate != nil {
+		mmCreate.mock.t.Fatalf("Inspect function is already set for TokenUsageRepositoryMock.Create")
+	}
+
+	mmCreate.mock.inspectFuncCreate = f
+
+	return mmCreate
+}
+
+// Return sets up results that will be returned by TokenUsageRepository.Create
+func (mmCreate *mTokenUsageRepositoryMockCreate) Return(err error) *TokenUsageRepositoryMock {
+	if mmCreate.mock.funcCreate != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Set")
+	}
+
+	if mmCreate.defaultExpectation == nil {
+		mmCreate.defaultExpectation = &TokenUsageRepositoryMockCreateExpectation{mock: mmCreate.mock}
+	}
+	mmCreate.defaultExpectation.results = &TokenUsageRepositoryMockCreateResults{err}
+	mmCreate.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
+	return mmCreate.mock
+}
+
+// Set uses given function f to mock the TokenUsageRepository.Create method
+func (mmCreate *mTokenUsageRepositoryMockCreate) Set(f func(ctx context.Context, usage *model.TokenUsage) (err error)) *TokenUsageRepositoryMock {
+	if mmCreate.defaultExpectation != nil {
+		mmCreate.mock.t.Fatalf("Default expectation is already set for the TokenUsageRepository.Create method")
+	}
+
+	if len(mmCreate.expectations) > 0 {
+		mmCreate.mock.t.Fatalf("Some expectations are already set for the TokenUsageRepository.Create method")
+	}
+
+	mmCreate.mock.funcCreate = f
+	mmCreate.mock.funcCreateOrigin = minimock.CallerInfo(1)
+	return mmCreate.mock
+}
+
+// When sets expectation for the TokenUsageRepository.Create which will trigger the result defined by the following
+// Then helper
+func (mmCreate *mTokenUsageRepositoryMockCreate) When(ctx context.Context, usage *model.TokenUsage) *TokenUsageRepositoryMockCreateExpectation {
+	if mmCreate.mock.funcCreate != nil {
+		mmCreate.mock.t.Fatalf("TokenUsageRepositoryMock.Create mock is already set by Set")
+	}
+
+	expectation := &TokenUsageRepositoryMockCreateExpectation{
+		mock:               mmCreate.mock,
+		params:             &TokenUsageRepositoryMockCreateParams{ctx, usage},
+		expectationOrigins: TokenUsageRepositoryMockCreateExpectationOrigins{origin: minimock.CallerInfo(1)},
+	}
+	mmCreate.expectations = append(mmCreate.expectations, expectation)
+	return expectation
+}
+
+// Then sets up TokenUsageRepository.Create return parameters for the expectation previously defined by the When method
+func (e *TokenUsageRepositoryMockCreateExpectation) Then(err error) *TokenUsageRepositoryMock {
+	e.results = &TokenUsageRepositoryMockCreateResults{err}
+	return e.mock
+}
+
+// Times sets number of times TokenUsageRepository.Create should be invoked
+func (mmCreate *mTokenUsageRepositoryMockCreate) Times(n uint64) *mTokenUsageRepositoryMockCreate {
+	if n == 0 {
+		mmCreate.mock.t.Fatalf("Times of TokenUsageRepositoryMock.Create mock can not be zero")
+	}
+	mm_atomic.StoreUint64(&mmCreate.expectedInvocations, n)
+	mmCreate.expectedInvocationsOrigin = minimock.CallerInfo(1)
+	return mmCreate
+}
+
+func (mmCreate *mTokenUsageRepositoryMockCreate) invocationsDone() bool {
+	if len(mmCreate.expectations) == 0 && mmCreate.defaultExpectation == nil && mmCreate.mock.funcCreate == nil {
+		return true
+	}
+
+	totalInvocations := mm_atomic.LoadUint64(&mmCreate.mock.afterCreateCounter)
+	expectedInvocations := mm_atomic.LoadUint64(&mmCreate.expectedInvocations)
+
+	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
+}
+
+// Create implements mm_repository.TokenUsageRepository
+func (mmCreate *TokenUsageRepositoryMock) Create(ctx context.Context, usage *model.TokenUsage) (err error) {
+	mm_atomic.AddUint64(&mmCreate.beforeCreateCounter, 1)
+	defer mm_atomic.AddUint64(&mmCreate.afterCreateCounter, 1)
+
+	mmCreate.t.Helper()
+
+	if mmCreate.inspectFuncCreate != nil {
+		mmCreate.inspectFuncCreate(ctx, usage)
+	}
+
+	mm_params := TokenUsageRepositoryMockCreateParams{ctx, usage}
+
+	// Record call args
+	mmCreate.CreateMock.mutex.Lock()
+	mmCreate.CreateMock.callArgs = append(mmCreate.CreateMock.callArgs, &mm_params)
+	mmCreate.CreateMock.mutex.Unlock()
+
+	for _, e := range mmCreate.CreateMock.expectations {
+		if minimock.Equal(*e.params, mm_params) {
+			mm_atomic.AddUint64(&e.Counter, 1)
+			return e.results.err
+		}
+	}
+
+	if mmCreate.CreateMock.defaultExpectation != nil {
+		mm_atomic.AddUint64(&mmCreate.CreateMock.defaultExpectation.Counter, 1)
+		mm_want := mmCreate.CreateMock.defaultExpectation.params
+		mm_want_ptrs := mmCreate.CreateMock.defaultExpectation.paramPtrs
+
+		mm_got := TokenUsageRepositoryMockCreateParams{ctx, usage}
+
+		if mm_want_ptrs != nil {
+
+			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
+				mmCreate.t.Errorf("TokenUsageRepositoryMock.Create got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmCreate.CreateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
+			}
+
+			if mm_want_ptrs.usage != nil && !minimock.Equal(*mm_want_ptrs.usage, mm_got.usage) {
+				mmCreate.t.Errorf("TokenUsageRepositoryMock.Create got unexpected parameter usage, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+					mmCreate.CreateMock.defaultExpectation.expectationOrigins.originUsage, *mm_want_ptrs.usage, mm_got.usage, minimock.Diff(*mm_want_ptrs.usage, mm_got.usage))
+			}
+
+		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
+			mmCreate.t.Errorf("TokenUsageRepositoryMock.Create got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
+				mmCreate.CreateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
+		}
+
+		mm_results := mmCreate.CreateMock.defaultExpectation.results
+		if mm_results == nil {
+			mmCreate.t.Fatal("No results are set for the TokenUsageRepositoryMock.Create")
+		}
+		return (*mm_results).err
+	}
+	if mmCreate.funcCreate != nil {
+		return mmCreate.funcCreate(ctx, usage)
+	}
+	mmCreate.t.Fatalf("Unexpected call to TokenUsageRepositoryMock.Create. %v %v", ctx, usage)
+	return
+}
+
+// CreateAfterCounter returns a count of finished TokenUsageRepositoryMock.Create invocations
+func (mmCreate *TokenUsageRepositoryMock) CreateAfterCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmCreate.afterCreateCounter)
+}
+
+// CreateBeforeCounter returns a count of TokenUsageRepositoryMock.Create invocations
+func (mmCreate *TokenUsageRepositoryMock) CreateBeforeCounter() uint64 {
+	return mm_atomic.LoadUint64(&mmCreate.beforeCreateCounter)
+}
+
+// Calls returns a list of arguments used in each call to TokenUsageRepositoryMock.Create.
+// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
+func (mmCreate *mTokenUsageRepositoryMockCreate) Calls() []*TokenUsageRepositoryMockCreateParams {
+	mmCreate.mutex.RLock()
+
+	argCopy := make([]*TokenUsageRepositoryMockCreateParams, len(mmCreate.callArgs))
+	copy(argCopy, mmCreate.callArgs)
+
+	mmCreate.mutex.RUnlock()
+
+	return argCopy
+}
+
+// MinimockCreateDone returns true if the count of the Create invocations corresponds
+// the number of defined expectations
+func (m *TokenUsageRepositoryMock) MinimockCreateDone() bool {
+	if m.CreateMock.optional {
+		// Optional methods provide '0 or more' call count restriction.
+		return true
+	}
+
+	for _, e := range m.CreateMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			return false
+		}
+	}
+
+	return m.CreateMock.invocationsDone()
+}
+
+// MinimockCreateInspect logs each unmet expectation
+func (m *TokenUsageRepositoryMock) MinimockCreateInspect() {
+	for _, e := range m.CreateMock.expectations {
+		if mm_atomic.LoadUint64(&e.Counter) < 1 {
+			m.t.Errorf("Expected call to TokenUsageRepositoryMock.Create at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
+		}
+	}
+
+	afterCreateCounter := mm_atomic.LoadUint64(&m.afterCreateCounter)
+	// if default expectation was set then invocations count should be greater than zero
+	if m.CreateMock.defaultExpectation != nil && afterCreateCounter < 1 {
+		if m.CreateMock.defaultExpectation.params == nil {
+			m.t.Errorf("Expected call to TokenUsageRepositoryMock.Create at\n%s", m.CreateMock.defaultExpectation.returnOrigin)
+		} else {
+			m.t.Errorf("Expected call to TokenUsageRepositoryMock.Create at\n%s with params: %#v", m.CreateMock.defaultExpectation.expectationOrigins.origin, *m.CreateMock.defaultExpectation.params)
+		}
+	}
+	// if func was set then invocations count should be greater than zero
+	if m.funcCreate != nil && afterCreateCounter < 1 {
+		m.t.Errorf("Expected call to TokenUsageRepositoryMock.Create at\n%s", m.funcCreateOrigin)
+	}
+
+	if !m.CreateMock.invocationsDone() && afterCreateCounter > 0 {
+		m.t.Errorf("Expected %d calls to TokenUsageRepositoryMock.Create at\n%s but found %d calls",
+			mm_atomic.LoadUint64(&m.CreateMock.expectedInvocations), m.CreateMock.expectedInvocationsOrigin, afterCreateCounter)
+	}
+}
+
+// MinimockFinish checks that all mocked methods have been called the expected number of times
+func (m *TokenUsageRepositoryMock) MinimockFinish() {
+	m.finishOnce.Do(func() {
+		if !m.minimockDone() {
+			m.MinimockCreateInspect()
+		}
+	})
+}
+
+// MinimockWait waits for all mocked methods to be called the expected number of times
+func (m *TokenUsageRepositoryMock) MinimockWait(timeout mm_time.Duration) {
+	timeoutCh := mm_time.After(timeout)
+	for {
+		if m.minimockDone() {
+			return
+		}
+		select {
+		case <-timeoutCh:
+			m.MinimockFinish()
+			return
+		case <-mm_time.After(10 * mm_time.Millisecond):
+		}
+	}
+}
+
+func (m *TokenUsageRepositoryMock) minimockDone() bool {
+	done := true
+	return done &&
+		m.MinimockCreateDone()
+}