smart-search-back/internal/mocks/invite_repository_mock.go

// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.

package mocks

//go:generate minimock -i git.techease.ru/Smart-search/smart-search-back/internal/repository.InviteRepository -o invite_repository_mock.go -n InviteRepositoryMock -p mocks

import (
	"context"
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"

	"git.techease.ru/Smart-search/smart-search-back/internal/model"
	"github.com/gojuno/minimock/v3"
	"github.com/jackc/pgx/v5"
)

// InviteRepositoryMock implements mm_repository.InviteRepository
type InviteRepositoryMock struct {
	t          minimock.Tester
	finishOnce sync.Once

	funcCreate          func(ctx context.Context, invite *model.InviteCode) (err error)
	funcCreateOrigin    string
	inspectFuncCreate   func(ctx context.Context, invite *model.InviteCode)
	afterCreateCounter  uint64
	beforeCreateCounter uint64
	CreateMock          mInviteRepositoryMockCreate

	funcCreateTx          func(ctx context.Context, tx pgx.Tx, invite *model.InviteCode) (err error)
	funcCreateTxOrigin    string
	inspectFuncCreateTx   func(ctx context.Context, tx pgx.Tx, invite *model.InviteCode)
	afterCreateTxCounter  uint64
	beforeCreateTxCounter uint64
	CreateTxMock          mInviteRepositoryMockCreateTx

	funcDeactivateExpired          func(ctx context.Context) (i1 int, err error)
	funcDeactivateExpiredOrigin    string
	inspectFuncDeactivateExpired   func(ctx context.Context)
	afterDeactivateExpiredCounter  uint64
	beforeDeactivateExpiredCounter uint64
	DeactivateExpiredMock          mInviteRepositoryMockDeactivateExpired

	funcDecrementCanBeUsedCountTx          func(ctx context.Context, tx pgx.Tx, code int64) (err error)
	funcDecrementCanBeUsedCountTxOrigin    string
	inspectFuncDecrementCanBeUsedCountTx   func(ctx context.Context, tx pgx.Tx, code int64)
	afterDecrementCanBeUsedCountTxCounter  uint64
	beforeDecrementCanBeUsedCountTxCounter uint64
	DecrementCanBeUsedCountTxMock          mInviteRepositoryMockDecrementCanBeUsedCountTx

	funcFindActiveByCode          func(ctx context.Context, code int64) (ip1 *model.InviteCode, err error)
	funcFindActiveByCodeOrigin    string
	inspectFuncFindActiveByCode   func(ctx context.Context, code int64)
	afterFindActiveByCodeCounter  uint64
	beforeFindActiveByCodeCounter uint64
	FindActiveByCodeMock          mInviteRepositoryMockFindActiveByCode

	funcFindActiveByUserID          func(ctx context.Context, userID int) (ip1 *model.InviteCode, err error)
	funcFindActiveByUserIDOrigin    string
	inspectFuncFindActiveByUserID   func(ctx context.Context, userID int)
	afterFindActiveByUserIDCounter  uint64
	beforeFindActiveByUserIDCounter uint64
	FindActiveByUserIDMock          mInviteRepositoryMockFindActiveByUserID

	funcFindByCode          func(ctx context.Context, code int64) (ip1 *model.InviteCode, err error)
	funcFindByCodeOrigin    string
	inspectFuncFindByCode   func(ctx context.Context, code int64)
	afterFindByCodeCounter  uint64
	beforeFindByCodeCounter uint64
	FindByCodeMock          mInviteRepositoryMockFindByCode

	funcGetUserInvites          func(ctx context.Context, userID int) (ipa1 []*model.InviteCode, err error)
	funcGetUserInvitesOrigin    string
	inspectFuncGetUserInvites   func(ctx context.Context, userID int)
	afterGetUserInvitesCounter  uint64
	beforeGetUserInvitesCounter uint64
	GetUserInvitesMock          mInviteRepositoryMockGetUserInvites
}

// NewInviteRepositoryMock returns a mock for mm_repository.InviteRepository
func NewInviteRepositoryMock(t minimock.Tester) *InviteRepositoryMock {
	m := &InviteRepositoryMock{t: t}

	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}

	m.CreateMock = mInviteRepositoryMockCreate{mock: m}
	m.CreateMock.callArgs = []*InviteRepositoryMockCreateParams{}

	m.CreateTxMock = mInviteRepositoryMockCreateTx{mock: m}
	m.CreateTxMock.callArgs = []*InviteRepositoryMockCreateTxParams{}

	m.DeactivateExpiredMock = mInviteRepositoryMockDeactivateExpired{mock: m}
	m.DeactivateExpiredMock.callArgs = []*InviteRepositoryMockDeactivateExpiredParams{}

	m.DecrementCanBeUsedCountTxMock = mInviteRepositoryMockDecrementCanBeUsedCountTx{mock: m}
	m.DecrementCanBeUsedCountTxMock.callArgs = []*InviteRepositoryMockDecrementCanBeUsedCountTxParams{}

	m.FindActiveByCodeMock = mInviteRepositoryMockFindActiveByCode{mock: m}
	m.FindActiveByCodeMock.callArgs = []*InviteRepositoryMockFindActiveByCodeParams{}

	m.FindActiveByUserIDMock = mInviteRepositoryMockFindActiveByUserID{mock: m}
	m.FindActiveByUserIDMock.callArgs = []*InviteRepositoryMockFindActiveByUserIDParams{}

	m.FindByCodeMock = mInviteRepositoryMockFindByCode{mock: m}
	m.FindByCodeMock.callArgs = []*InviteRepositoryMockFindByCodeParams{}

	m.GetUserInvitesMock = mInviteRepositoryMockGetUserInvites{mock: m}
	m.GetUserInvitesMock.callArgs = []*InviteRepositoryMockGetUserInvitesParams{}

	t.Cleanup(m.MinimockFinish)

	return m
}

type mInviteRepositoryMockCreate struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockCreateExpectation
	expectations       []*InviteRepositoryMockCreateExpectation

	callArgs []*InviteRepositoryMockCreateParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockCreateExpectation specifies expectation struct of the InviteRepository.Create
type InviteRepositoryMockCreateExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockCreateParams
	paramPtrs          *InviteRepositoryMockCreateParamPtrs
	expectationOrigins InviteRepositoryMockCreateExpectationOrigins
	results            *InviteRepositoryMockCreateResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockCreateParams contains parameters of the InviteRepository.Create
type InviteRepositoryMockCreateParams struct {
	ctx    context.Context
	invite *model.InviteCode
}

// InviteRepositoryMockCreateParamPtrs contains pointers to parameters of the InviteRepository.Create
type InviteRepositoryMockCreateParamPtrs struct {
	ctx    *context.Context
	invite **model.InviteCode
}

// InviteRepositoryMockCreateResults contains results of the InviteRepository.Create
type InviteRepositoryMockCreateResults struct {
	err error
}

// InviteRepositoryMockCreateOrigins contains origins of expectations of the InviteRepository.Create
type InviteRepositoryMockCreateExpectationOrigins struct {
	origin       string
	originCtx    string
	originInvite 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 *mInviteRepositoryMockCreate) Optional() *mInviteRepositoryMockCreate {
	mmCreate.optional = true
	return mmCreate
}

// Expect sets up expected params for InviteRepository.Create
func (mmCreate *mInviteRepositoryMockCreate) Expect(ctx context.Context, invite *model.InviteCode) *mInviteRepositoryMockCreate {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &InviteRepositoryMockCreateExpectation{}
	}

	if mmCreate.defaultExpectation.paramPtrs != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by ExpectParams functions")
	}

	mmCreate.defaultExpectation.params = &InviteRepositoryMockCreateParams{ctx, invite}
	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 InviteRepository.Create
func (mmCreate *mInviteRepositoryMockCreate) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockCreate {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &InviteRepositoryMockCreateExpectation{}
	}

	if mmCreate.defaultExpectation.params != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Expect")
	}

	if mmCreate.defaultExpectation.paramPtrs == nil {
		mmCreate.defaultExpectation.paramPtrs = &InviteRepositoryMockCreateParamPtrs{}
	}
	mmCreate.defaultExpectation.paramPtrs.ctx = &ctx
	mmCreate.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmCreate
}

// ExpectInviteParam2 sets up expected param invite for InviteRepository.Create
func (mmCreate *mInviteRepositoryMockCreate) ExpectInviteParam2(invite *model.InviteCode) *mInviteRepositoryMockCreate {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &InviteRepositoryMockCreateExpectation{}
	}

	if mmCreate.defaultExpectation.params != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Expect")
	}

	if mmCreate.defaultExpectation.paramPtrs == nil {
		mmCreate.defaultExpectation.paramPtrs = &InviteRepositoryMockCreateParamPtrs{}
	}
	mmCreate.defaultExpectation.paramPtrs.invite = &invite
	mmCreate.defaultExpectation.expectationOrigins.originInvite = minimock.CallerInfo(1)

	return mmCreate
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.Create
func (mmCreate *mInviteRepositoryMockCreate) Inspect(f func(ctx context.Context, invite *model.InviteCode)) *mInviteRepositoryMockCreate {
	if mmCreate.mock.inspectFuncCreate != nil {
		mmCreate.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.Create")
	}

	mmCreate.mock.inspectFuncCreate = f

	return mmCreate
}

// Return sets up results that will be returned by InviteRepository.Create
func (mmCreate *mInviteRepositoryMockCreate) Return(err error) *InviteRepositoryMock {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Set")
	}

	if mmCreate.defaultExpectation == nil {
		mmCreate.defaultExpectation = &InviteRepositoryMockCreateExpectation{mock: mmCreate.mock}
	}
	mmCreate.defaultExpectation.results = &InviteRepositoryMockCreateResults{err}
	mmCreate.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCreate.mock
}

// Set uses given function f to mock the InviteRepository.Create method
func (mmCreate *mInviteRepositoryMockCreate) Set(f func(ctx context.Context, invite *model.InviteCode) (err error)) *InviteRepositoryMock {
	if mmCreate.defaultExpectation != nil {
		mmCreate.mock.t.Fatalf("Default expectation is already set for the InviteRepository.Create method")
	}

	if len(mmCreate.expectations) > 0 {
		mmCreate.mock.t.Fatalf("Some expectations are already set for the InviteRepository.Create method")
	}

	mmCreate.mock.funcCreate = f
	mmCreate.mock.funcCreateOrigin = minimock.CallerInfo(1)
	return mmCreate.mock
}

// When sets expectation for the InviteRepository.Create which will trigger the result defined by the following
// Then helper
func (mmCreate *mInviteRepositoryMockCreate) When(ctx context.Context, invite *model.InviteCode) *InviteRepositoryMockCreateExpectation {
	if mmCreate.mock.funcCreate != nil {
		mmCreate.mock.t.Fatalf("InviteRepositoryMock.Create mock is already set by Set")
	}

	expectation := &InviteRepositoryMockCreateExpectation{
		mock:               mmCreate.mock,
		params:             &InviteRepositoryMockCreateParams{ctx, invite},
		expectationOrigins: InviteRepositoryMockCreateExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCreate.expectations = append(mmCreate.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.Create return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockCreateExpectation) Then(err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockCreateResults{err}
	return e.mock
}

// Times sets number of times InviteRepository.Create should be invoked
func (mmCreate *mInviteRepositoryMockCreate) Times(n uint64) *mInviteRepositoryMockCreate {
	if n == 0 {
		mmCreate.mock.t.Fatalf("Times of InviteRepositoryMock.Create mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCreate.expectedInvocations, n)
	mmCreate.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCreate
}

func (mmCreate *mInviteRepositoryMockCreate) 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.InviteRepository
func (mmCreate *InviteRepositoryMock) Create(ctx context.Context, invite *model.InviteCode) (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, invite)
	}

	mm_params := InviteRepositoryMockCreateParams{ctx, invite}

	// 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 := InviteRepositoryMockCreateParams{ctx, invite}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmCreate.t.Errorf("InviteRepositoryMock.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.invite != nil && !minimock.Equal(*mm_want_ptrs.invite, mm_got.invite) {
				mmCreate.t.Errorf("InviteRepositoryMock.Create got unexpected parameter invite, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreate.CreateMock.defaultExpectation.expectationOrigins.originInvite, *mm_want_ptrs.invite, mm_got.invite, minimock.Diff(*mm_want_ptrs.invite, mm_got.invite))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmCreate.t.Errorf("InviteRepositoryMock.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 InviteRepositoryMock.Create")
		}
		return (*mm_results).err
	}
	if mmCreate.funcCreate != nil {
		return mmCreate.funcCreate(ctx, invite)
	}
	mmCreate.t.Fatalf("Unexpected call to InviteRepositoryMock.Create. %v %v", ctx, invite)
	return
}

// CreateAfterCounter returns a count of finished InviteRepositoryMock.Create invocations
func (mmCreate *InviteRepositoryMock) CreateAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreate.afterCreateCounter)
}

// CreateBeforeCounter returns a count of InviteRepositoryMock.Create invocations
func (mmCreate *InviteRepositoryMock) CreateBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreate.beforeCreateCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.Create.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCreate *mInviteRepositoryMockCreate) Calls() []*InviteRepositoryMockCreateParams {
	mmCreate.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockCreateParams, 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 *InviteRepositoryMock) 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 *InviteRepositoryMock) MinimockCreateInspect() {
	for _, e := range m.CreateMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.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 InviteRepositoryMock.Create at\n%s", m.CreateMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.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 InviteRepositoryMock.Create at\n%s", m.funcCreateOrigin)
	}

	if !m.CreateMock.invocationsDone() && afterCreateCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.Create at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CreateMock.expectedInvocations), m.CreateMock.expectedInvocationsOrigin, afterCreateCounter)
	}
}

type mInviteRepositoryMockCreateTx struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockCreateTxExpectation
	expectations       []*InviteRepositoryMockCreateTxExpectation

	callArgs []*InviteRepositoryMockCreateTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockCreateTxExpectation specifies expectation struct of the InviteRepository.CreateTx
type InviteRepositoryMockCreateTxExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockCreateTxParams
	paramPtrs          *InviteRepositoryMockCreateTxParamPtrs
	expectationOrigins InviteRepositoryMockCreateTxExpectationOrigins
	results            *InviteRepositoryMockCreateTxResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockCreateTxParams contains parameters of the InviteRepository.CreateTx
type InviteRepositoryMockCreateTxParams struct {
	ctx    context.Context
	tx     pgx.Tx
	invite *model.InviteCode
}

// InviteRepositoryMockCreateTxParamPtrs contains pointers to parameters of the InviteRepository.CreateTx
type InviteRepositoryMockCreateTxParamPtrs struct {
	ctx    *context.Context
	tx     *pgx.Tx
	invite **model.InviteCode
}

// InviteRepositoryMockCreateTxResults contains results of the InviteRepository.CreateTx
type InviteRepositoryMockCreateTxResults struct {
	err error
}

// InviteRepositoryMockCreateTxOrigins contains origins of expectations of the InviteRepository.CreateTx
type InviteRepositoryMockCreateTxExpectationOrigins struct {
	origin       string
	originCtx    string
	originTx     string
	originInvite 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 (mmCreateTx *mInviteRepositoryMockCreateTx) Optional() *mInviteRepositoryMockCreateTx {
	mmCreateTx.optional = true
	return mmCreateTx
}

// Expect sets up expected params for InviteRepository.CreateTx
func (mmCreateTx *mInviteRepositoryMockCreateTx) Expect(ctx context.Context, tx pgx.Tx, invite *model.InviteCode) *mInviteRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &InviteRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.paramPtrs != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by ExpectParams functions")
	}

	mmCreateTx.defaultExpectation.params = &InviteRepositoryMockCreateTxParams{ctx, tx, invite}
	mmCreateTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmCreateTx.expectations {
		if minimock.Equal(e.params, mmCreateTx.defaultExpectation.params) {
			mmCreateTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateTx.defaultExpectation.params)
		}
	}

	return mmCreateTx
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.CreateTx
func (mmCreateTx *mInviteRepositoryMockCreateTx) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &InviteRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.params != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Expect")
	}

	if mmCreateTx.defaultExpectation.paramPtrs == nil {
		mmCreateTx.defaultExpectation.paramPtrs = &InviteRepositoryMockCreateTxParamPtrs{}
	}
	mmCreateTx.defaultExpectation.paramPtrs.ctx = &ctx
	mmCreateTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmCreateTx
}

// ExpectTxParam2 sets up expected param tx for InviteRepository.CreateTx
func (mmCreateTx *mInviteRepositoryMockCreateTx) ExpectTxParam2(tx pgx.Tx) *mInviteRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &InviteRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.params != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Expect")
	}

	if mmCreateTx.defaultExpectation.paramPtrs == nil {
		mmCreateTx.defaultExpectation.paramPtrs = &InviteRepositoryMockCreateTxParamPtrs{}
	}
	mmCreateTx.defaultExpectation.paramPtrs.tx = &tx
	mmCreateTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)

	return mmCreateTx
}

// ExpectInviteParam3 sets up expected param invite for InviteRepository.CreateTx
func (mmCreateTx *mInviteRepositoryMockCreateTx) ExpectInviteParam3(invite *model.InviteCode) *mInviteRepositoryMockCreateTx {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &InviteRepositoryMockCreateTxExpectation{}
	}

	if mmCreateTx.defaultExpectation.params != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Expect")
	}

	if mmCreateTx.defaultExpectation.paramPtrs == nil {
		mmCreateTx.defaultExpectation.paramPtrs = &InviteRepositoryMockCreateTxParamPtrs{}
	}
	mmCreateTx.defaultExpectation.paramPtrs.invite = &invite
	mmCreateTx.defaultExpectation.expectationOrigins.originInvite = minimock.CallerInfo(1)

	return mmCreateTx
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.CreateTx
func (mmCreateTx *mInviteRepositoryMockCreateTx) Inspect(f func(ctx context.Context, tx pgx.Tx, invite *model.InviteCode)) *mInviteRepositoryMockCreateTx {
	if mmCreateTx.mock.inspectFuncCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.CreateTx")
	}

	mmCreateTx.mock.inspectFuncCreateTx = f

	return mmCreateTx
}

// Return sets up results that will be returned by InviteRepository.CreateTx
func (mmCreateTx *mInviteRepositoryMockCreateTx) Return(err error) *InviteRepositoryMock {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Set")
	}

	if mmCreateTx.defaultExpectation == nil {
		mmCreateTx.defaultExpectation = &InviteRepositoryMockCreateTxExpectation{mock: mmCreateTx.mock}
	}
	mmCreateTx.defaultExpectation.results = &InviteRepositoryMockCreateTxResults{err}
	mmCreateTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCreateTx.mock
}

// Set uses given function f to mock the InviteRepository.CreateTx method
func (mmCreateTx *mInviteRepositoryMockCreateTx) Set(f func(ctx context.Context, tx pgx.Tx, invite *model.InviteCode) (err error)) *InviteRepositoryMock {
	if mmCreateTx.defaultExpectation != nil {
		mmCreateTx.mock.t.Fatalf("Default expectation is already set for the InviteRepository.CreateTx method")
	}

	if len(mmCreateTx.expectations) > 0 {
		mmCreateTx.mock.t.Fatalf("Some expectations are already set for the InviteRepository.CreateTx method")
	}

	mmCreateTx.mock.funcCreateTx = f
	mmCreateTx.mock.funcCreateTxOrigin = minimock.CallerInfo(1)
	return mmCreateTx.mock
}

// When sets expectation for the InviteRepository.CreateTx which will trigger the result defined by the following
// Then helper
func (mmCreateTx *mInviteRepositoryMockCreateTx) When(ctx context.Context, tx pgx.Tx, invite *model.InviteCode) *InviteRepositoryMockCreateTxExpectation {
	if mmCreateTx.mock.funcCreateTx != nil {
		mmCreateTx.mock.t.Fatalf("InviteRepositoryMock.CreateTx mock is already set by Set")
	}

	expectation := &InviteRepositoryMockCreateTxExpectation{
		mock:               mmCreateTx.mock,
		params:             &InviteRepositoryMockCreateTxParams{ctx, tx, invite},
		expectationOrigins: InviteRepositoryMockCreateTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCreateTx.expectations = append(mmCreateTx.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.CreateTx return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockCreateTxExpectation) Then(err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockCreateTxResults{err}
	return e.mock
}

// Times sets number of times InviteRepository.CreateTx should be invoked
func (mmCreateTx *mInviteRepositoryMockCreateTx) Times(n uint64) *mInviteRepositoryMockCreateTx {
	if n == 0 {
		mmCreateTx.mock.t.Fatalf("Times of InviteRepositoryMock.CreateTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCreateTx.expectedInvocations, n)
	mmCreateTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCreateTx
}

func (mmCreateTx *mInviteRepositoryMockCreateTx) invocationsDone() bool {
	if len(mmCreateTx.expectations) == 0 && mmCreateTx.defaultExpectation == nil && mmCreateTx.mock.funcCreateTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmCreateTx.mock.afterCreateTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmCreateTx.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// CreateTx implements mm_repository.InviteRepository
func (mmCreateTx *InviteRepositoryMock) CreateTx(ctx context.Context, tx pgx.Tx, invite *model.InviteCode) (err error) {
	mm_atomic.AddUint64(&mmCreateTx.beforeCreateTxCounter, 1)
	defer mm_atomic.AddUint64(&mmCreateTx.afterCreateTxCounter, 1)

	mmCreateTx.t.Helper()

	if mmCreateTx.inspectFuncCreateTx != nil {
		mmCreateTx.inspectFuncCreateTx(ctx, tx, invite)
	}

	mm_params := InviteRepositoryMockCreateTxParams{ctx, tx, invite}

	// Record call args
	mmCreateTx.CreateTxMock.mutex.Lock()
	mmCreateTx.CreateTxMock.callArgs = append(mmCreateTx.CreateTxMock.callArgs, &mm_params)
	mmCreateTx.CreateTxMock.mutex.Unlock()

	for _, e := range mmCreateTx.CreateTxMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmCreateTx.CreateTxMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmCreateTx.CreateTxMock.defaultExpectation.Counter, 1)
		mm_want := mmCreateTx.CreateTxMock.defaultExpectation.params
		mm_want_ptrs := mmCreateTx.CreateTxMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockCreateTxParams{ctx, tx, invite}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmCreateTx.t.Errorf("InviteRepositoryMock.CreateTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
				mmCreateTx.t.Errorf("InviteRepositoryMock.CreateTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.invite != nil && !minimock.Equal(*mm_want_ptrs.invite, mm_got.invite) {
				mmCreateTx.t.Errorf("InviteRepositoryMock.CreateTx got unexpected parameter invite, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originInvite, *mm_want_ptrs.invite, mm_got.invite, minimock.Diff(*mm_want_ptrs.invite, mm_got.invite))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmCreateTx.t.Errorf("InviteRepositoryMock.CreateTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmCreateTx.CreateTxMock.defaultExpectation.results
		if mm_results == nil {
			mmCreateTx.t.Fatal("No results are set for the InviteRepositoryMock.CreateTx")
		}
		return (*mm_results).err
	}
	if mmCreateTx.funcCreateTx != nil {
		return mmCreateTx.funcCreateTx(ctx, tx, invite)
	}
	mmCreateTx.t.Fatalf("Unexpected call to InviteRepositoryMock.CreateTx. %v %v %v", ctx, tx, invite)
	return
}

// CreateTxAfterCounter returns a count of finished InviteRepositoryMock.CreateTx invocations
func (mmCreateTx *InviteRepositoryMock) CreateTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreateTx.afterCreateTxCounter)
}

// CreateTxBeforeCounter returns a count of InviteRepositoryMock.CreateTx invocations
func (mmCreateTx *InviteRepositoryMock) CreateTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreateTx.beforeCreateTxCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.CreateTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCreateTx *mInviteRepositoryMockCreateTx) Calls() []*InviteRepositoryMockCreateTxParams {
	mmCreateTx.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockCreateTxParams, len(mmCreateTx.callArgs))
	copy(argCopy, mmCreateTx.callArgs)

	mmCreateTx.mutex.RUnlock()

	return argCopy
}

// MinimockCreateTxDone returns true if the count of the CreateTx invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockCreateTxDone() bool {
	if m.CreateTxMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.CreateTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.CreateTxMock.invocationsDone()
}

// MinimockCreateTxInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockCreateTxInspect() {
	for _, e := range m.CreateTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.CreateTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterCreateTxCounter := mm_atomic.LoadUint64(&m.afterCreateTxCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.CreateTxMock.defaultExpectation != nil && afterCreateTxCounter < 1 {
		if m.CreateTxMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.CreateTx at\n%s", m.CreateTxMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.CreateTx at\n%s with params: %#v", m.CreateTxMock.defaultExpectation.expectationOrigins.origin, *m.CreateTxMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcCreateTx != nil && afterCreateTxCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.CreateTx at\n%s", m.funcCreateTxOrigin)
	}

	if !m.CreateTxMock.invocationsDone() && afterCreateTxCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.CreateTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CreateTxMock.expectedInvocations), m.CreateTxMock.expectedInvocationsOrigin, afterCreateTxCounter)
	}
}

type mInviteRepositoryMockDeactivateExpired struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockDeactivateExpiredExpectation
	expectations       []*InviteRepositoryMockDeactivateExpiredExpectation

	callArgs []*InviteRepositoryMockDeactivateExpiredParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockDeactivateExpiredExpectation specifies expectation struct of the InviteRepository.DeactivateExpired
type InviteRepositoryMockDeactivateExpiredExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockDeactivateExpiredParams
	paramPtrs          *InviteRepositoryMockDeactivateExpiredParamPtrs
	expectationOrigins InviteRepositoryMockDeactivateExpiredExpectationOrigins
	results            *InviteRepositoryMockDeactivateExpiredResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockDeactivateExpiredParams contains parameters of the InviteRepository.DeactivateExpired
type InviteRepositoryMockDeactivateExpiredParams struct {
	ctx context.Context
}

// InviteRepositoryMockDeactivateExpiredParamPtrs contains pointers to parameters of the InviteRepository.DeactivateExpired
type InviteRepositoryMockDeactivateExpiredParamPtrs struct {
	ctx *context.Context
}

// InviteRepositoryMockDeactivateExpiredResults contains results of the InviteRepository.DeactivateExpired
type InviteRepositoryMockDeactivateExpiredResults struct {
	i1  int
	err error
}

// InviteRepositoryMockDeactivateExpiredOrigins contains origins of expectations of the InviteRepository.DeactivateExpired
type InviteRepositoryMockDeactivateExpiredExpectationOrigins struct {
	origin    string
	originCtx 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 (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Optional() *mInviteRepositoryMockDeactivateExpired {
	mmDeactivateExpired.optional = true
	return mmDeactivateExpired
}

// Expect sets up expected params for InviteRepository.DeactivateExpired
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Expect(ctx context.Context) *mInviteRepositoryMockDeactivateExpired {
	if mmDeactivateExpired.mock.funcDeactivateExpired != nil {
		mmDeactivateExpired.mock.t.Fatalf("InviteRepositoryMock.DeactivateExpired mock is already set by Set")
	}

	if mmDeactivateExpired.defaultExpectation == nil {
		mmDeactivateExpired.defaultExpectation = &InviteRepositoryMockDeactivateExpiredExpectation{}
	}

	if mmDeactivateExpired.defaultExpectation.paramPtrs != nil {
		mmDeactivateExpired.mock.t.Fatalf("InviteRepositoryMock.DeactivateExpired mock is already set by ExpectParams functions")
	}

	mmDeactivateExpired.defaultExpectation.params = &InviteRepositoryMockDeactivateExpiredParams{ctx}
	mmDeactivateExpired.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmDeactivateExpired.expectations {
		if minimock.Equal(e.params, mmDeactivateExpired.defaultExpectation.params) {
			mmDeactivateExpired.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDeactivateExpired.defaultExpectation.params)
		}
	}

	return mmDeactivateExpired
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.DeactivateExpired
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockDeactivateExpired {
	if mmDeactivateExpired.mock.funcDeactivateExpired != nil {
		mmDeactivateExpired.mock.t.Fatalf("InviteRepositoryMock.DeactivateExpired mock is already set by Set")
	}

	if mmDeactivateExpired.defaultExpectation == nil {
		mmDeactivateExpired.defaultExpectation = &InviteRepositoryMockDeactivateExpiredExpectation{}
	}

	if mmDeactivateExpired.defaultExpectation.params != nil {
		mmDeactivateExpired.mock.t.Fatalf("InviteRepositoryMock.DeactivateExpired mock is already set by Expect")
	}

	if mmDeactivateExpired.defaultExpectation.paramPtrs == nil {
		mmDeactivateExpired.defaultExpectation.paramPtrs = &InviteRepositoryMockDeactivateExpiredParamPtrs{}
	}
	mmDeactivateExpired.defaultExpectation.paramPtrs.ctx = &ctx
	mmDeactivateExpired.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmDeactivateExpired
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.DeactivateExpired
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Inspect(f func(ctx context.Context)) *mInviteRepositoryMockDeactivateExpired {
	if mmDeactivateExpired.mock.inspectFuncDeactivateExpired != nil {
		mmDeactivateExpired.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.DeactivateExpired")
	}

	mmDeactivateExpired.mock.inspectFuncDeactivateExpired = f

	return mmDeactivateExpired
}

// Return sets up results that will be returned by InviteRepository.DeactivateExpired
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Return(i1 int, err error) *InviteRepositoryMock {
	if mmDeactivateExpired.mock.funcDeactivateExpired != nil {
		mmDeactivateExpired.mock.t.Fatalf("InviteRepositoryMock.DeactivateExpired mock is already set by Set")
	}

	if mmDeactivateExpired.defaultExpectation == nil {
		mmDeactivateExpired.defaultExpectation = &InviteRepositoryMockDeactivateExpiredExpectation{mock: mmDeactivateExpired.mock}
	}
	mmDeactivateExpired.defaultExpectation.results = &InviteRepositoryMockDeactivateExpiredResults{i1, err}
	mmDeactivateExpired.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmDeactivateExpired.mock
}

// Set uses given function f to mock the InviteRepository.DeactivateExpired method
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Set(f func(ctx context.Context) (i1 int, err error)) *InviteRepositoryMock {
	if mmDeactivateExpired.defaultExpectation != nil {
		mmDeactivateExpired.mock.t.Fatalf("Default expectation is already set for the InviteRepository.DeactivateExpired method")
	}

	if len(mmDeactivateExpired.expectations) > 0 {
		mmDeactivateExpired.mock.t.Fatalf("Some expectations are already set for the InviteRepository.DeactivateExpired method")
	}

	mmDeactivateExpired.mock.funcDeactivateExpired = f
	mmDeactivateExpired.mock.funcDeactivateExpiredOrigin = minimock.CallerInfo(1)
	return mmDeactivateExpired.mock
}

// When sets expectation for the InviteRepository.DeactivateExpired which will trigger the result defined by the following
// Then helper
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) When(ctx context.Context) *InviteRepositoryMockDeactivateExpiredExpectation {
	if mmDeactivateExpired.mock.funcDeactivateExpired != nil {
		mmDeactivateExpired.mock.t.Fatalf("InviteRepositoryMock.DeactivateExpired mock is already set by Set")
	}

	expectation := &InviteRepositoryMockDeactivateExpiredExpectation{
		mock:               mmDeactivateExpired.mock,
		params:             &InviteRepositoryMockDeactivateExpiredParams{ctx},
		expectationOrigins: InviteRepositoryMockDeactivateExpiredExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmDeactivateExpired.expectations = append(mmDeactivateExpired.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.DeactivateExpired return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockDeactivateExpiredExpectation) Then(i1 int, err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockDeactivateExpiredResults{i1, err}
	return e.mock
}

// Times sets number of times InviteRepository.DeactivateExpired should be invoked
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Times(n uint64) *mInviteRepositoryMockDeactivateExpired {
	if n == 0 {
		mmDeactivateExpired.mock.t.Fatalf("Times of InviteRepositoryMock.DeactivateExpired mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmDeactivateExpired.expectedInvocations, n)
	mmDeactivateExpired.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmDeactivateExpired
}

func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) invocationsDone() bool {
	if len(mmDeactivateExpired.expectations) == 0 && mmDeactivateExpired.defaultExpectation == nil && mmDeactivateExpired.mock.funcDeactivateExpired == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmDeactivateExpired.mock.afterDeactivateExpiredCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmDeactivateExpired.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// DeactivateExpired implements mm_repository.InviteRepository
func (mmDeactivateExpired *InviteRepositoryMock) DeactivateExpired(ctx context.Context) (i1 int, err error) {
	mm_atomic.AddUint64(&mmDeactivateExpired.beforeDeactivateExpiredCounter, 1)
	defer mm_atomic.AddUint64(&mmDeactivateExpired.afterDeactivateExpiredCounter, 1)

	mmDeactivateExpired.t.Helper()

	if mmDeactivateExpired.inspectFuncDeactivateExpired != nil {
		mmDeactivateExpired.inspectFuncDeactivateExpired(ctx)
	}

	mm_params := InviteRepositoryMockDeactivateExpiredParams{ctx}

	// Record call args
	mmDeactivateExpired.DeactivateExpiredMock.mutex.Lock()
	mmDeactivateExpired.DeactivateExpiredMock.callArgs = append(mmDeactivateExpired.DeactivateExpiredMock.callArgs, &mm_params)
	mmDeactivateExpired.DeactivateExpiredMock.mutex.Unlock()

	for _, e := range mmDeactivateExpired.DeactivateExpiredMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.i1, e.results.err
		}
	}

	if mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation.Counter, 1)
		mm_want := mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation.params
		mm_want_ptrs := mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockDeactivateExpiredParams{ctx}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmDeactivateExpired.t.Errorf("InviteRepositoryMock.DeactivateExpired got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmDeactivateExpired.t.Errorf("InviteRepositoryMock.DeactivateExpired got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmDeactivateExpired.DeactivateExpiredMock.defaultExpectation.results
		if mm_results == nil {
			mmDeactivateExpired.t.Fatal("No results are set for the InviteRepositoryMock.DeactivateExpired")
		}
		return (*mm_results).i1, (*mm_results).err
	}
	if mmDeactivateExpired.funcDeactivateExpired != nil {
		return mmDeactivateExpired.funcDeactivateExpired(ctx)
	}
	mmDeactivateExpired.t.Fatalf("Unexpected call to InviteRepositoryMock.DeactivateExpired. %v", ctx)
	return
}

// DeactivateExpiredAfterCounter returns a count of finished InviteRepositoryMock.DeactivateExpired invocations
func (mmDeactivateExpired *InviteRepositoryMock) DeactivateExpiredAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDeactivateExpired.afterDeactivateExpiredCounter)
}

// DeactivateExpiredBeforeCounter returns a count of InviteRepositoryMock.DeactivateExpired invocations
func (mmDeactivateExpired *InviteRepositoryMock) DeactivateExpiredBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDeactivateExpired.beforeDeactivateExpiredCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.DeactivateExpired.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmDeactivateExpired *mInviteRepositoryMockDeactivateExpired) Calls() []*InviteRepositoryMockDeactivateExpiredParams {
	mmDeactivateExpired.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockDeactivateExpiredParams, len(mmDeactivateExpired.callArgs))
	copy(argCopy, mmDeactivateExpired.callArgs)

	mmDeactivateExpired.mutex.RUnlock()

	return argCopy
}

// MinimockDeactivateExpiredDone returns true if the count of the DeactivateExpired invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockDeactivateExpiredDone() bool {
	if m.DeactivateExpiredMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.DeactivateExpiredMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.DeactivateExpiredMock.invocationsDone()
}

// MinimockDeactivateExpiredInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockDeactivateExpiredInspect() {
	for _, e := range m.DeactivateExpiredMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.DeactivateExpired at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterDeactivateExpiredCounter := mm_atomic.LoadUint64(&m.afterDeactivateExpiredCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.DeactivateExpiredMock.defaultExpectation != nil && afterDeactivateExpiredCounter < 1 {
		if m.DeactivateExpiredMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.DeactivateExpired at\n%s", m.DeactivateExpiredMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.DeactivateExpired at\n%s with params: %#v", m.DeactivateExpiredMock.defaultExpectation.expectationOrigins.origin, *m.DeactivateExpiredMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcDeactivateExpired != nil && afterDeactivateExpiredCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.DeactivateExpired at\n%s", m.funcDeactivateExpiredOrigin)
	}

	if !m.DeactivateExpiredMock.invocationsDone() && afterDeactivateExpiredCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.DeactivateExpired at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.DeactivateExpiredMock.expectedInvocations), m.DeactivateExpiredMock.expectedInvocationsOrigin, afterDeactivateExpiredCounter)
	}
}

type mInviteRepositoryMockDecrementCanBeUsedCountTx struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockDecrementCanBeUsedCountTxExpectation
	expectations       []*InviteRepositoryMockDecrementCanBeUsedCountTxExpectation

	callArgs []*InviteRepositoryMockDecrementCanBeUsedCountTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockDecrementCanBeUsedCountTxExpectation specifies expectation struct of the InviteRepository.DecrementCanBeUsedCountTx
type InviteRepositoryMockDecrementCanBeUsedCountTxExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockDecrementCanBeUsedCountTxParams
	paramPtrs          *InviteRepositoryMockDecrementCanBeUsedCountTxParamPtrs
	expectationOrigins InviteRepositoryMockDecrementCanBeUsedCountTxExpectationOrigins
	results            *InviteRepositoryMockDecrementCanBeUsedCountTxResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockDecrementCanBeUsedCountTxParams contains parameters of the InviteRepository.DecrementCanBeUsedCountTx
type InviteRepositoryMockDecrementCanBeUsedCountTxParams struct {
	ctx  context.Context
	tx   pgx.Tx
	code int64
}

// InviteRepositoryMockDecrementCanBeUsedCountTxParamPtrs contains pointers to parameters of the InviteRepository.DecrementCanBeUsedCountTx
type InviteRepositoryMockDecrementCanBeUsedCountTxParamPtrs struct {
	ctx  *context.Context
	tx   *pgx.Tx
	code *int64
}

// InviteRepositoryMockDecrementCanBeUsedCountTxResults contains results of the InviteRepository.DecrementCanBeUsedCountTx
type InviteRepositoryMockDecrementCanBeUsedCountTxResults struct {
	err error
}

// InviteRepositoryMockDecrementCanBeUsedCountTxOrigins contains origins of expectations of the InviteRepository.DecrementCanBeUsedCountTx
type InviteRepositoryMockDecrementCanBeUsedCountTxExpectationOrigins struct {
	origin     string
	originCtx  string
	originTx   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 (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Optional() *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	mmDecrementCanBeUsedCountTx.optional = true
	return mmDecrementCanBeUsedCountTx
}

// Expect sets up expected params for InviteRepository.DecrementCanBeUsedCountTx
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Expect(ctx context.Context, tx pgx.Tx, code int64) *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	if mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Set")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation = &InviteRepositoryMockDecrementCanBeUsedCountTxExpectation{}
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by ExpectParams functions")
	}

	mmDecrementCanBeUsedCountTx.defaultExpectation.params = &InviteRepositoryMockDecrementCanBeUsedCountTxParams{ctx, tx, code}
	mmDecrementCanBeUsedCountTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmDecrementCanBeUsedCountTx.expectations {
		if minimock.Equal(e.params, mmDecrementCanBeUsedCountTx.defaultExpectation.params) {
			mmDecrementCanBeUsedCountTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDecrementCanBeUsedCountTx.defaultExpectation.params)
		}
	}

	return mmDecrementCanBeUsedCountTx
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.DecrementCanBeUsedCountTx
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	if mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Set")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation = &InviteRepositoryMockDecrementCanBeUsedCountTxExpectation{}
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.params != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Expect")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs = &InviteRepositoryMockDecrementCanBeUsedCountTxParamPtrs{}
	}
	mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs.ctx = &ctx
	mmDecrementCanBeUsedCountTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmDecrementCanBeUsedCountTx
}

// ExpectTxParam2 sets up expected param tx for InviteRepository.DecrementCanBeUsedCountTx
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) ExpectTxParam2(tx pgx.Tx) *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	if mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Set")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation = &InviteRepositoryMockDecrementCanBeUsedCountTxExpectation{}
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.params != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Expect")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs = &InviteRepositoryMockDecrementCanBeUsedCountTxParamPtrs{}
	}
	mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs.tx = &tx
	mmDecrementCanBeUsedCountTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)

	return mmDecrementCanBeUsedCountTx
}

// ExpectCodeParam3 sets up expected param code for InviteRepository.DecrementCanBeUsedCountTx
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) ExpectCodeParam3(code int64) *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	if mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Set")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation = &InviteRepositoryMockDecrementCanBeUsedCountTxExpectation{}
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.params != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Expect")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs = &InviteRepositoryMockDecrementCanBeUsedCountTxParamPtrs{}
	}
	mmDecrementCanBeUsedCountTx.defaultExpectation.paramPtrs.code = &code
	mmDecrementCanBeUsedCountTx.defaultExpectation.expectationOrigins.originCode = minimock.CallerInfo(1)

	return mmDecrementCanBeUsedCountTx
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.DecrementCanBeUsedCountTx
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Inspect(f func(ctx context.Context, tx pgx.Tx, code int64)) *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	if mmDecrementCanBeUsedCountTx.mock.inspectFuncDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.DecrementCanBeUsedCountTx")
	}

	mmDecrementCanBeUsedCountTx.mock.inspectFuncDecrementCanBeUsedCountTx = f

	return mmDecrementCanBeUsedCountTx
}

// Return sets up results that will be returned by InviteRepository.DecrementCanBeUsedCountTx
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Return(err error) *InviteRepositoryMock {
	if mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Set")
	}

	if mmDecrementCanBeUsedCountTx.defaultExpectation == nil {
		mmDecrementCanBeUsedCountTx.defaultExpectation = &InviteRepositoryMockDecrementCanBeUsedCountTxExpectation{mock: mmDecrementCanBeUsedCountTx.mock}
	}
	mmDecrementCanBeUsedCountTx.defaultExpectation.results = &InviteRepositoryMockDecrementCanBeUsedCountTxResults{err}
	mmDecrementCanBeUsedCountTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmDecrementCanBeUsedCountTx.mock
}

// Set uses given function f to mock the InviteRepository.DecrementCanBeUsedCountTx method
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Set(f func(ctx context.Context, tx pgx.Tx, code int64) (err error)) *InviteRepositoryMock {
	if mmDecrementCanBeUsedCountTx.defaultExpectation != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("Default expectation is already set for the InviteRepository.DecrementCanBeUsedCountTx method")
	}

	if len(mmDecrementCanBeUsedCountTx.expectations) > 0 {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("Some expectations are already set for the InviteRepository.DecrementCanBeUsedCountTx method")
	}

	mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx = f
	mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTxOrigin = minimock.CallerInfo(1)
	return mmDecrementCanBeUsedCountTx.mock
}

// When sets expectation for the InviteRepository.DecrementCanBeUsedCountTx which will trigger the result defined by the following
// Then helper
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) When(ctx context.Context, tx pgx.Tx, code int64) *InviteRepositoryMockDecrementCanBeUsedCountTxExpectation {
	if mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("InviteRepositoryMock.DecrementCanBeUsedCountTx mock is already set by Set")
	}

	expectation := &InviteRepositoryMockDecrementCanBeUsedCountTxExpectation{
		mock:               mmDecrementCanBeUsedCountTx.mock,
		params:             &InviteRepositoryMockDecrementCanBeUsedCountTxParams{ctx, tx, code},
		expectationOrigins: InviteRepositoryMockDecrementCanBeUsedCountTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmDecrementCanBeUsedCountTx.expectations = append(mmDecrementCanBeUsedCountTx.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.DecrementCanBeUsedCountTx return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockDecrementCanBeUsedCountTxExpectation) Then(err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockDecrementCanBeUsedCountTxResults{err}
	return e.mock
}

// Times sets number of times InviteRepository.DecrementCanBeUsedCountTx should be invoked
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Times(n uint64) *mInviteRepositoryMockDecrementCanBeUsedCountTx {
	if n == 0 {
		mmDecrementCanBeUsedCountTx.mock.t.Fatalf("Times of InviteRepositoryMock.DecrementCanBeUsedCountTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmDecrementCanBeUsedCountTx.expectedInvocations, n)
	mmDecrementCanBeUsedCountTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmDecrementCanBeUsedCountTx
}

func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) invocationsDone() bool {
	if len(mmDecrementCanBeUsedCountTx.expectations) == 0 && mmDecrementCanBeUsedCountTx.defaultExpectation == nil && mmDecrementCanBeUsedCountTx.mock.funcDecrementCanBeUsedCountTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmDecrementCanBeUsedCountTx.mock.afterDecrementCanBeUsedCountTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmDecrementCanBeUsedCountTx.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// DecrementCanBeUsedCountTx implements mm_repository.InviteRepository
func (mmDecrementCanBeUsedCountTx *InviteRepositoryMock) DecrementCanBeUsedCountTx(ctx context.Context, tx pgx.Tx, code int64) (err error) {
	mm_atomic.AddUint64(&mmDecrementCanBeUsedCountTx.beforeDecrementCanBeUsedCountTxCounter, 1)
	defer mm_atomic.AddUint64(&mmDecrementCanBeUsedCountTx.afterDecrementCanBeUsedCountTxCounter, 1)

	mmDecrementCanBeUsedCountTx.t.Helper()

	if mmDecrementCanBeUsedCountTx.inspectFuncDecrementCanBeUsedCountTx != nil {
		mmDecrementCanBeUsedCountTx.inspectFuncDecrementCanBeUsedCountTx(ctx, tx, code)
	}

	mm_params := InviteRepositoryMockDecrementCanBeUsedCountTxParams{ctx, tx, code}

	// Record call args
	mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.mutex.Lock()
	mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.callArgs = append(mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.callArgs, &mm_params)
	mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.mutex.Unlock()

	for _, e := range mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.Counter, 1)
		mm_want := mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.params
		mm_want_ptrs := mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockDecrementCanBeUsedCountTxParams{ctx, tx, code}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmDecrementCanBeUsedCountTx.t.Errorf("InviteRepositoryMock.DecrementCanBeUsedCountTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
			}

			if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
				mmDecrementCanBeUsedCountTx.t.Errorf("InviteRepositoryMock.DecrementCanBeUsedCountTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.code != nil && !minimock.Equal(*mm_want_ptrs.code, mm_got.code) {
				mmDecrementCanBeUsedCountTx.t.Errorf("InviteRepositoryMock.DecrementCanBeUsedCountTx got unexpected parameter code, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.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) {
			mmDecrementCanBeUsedCountTx.t.Errorf("InviteRepositoryMock.DecrementCanBeUsedCountTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmDecrementCanBeUsedCountTx.DecrementCanBeUsedCountTxMock.defaultExpectation.results
		if mm_results == nil {
			mmDecrementCanBeUsedCountTx.t.Fatal("No results are set for the InviteRepositoryMock.DecrementCanBeUsedCountTx")
		}
		return (*mm_results).err
	}
	if mmDecrementCanBeUsedCountTx.funcDecrementCanBeUsedCountTx != nil {
		return mmDecrementCanBeUsedCountTx.funcDecrementCanBeUsedCountTx(ctx, tx, code)
	}
	mmDecrementCanBeUsedCountTx.t.Fatalf("Unexpected call to InviteRepositoryMock.DecrementCanBeUsedCountTx. %v %v %v", ctx, tx, code)
	return
}

// DecrementCanBeUsedCountTxAfterCounter returns a count of finished InviteRepositoryMock.DecrementCanBeUsedCountTx invocations
func (mmDecrementCanBeUsedCountTx *InviteRepositoryMock) DecrementCanBeUsedCountTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDecrementCanBeUsedCountTx.afterDecrementCanBeUsedCountTxCounter)
}

// DecrementCanBeUsedCountTxBeforeCounter returns a count of InviteRepositoryMock.DecrementCanBeUsedCountTx invocations
func (mmDecrementCanBeUsedCountTx *InviteRepositoryMock) DecrementCanBeUsedCountTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDecrementCanBeUsedCountTx.beforeDecrementCanBeUsedCountTxCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.DecrementCanBeUsedCountTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmDecrementCanBeUsedCountTx *mInviteRepositoryMockDecrementCanBeUsedCountTx) Calls() []*InviteRepositoryMockDecrementCanBeUsedCountTxParams {
	mmDecrementCanBeUsedCountTx.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockDecrementCanBeUsedCountTxParams, len(mmDecrementCanBeUsedCountTx.callArgs))
	copy(argCopy, mmDecrementCanBeUsedCountTx.callArgs)

	mmDecrementCanBeUsedCountTx.mutex.RUnlock()

	return argCopy
}

// MinimockDecrementCanBeUsedCountTxDone returns true if the count of the DecrementCanBeUsedCountTx invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockDecrementCanBeUsedCountTxDone() bool {
	if m.DecrementCanBeUsedCountTxMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.DecrementCanBeUsedCountTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.DecrementCanBeUsedCountTxMock.invocationsDone()
}

// MinimockDecrementCanBeUsedCountTxInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockDecrementCanBeUsedCountTxInspect() {
	for _, e := range m.DecrementCanBeUsedCountTxMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.DecrementCanBeUsedCountTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterDecrementCanBeUsedCountTxCounter := mm_atomic.LoadUint64(&m.afterDecrementCanBeUsedCountTxCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.DecrementCanBeUsedCountTxMock.defaultExpectation != nil && afterDecrementCanBeUsedCountTxCounter < 1 {
		if m.DecrementCanBeUsedCountTxMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.DecrementCanBeUsedCountTx at\n%s", m.DecrementCanBeUsedCountTxMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.DecrementCanBeUsedCountTx at\n%s with params: %#v", m.DecrementCanBeUsedCountTxMock.defaultExpectation.expectationOrigins.origin, *m.DecrementCanBeUsedCountTxMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcDecrementCanBeUsedCountTx != nil && afterDecrementCanBeUsedCountTxCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.DecrementCanBeUsedCountTx at\n%s", m.funcDecrementCanBeUsedCountTxOrigin)
	}

	if !m.DecrementCanBeUsedCountTxMock.invocationsDone() && afterDecrementCanBeUsedCountTxCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.DecrementCanBeUsedCountTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.DecrementCanBeUsedCountTxMock.expectedInvocations), m.DecrementCanBeUsedCountTxMock.expectedInvocationsOrigin, afterDecrementCanBeUsedCountTxCounter)
	}
}

type mInviteRepositoryMockFindActiveByCode struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockFindActiveByCodeExpectation
	expectations       []*InviteRepositoryMockFindActiveByCodeExpectation

	callArgs []*InviteRepositoryMockFindActiveByCodeParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockFindActiveByCodeExpectation specifies expectation struct of the InviteRepository.FindActiveByCode
type InviteRepositoryMockFindActiveByCodeExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockFindActiveByCodeParams
	paramPtrs          *InviteRepositoryMockFindActiveByCodeParamPtrs
	expectationOrigins InviteRepositoryMockFindActiveByCodeExpectationOrigins
	results            *InviteRepositoryMockFindActiveByCodeResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockFindActiveByCodeParams contains parameters of the InviteRepository.FindActiveByCode
type InviteRepositoryMockFindActiveByCodeParams struct {
	ctx  context.Context
	code int64
}

// InviteRepositoryMockFindActiveByCodeParamPtrs contains pointers to parameters of the InviteRepository.FindActiveByCode
type InviteRepositoryMockFindActiveByCodeParamPtrs struct {
	ctx  *context.Context
	code *int64
}

// InviteRepositoryMockFindActiveByCodeResults contains results of the InviteRepository.FindActiveByCode
type InviteRepositoryMockFindActiveByCodeResults struct {
	ip1 *model.InviteCode
	err error
}

// InviteRepositoryMockFindActiveByCodeOrigins contains origins of expectations of the InviteRepository.FindActiveByCode
type InviteRepositoryMockFindActiveByCodeExpectationOrigins 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 (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Optional() *mInviteRepositoryMockFindActiveByCode {
	mmFindActiveByCode.optional = true
	return mmFindActiveByCode
}

// Expect sets up expected params for InviteRepository.FindActiveByCode
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Expect(ctx context.Context, code int64) *mInviteRepositoryMockFindActiveByCode {
	if mmFindActiveByCode.mock.funcFindActiveByCode != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Set")
	}

	if mmFindActiveByCode.defaultExpectation == nil {
		mmFindActiveByCode.defaultExpectation = &InviteRepositoryMockFindActiveByCodeExpectation{}
	}

	if mmFindActiveByCode.defaultExpectation.paramPtrs != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by ExpectParams functions")
	}

	mmFindActiveByCode.defaultExpectation.params = &InviteRepositoryMockFindActiveByCodeParams{ctx, code}
	mmFindActiveByCode.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmFindActiveByCode.expectations {
		if minimock.Equal(e.params, mmFindActiveByCode.defaultExpectation.params) {
			mmFindActiveByCode.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindActiveByCode.defaultExpectation.params)
		}
	}

	return mmFindActiveByCode
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.FindActiveByCode
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockFindActiveByCode {
	if mmFindActiveByCode.mock.funcFindActiveByCode != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Set")
	}

	if mmFindActiveByCode.defaultExpectation == nil {
		mmFindActiveByCode.defaultExpectation = &InviteRepositoryMockFindActiveByCodeExpectation{}
	}

	if mmFindActiveByCode.defaultExpectation.params != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Expect")
	}

	if mmFindActiveByCode.defaultExpectation.paramPtrs == nil {
		mmFindActiveByCode.defaultExpectation.paramPtrs = &InviteRepositoryMockFindActiveByCodeParamPtrs{}
	}
	mmFindActiveByCode.defaultExpectation.paramPtrs.ctx = &ctx
	mmFindActiveByCode.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmFindActiveByCode
}

// ExpectCodeParam2 sets up expected param code for InviteRepository.FindActiveByCode
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) ExpectCodeParam2(code int64) *mInviteRepositoryMockFindActiveByCode {
	if mmFindActiveByCode.mock.funcFindActiveByCode != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Set")
	}

	if mmFindActiveByCode.defaultExpectation == nil {
		mmFindActiveByCode.defaultExpectation = &InviteRepositoryMockFindActiveByCodeExpectation{}
	}

	if mmFindActiveByCode.defaultExpectation.params != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Expect")
	}

	if mmFindActiveByCode.defaultExpectation.paramPtrs == nil {
		mmFindActiveByCode.defaultExpectation.paramPtrs = &InviteRepositoryMockFindActiveByCodeParamPtrs{}
	}
	mmFindActiveByCode.defaultExpectation.paramPtrs.code = &code
	mmFindActiveByCode.defaultExpectation.expectationOrigins.originCode = minimock.CallerInfo(1)

	return mmFindActiveByCode
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.FindActiveByCode
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Inspect(f func(ctx context.Context, code int64)) *mInviteRepositoryMockFindActiveByCode {
	if mmFindActiveByCode.mock.inspectFuncFindActiveByCode != nil {
		mmFindActiveByCode.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.FindActiveByCode")
	}

	mmFindActiveByCode.mock.inspectFuncFindActiveByCode = f

	return mmFindActiveByCode
}

// Return sets up results that will be returned by InviteRepository.FindActiveByCode
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Return(ip1 *model.InviteCode, err error) *InviteRepositoryMock {
	if mmFindActiveByCode.mock.funcFindActiveByCode != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Set")
	}

	if mmFindActiveByCode.defaultExpectation == nil {
		mmFindActiveByCode.defaultExpectation = &InviteRepositoryMockFindActiveByCodeExpectation{mock: mmFindActiveByCode.mock}
	}
	mmFindActiveByCode.defaultExpectation.results = &InviteRepositoryMockFindActiveByCodeResults{ip1, err}
	mmFindActiveByCode.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmFindActiveByCode.mock
}

// Set uses given function f to mock the InviteRepository.FindActiveByCode method
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Set(f func(ctx context.Context, code int64) (ip1 *model.InviteCode, err error)) *InviteRepositoryMock {
	if mmFindActiveByCode.defaultExpectation != nil {
		mmFindActiveByCode.mock.t.Fatalf("Default expectation is already set for the InviteRepository.FindActiveByCode method")
	}

	if len(mmFindActiveByCode.expectations) > 0 {
		mmFindActiveByCode.mock.t.Fatalf("Some expectations are already set for the InviteRepository.FindActiveByCode method")
	}

	mmFindActiveByCode.mock.funcFindActiveByCode = f
	mmFindActiveByCode.mock.funcFindActiveByCodeOrigin = minimock.CallerInfo(1)
	return mmFindActiveByCode.mock
}

// When sets expectation for the InviteRepository.FindActiveByCode which will trigger the result defined by the following
// Then helper
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) When(ctx context.Context, code int64) *InviteRepositoryMockFindActiveByCodeExpectation {
	if mmFindActiveByCode.mock.funcFindActiveByCode != nil {
		mmFindActiveByCode.mock.t.Fatalf("InviteRepositoryMock.FindActiveByCode mock is already set by Set")
	}

	expectation := &InviteRepositoryMockFindActiveByCodeExpectation{
		mock:               mmFindActiveByCode.mock,
		params:             &InviteRepositoryMockFindActiveByCodeParams{ctx, code},
		expectationOrigins: InviteRepositoryMockFindActiveByCodeExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmFindActiveByCode.expectations = append(mmFindActiveByCode.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.FindActiveByCode return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockFindActiveByCodeExpectation) Then(ip1 *model.InviteCode, err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockFindActiveByCodeResults{ip1, err}
	return e.mock
}

// Times sets number of times InviteRepository.FindActiveByCode should be invoked
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Times(n uint64) *mInviteRepositoryMockFindActiveByCode {
	if n == 0 {
		mmFindActiveByCode.mock.t.Fatalf("Times of InviteRepositoryMock.FindActiveByCode mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmFindActiveByCode.expectedInvocations, n)
	mmFindActiveByCode.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmFindActiveByCode
}

func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) invocationsDone() bool {
	if len(mmFindActiveByCode.expectations) == 0 && mmFindActiveByCode.defaultExpectation == nil && mmFindActiveByCode.mock.funcFindActiveByCode == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmFindActiveByCode.mock.afterFindActiveByCodeCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmFindActiveByCode.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// FindActiveByCode implements mm_repository.InviteRepository
func (mmFindActiveByCode *InviteRepositoryMock) FindActiveByCode(ctx context.Context, code int64) (ip1 *model.InviteCode, err error) {
	mm_atomic.AddUint64(&mmFindActiveByCode.beforeFindActiveByCodeCounter, 1)
	defer mm_atomic.AddUint64(&mmFindActiveByCode.afterFindActiveByCodeCounter, 1)

	mmFindActiveByCode.t.Helper()

	if mmFindActiveByCode.inspectFuncFindActiveByCode != nil {
		mmFindActiveByCode.inspectFuncFindActiveByCode(ctx, code)
	}

	mm_params := InviteRepositoryMockFindActiveByCodeParams{ctx, code}

	// Record call args
	mmFindActiveByCode.FindActiveByCodeMock.mutex.Lock()
	mmFindActiveByCode.FindActiveByCodeMock.callArgs = append(mmFindActiveByCode.FindActiveByCodeMock.callArgs, &mm_params)
	mmFindActiveByCode.FindActiveByCodeMock.mutex.Unlock()

	for _, e := range mmFindActiveByCode.FindActiveByCodeMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.ip1, e.results.err
		}
	}

	if mmFindActiveByCode.FindActiveByCodeMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmFindActiveByCode.FindActiveByCodeMock.defaultExpectation.Counter, 1)
		mm_want := mmFindActiveByCode.FindActiveByCodeMock.defaultExpectation.params
		mm_want_ptrs := mmFindActiveByCode.FindActiveByCodeMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockFindActiveByCodeParams{ctx, code}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmFindActiveByCode.t.Errorf("InviteRepositoryMock.FindActiveByCode got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindActiveByCode.FindActiveByCodeMock.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) {
				mmFindActiveByCode.t.Errorf("InviteRepositoryMock.FindActiveByCode got unexpected parameter code, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindActiveByCode.FindActiveByCodeMock.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) {
			mmFindActiveByCode.t.Errorf("InviteRepositoryMock.FindActiveByCode got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmFindActiveByCode.FindActiveByCodeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmFindActiveByCode.FindActiveByCodeMock.defaultExpectation.results
		if mm_results == nil {
			mmFindActiveByCode.t.Fatal("No results are set for the InviteRepositoryMock.FindActiveByCode")
		}
		return (*mm_results).ip1, (*mm_results).err
	}
	if mmFindActiveByCode.funcFindActiveByCode != nil {
		return mmFindActiveByCode.funcFindActiveByCode(ctx, code)
	}
	mmFindActiveByCode.t.Fatalf("Unexpected call to InviteRepositoryMock.FindActiveByCode. %v %v", ctx, code)
	return
}

// FindActiveByCodeAfterCounter returns a count of finished InviteRepositoryMock.FindActiveByCode invocations
func (mmFindActiveByCode *InviteRepositoryMock) FindActiveByCodeAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindActiveByCode.afterFindActiveByCodeCounter)
}

// FindActiveByCodeBeforeCounter returns a count of InviteRepositoryMock.FindActiveByCode invocations
func (mmFindActiveByCode *InviteRepositoryMock) FindActiveByCodeBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindActiveByCode.beforeFindActiveByCodeCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.FindActiveByCode.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmFindActiveByCode *mInviteRepositoryMockFindActiveByCode) Calls() []*InviteRepositoryMockFindActiveByCodeParams {
	mmFindActiveByCode.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockFindActiveByCodeParams, len(mmFindActiveByCode.callArgs))
	copy(argCopy, mmFindActiveByCode.callArgs)

	mmFindActiveByCode.mutex.RUnlock()

	return argCopy
}

// MinimockFindActiveByCodeDone returns true if the count of the FindActiveByCode invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockFindActiveByCodeDone() bool {
	if m.FindActiveByCodeMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.FindActiveByCodeMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.FindActiveByCodeMock.invocationsDone()
}

// MinimockFindActiveByCodeInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockFindActiveByCodeInspect() {
	for _, e := range m.FindActiveByCodeMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByCode at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterFindActiveByCodeCounter := mm_atomic.LoadUint64(&m.afterFindActiveByCodeCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.FindActiveByCodeMock.defaultExpectation != nil && afterFindActiveByCodeCounter < 1 {
		if m.FindActiveByCodeMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByCode at\n%s", m.FindActiveByCodeMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByCode at\n%s with params: %#v", m.FindActiveByCodeMock.defaultExpectation.expectationOrigins.origin, *m.FindActiveByCodeMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcFindActiveByCode != nil && afterFindActiveByCodeCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByCode at\n%s", m.funcFindActiveByCodeOrigin)
	}

	if !m.FindActiveByCodeMock.invocationsDone() && afterFindActiveByCodeCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.FindActiveByCode at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.FindActiveByCodeMock.expectedInvocations), m.FindActiveByCodeMock.expectedInvocationsOrigin, afterFindActiveByCodeCounter)
	}
}

type mInviteRepositoryMockFindActiveByUserID struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockFindActiveByUserIDExpectation
	expectations       []*InviteRepositoryMockFindActiveByUserIDExpectation

	callArgs []*InviteRepositoryMockFindActiveByUserIDParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockFindActiveByUserIDExpectation specifies expectation struct of the InviteRepository.FindActiveByUserID
type InviteRepositoryMockFindActiveByUserIDExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockFindActiveByUserIDParams
	paramPtrs          *InviteRepositoryMockFindActiveByUserIDParamPtrs
	expectationOrigins InviteRepositoryMockFindActiveByUserIDExpectationOrigins
	results            *InviteRepositoryMockFindActiveByUserIDResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockFindActiveByUserIDParams contains parameters of the InviteRepository.FindActiveByUserID
type InviteRepositoryMockFindActiveByUserIDParams struct {
	ctx    context.Context
	userID int
}

// InviteRepositoryMockFindActiveByUserIDParamPtrs contains pointers to parameters of the InviteRepository.FindActiveByUserID
type InviteRepositoryMockFindActiveByUserIDParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// InviteRepositoryMockFindActiveByUserIDResults contains results of the InviteRepository.FindActiveByUserID
type InviteRepositoryMockFindActiveByUserIDResults struct {
	ip1 *model.InviteCode
	err error
}

// InviteRepositoryMockFindActiveByUserIDOrigins contains origins of expectations of the InviteRepository.FindActiveByUserID
type InviteRepositoryMockFindActiveByUserIDExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID 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 (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Optional() *mInviteRepositoryMockFindActiveByUserID {
	mmFindActiveByUserID.optional = true
	return mmFindActiveByUserID
}

// Expect sets up expected params for InviteRepository.FindActiveByUserID
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Expect(ctx context.Context, userID int) *mInviteRepositoryMockFindActiveByUserID {
	if mmFindActiveByUserID.mock.funcFindActiveByUserID != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Set")
	}

	if mmFindActiveByUserID.defaultExpectation == nil {
		mmFindActiveByUserID.defaultExpectation = &InviteRepositoryMockFindActiveByUserIDExpectation{}
	}

	if mmFindActiveByUserID.defaultExpectation.paramPtrs != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by ExpectParams functions")
	}

	mmFindActiveByUserID.defaultExpectation.params = &InviteRepositoryMockFindActiveByUserIDParams{ctx, userID}
	mmFindActiveByUserID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmFindActiveByUserID.expectations {
		if minimock.Equal(e.params, mmFindActiveByUserID.defaultExpectation.params) {
			mmFindActiveByUserID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindActiveByUserID.defaultExpectation.params)
		}
	}

	return mmFindActiveByUserID
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.FindActiveByUserID
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockFindActiveByUserID {
	if mmFindActiveByUserID.mock.funcFindActiveByUserID != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Set")
	}

	if mmFindActiveByUserID.defaultExpectation == nil {
		mmFindActiveByUserID.defaultExpectation = &InviteRepositoryMockFindActiveByUserIDExpectation{}
	}

	if mmFindActiveByUserID.defaultExpectation.params != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Expect")
	}

	if mmFindActiveByUserID.defaultExpectation.paramPtrs == nil {
		mmFindActiveByUserID.defaultExpectation.paramPtrs = &InviteRepositoryMockFindActiveByUserIDParamPtrs{}
	}
	mmFindActiveByUserID.defaultExpectation.paramPtrs.ctx = &ctx
	mmFindActiveByUserID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmFindActiveByUserID
}

// ExpectUserIDParam2 sets up expected param userID for InviteRepository.FindActiveByUserID
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) ExpectUserIDParam2(userID int) *mInviteRepositoryMockFindActiveByUserID {
	if mmFindActiveByUserID.mock.funcFindActiveByUserID != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Set")
	}

	if mmFindActiveByUserID.defaultExpectation == nil {
		mmFindActiveByUserID.defaultExpectation = &InviteRepositoryMockFindActiveByUserIDExpectation{}
	}

	if mmFindActiveByUserID.defaultExpectation.params != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Expect")
	}

	if mmFindActiveByUserID.defaultExpectation.paramPtrs == nil {
		mmFindActiveByUserID.defaultExpectation.paramPtrs = &InviteRepositoryMockFindActiveByUserIDParamPtrs{}
	}
	mmFindActiveByUserID.defaultExpectation.paramPtrs.userID = &userID
	mmFindActiveByUserID.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmFindActiveByUserID
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.FindActiveByUserID
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Inspect(f func(ctx context.Context, userID int)) *mInviteRepositoryMockFindActiveByUserID {
	if mmFindActiveByUserID.mock.inspectFuncFindActiveByUserID != nil {
		mmFindActiveByUserID.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.FindActiveByUserID")
	}

	mmFindActiveByUserID.mock.inspectFuncFindActiveByUserID = f

	return mmFindActiveByUserID
}

// Return sets up results that will be returned by InviteRepository.FindActiveByUserID
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Return(ip1 *model.InviteCode, err error) *InviteRepositoryMock {
	if mmFindActiveByUserID.mock.funcFindActiveByUserID != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Set")
	}

	if mmFindActiveByUserID.defaultExpectation == nil {
		mmFindActiveByUserID.defaultExpectation = &InviteRepositoryMockFindActiveByUserIDExpectation{mock: mmFindActiveByUserID.mock}
	}
	mmFindActiveByUserID.defaultExpectation.results = &InviteRepositoryMockFindActiveByUserIDResults{ip1, err}
	mmFindActiveByUserID.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmFindActiveByUserID.mock
}

// Set uses given function f to mock the InviteRepository.FindActiveByUserID method
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Set(f func(ctx context.Context, userID int) (ip1 *model.InviteCode, err error)) *InviteRepositoryMock {
	if mmFindActiveByUserID.defaultExpectation != nil {
		mmFindActiveByUserID.mock.t.Fatalf("Default expectation is already set for the InviteRepository.FindActiveByUserID method")
	}

	if len(mmFindActiveByUserID.expectations) > 0 {
		mmFindActiveByUserID.mock.t.Fatalf("Some expectations are already set for the InviteRepository.FindActiveByUserID method")
	}

	mmFindActiveByUserID.mock.funcFindActiveByUserID = f
	mmFindActiveByUserID.mock.funcFindActiveByUserIDOrigin = minimock.CallerInfo(1)
	return mmFindActiveByUserID.mock
}

// When sets expectation for the InviteRepository.FindActiveByUserID which will trigger the result defined by the following
// Then helper
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) When(ctx context.Context, userID int) *InviteRepositoryMockFindActiveByUserIDExpectation {
	if mmFindActiveByUserID.mock.funcFindActiveByUserID != nil {
		mmFindActiveByUserID.mock.t.Fatalf("InviteRepositoryMock.FindActiveByUserID mock is already set by Set")
	}

	expectation := &InviteRepositoryMockFindActiveByUserIDExpectation{
		mock:               mmFindActiveByUserID.mock,
		params:             &InviteRepositoryMockFindActiveByUserIDParams{ctx, userID},
		expectationOrigins: InviteRepositoryMockFindActiveByUserIDExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmFindActiveByUserID.expectations = append(mmFindActiveByUserID.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.FindActiveByUserID return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockFindActiveByUserIDExpectation) Then(ip1 *model.InviteCode, err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockFindActiveByUserIDResults{ip1, err}
	return e.mock
}

// Times sets number of times InviteRepository.FindActiveByUserID should be invoked
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Times(n uint64) *mInviteRepositoryMockFindActiveByUserID {
	if n == 0 {
		mmFindActiveByUserID.mock.t.Fatalf("Times of InviteRepositoryMock.FindActiveByUserID mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmFindActiveByUserID.expectedInvocations, n)
	mmFindActiveByUserID.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmFindActiveByUserID
}

func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) invocationsDone() bool {
	if len(mmFindActiveByUserID.expectations) == 0 && mmFindActiveByUserID.defaultExpectation == nil && mmFindActiveByUserID.mock.funcFindActiveByUserID == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmFindActiveByUserID.mock.afterFindActiveByUserIDCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmFindActiveByUserID.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// FindActiveByUserID implements mm_repository.InviteRepository
func (mmFindActiveByUserID *InviteRepositoryMock) FindActiveByUserID(ctx context.Context, userID int) (ip1 *model.InviteCode, err error) {
	mm_atomic.AddUint64(&mmFindActiveByUserID.beforeFindActiveByUserIDCounter, 1)
	defer mm_atomic.AddUint64(&mmFindActiveByUserID.afterFindActiveByUserIDCounter, 1)

	mmFindActiveByUserID.t.Helper()

	if mmFindActiveByUserID.inspectFuncFindActiveByUserID != nil {
		mmFindActiveByUserID.inspectFuncFindActiveByUserID(ctx, userID)
	}

	mm_params := InviteRepositoryMockFindActiveByUserIDParams{ctx, userID}

	// Record call args
	mmFindActiveByUserID.FindActiveByUserIDMock.mutex.Lock()
	mmFindActiveByUserID.FindActiveByUserIDMock.callArgs = append(mmFindActiveByUserID.FindActiveByUserIDMock.callArgs, &mm_params)
	mmFindActiveByUserID.FindActiveByUserIDMock.mutex.Unlock()

	for _, e := range mmFindActiveByUserID.FindActiveByUserIDMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.ip1, e.results.err
		}
	}

	if mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation.Counter, 1)
		mm_want := mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation.params
		mm_want_ptrs := mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockFindActiveByUserIDParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmFindActiveByUserID.t.Errorf("InviteRepositoryMock.FindActiveByUserID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindActiveByUserID.FindActiveByUserIDMock.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) {
				mmFindActiveByUserID.t.Errorf("InviteRepositoryMock.FindActiveByUserID got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmFindActiveByUserID.t.Errorf("InviteRepositoryMock.FindActiveByUserID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmFindActiveByUserID.FindActiveByUserIDMock.defaultExpectation.results
		if mm_results == nil {
			mmFindActiveByUserID.t.Fatal("No results are set for the InviteRepositoryMock.FindActiveByUserID")
		}
		return (*mm_results).ip1, (*mm_results).err
	}
	if mmFindActiveByUserID.funcFindActiveByUserID != nil {
		return mmFindActiveByUserID.funcFindActiveByUserID(ctx, userID)
	}
	mmFindActiveByUserID.t.Fatalf("Unexpected call to InviteRepositoryMock.FindActiveByUserID. %v %v", ctx, userID)
	return
}

// FindActiveByUserIDAfterCounter returns a count of finished InviteRepositoryMock.FindActiveByUserID invocations
func (mmFindActiveByUserID *InviteRepositoryMock) FindActiveByUserIDAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindActiveByUserID.afterFindActiveByUserIDCounter)
}

// FindActiveByUserIDBeforeCounter returns a count of InviteRepositoryMock.FindActiveByUserID invocations
func (mmFindActiveByUserID *InviteRepositoryMock) FindActiveByUserIDBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindActiveByUserID.beforeFindActiveByUserIDCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.FindActiveByUserID.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmFindActiveByUserID *mInviteRepositoryMockFindActiveByUserID) Calls() []*InviteRepositoryMockFindActiveByUserIDParams {
	mmFindActiveByUserID.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockFindActiveByUserIDParams, len(mmFindActiveByUserID.callArgs))
	copy(argCopy, mmFindActiveByUserID.callArgs)

	mmFindActiveByUserID.mutex.RUnlock()

	return argCopy
}

// MinimockFindActiveByUserIDDone returns true if the count of the FindActiveByUserID invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockFindActiveByUserIDDone() bool {
	if m.FindActiveByUserIDMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.FindActiveByUserIDMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.FindActiveByUserIDMock.invocationsDone()
}

// MinimockFindActiveByUserIDInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockFindActiveByUserIDInspect() {
	for _, e := range m.FindActiveByUserIDMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByUserID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterFindActiveByUserIDCounter := mm_atomic.LoadUint64(&m.afterFindActiveByUserIDCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.FindActiveByUserIDMock.defaultExpectation != nil && afterFindActiveByUserIDCounter < 1 {
		if m.FindActiveByUserIDMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByUserID at\n%s", m.FindActiveByUserIDMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByUserID at\n%s with params: %#v", m.FindActiveByUserIDMock.defaultExpectation.expectationOrigins.origin, *m.FindActiveByUserIDMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcFindActiveByUserID != nil && afterFindActiveByUserIDCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.FindActiveByUserID at\n%s", m.funcFindActiveByUserIDOrigin)
	}

	if !m.FindActiveByUserIDMock.invocationsDone() && afterFindActiveByUserIDCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.FindActiveByUserID at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.FindActiveByUserIDMock.expectedInvocations), m.FindActiveByUserIDMock.expectedInvocationsOrigin, afterFindActiveByUserIDCounter)
	}
}

type mInviteRepositoryMockFindByCode struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockFindByCodeExpectation
	expectations       []*InviteRepositoryMockFindByCodeExpectation

	callArgs []*InviteRepositoryMockFindByCodeParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockFindByCodeExpectation specifies expectation struct of the InviteRepository.FindByCode
type InviteRepositoryMockFindByCodeExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockFindByCodeParams
	paramPtrs          *InviteRepositoryMockFindByCodeParamPtrs
	expectationOrigins InviteRepositoryMockFindByCodeExpectationOrigins
	results            *InviteRepositoryMockFindByCodeResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockFindByCodeParams contains parameters of the InviteRepository.FindByCode
type InviteRepositoryMockFindByCodeParams struct {
	ctx  context.Context
	code int64
}

// InviteRepositoryMockFindByCodeParamPtrs contains pointers to parameters of the InviteRepository.FindByCode
type InviteRepositoryMockFindByCodeParamPtrs struct {
	ctx  *context.Context
	code *int64
}

// InviteRepositoryMockFindByCodeResults contains results of the InviteRepository.FindByCode
type InviteRepositoryMockFindByCodeResults struct {
	ip1 *model.InviteCode
	err error
}

// InviteRepositoryMockFindByCodeOrigins contains origins of expectations of the InviteRepository.FindByCode
type InviteRepositoryMockFindByCodeExpectationOrigins 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 (mmFindByCode *mInviteRepositoryMockFindByCode) Optional() *mInviteRepositoryMockFindByCode {
	mmFindByCode.optional = true
	return mmFindByCode
}

// Expect sets up expected params for InviteRepository.FindByCode
func (mmFindByCode *mInviteRepositoryMockFindByCode) Expect(ctx context.Context, code int64) *mInviteRepositoryMockFindByCode {
	if mmFindByCode.mock.funcFindByCode != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Set")
	}

	if mmFindByCode.defaultExpectation == nil {
		mmFindByCode.defaultExpectation = &InviteRepositoryMockFindByCodeExpectation{}
	}

	if mmFindByCode.defaultExpectation.paramPtrs != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by ExpectParams functions")
	}

	mmFindByCode.defaultExpectation.params = &InviteRepositoryMockFindByCodeParams{ctx, code}
	mmFindByCode.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmFindByCode.expectations {
		if minimock.Equal(e.params, mmFindByCode.defaultExpectation.params) {
			mmFindByCode.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindByCode.defaultExpectation.params)
		}
	}

	return mmFindByCode
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.FindByCode
func (mmFindByCode *mInviteRepositoryMockFindByCode) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockFindByCode {
	if mmFindByCode.mock.funcFindByCode != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Set")
	}

	if mmFindByCode.defaultExpectation == nil {
		mmFindByCode.defaultExpectation = &InviteRepositoryMockFindByCodeExpectation{}
	}

	if mmFindByCode.defaultExpectation.params != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Expect")
	}

	if mmFindByCode.defaultExpectation.paramPtrs == nil {
		mmFindByCode.defaultExpectation.paramPtrs = &InviteRepositoryMockFindByCodeParamPtrs{}
	}
	mmFindByCode.defaultExpectation.paramPtrs.ctx = &ctx
	mmFindByCode.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmFindByCode
}

// ExpectCodeParam2 sets up expected param code for InviteRepository.FindByCode
func (mmFindByCode *mInviteRepositoryMockFindByCode) ExpectCodeParam2(code int64) *mInviteRepositoryMockFindByCode {
	if mmFindByCode.mock.funcFindByCode != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Set")
	}

	if mmFindByCode.defaultExpectation == nil {
		mmFindByCode.defaultExpectation = &InviteRepositoryMockFindByCodeExpectation{}
	}

	if mmFindByCode.defaultExpectation.params != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Expect")
	}

	if mmFindByCode.defaultExpectation.paramPtrs == nil {
		mmFindByCode.defaultExpectation.paramPtrs = &InviteRepositoryMockFindByCodeParamPtrs{}
	}
	mmFindByCode.defaultExpectation.paramPtrs.code = &code
	mmFindByCode.defaultExpectation.expectationOrigins.originCode = minimock.CallerInfo(1)

	return mmFindByCode
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.FindByCode
func (mmFindByCode *mInviteRepositoryMockFindByCode) Inspect(f func(ctx context.Context, code int64)) *mInviteRepositoryMockFindByCode {
	if mmFindByCode.mock.inspectFuncFindByCode != nil {
		mmFindByCode.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.FindByCode")
	}

	mmFindByCode.mock.inspectFuncFindByCode = f

	return mmFindByCode
}

// Return sets up results that will be returned by InviteRepository.FindByCode
func (mmFindByCode *mInviteRepositoryMockFindByCode) Return(ip1 *model.InviteCode, err error) *InviteRepositoryMock {
	if mmFindByCode.mock.funcFindByCode != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Set")
	}

	if mmFindByCode.defaultExpectation == nil {
		mmFindByCode.defaultExpectation = &InviteRepositoryMockFindByCodeExpectation{mock: mmFindByCode.mock}
	}
	mmFindByCode.defaultExpectation.results = &InviteRepositoryMockFindByCodeResults{ip1, err}
	mmFindByCode.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmFindByCode.mock
}

// Set uses given function f to mock the InviteRepository.FindByCode method
func (mmFindByCode *mInviteRepositoryMockFindByCode) Set(f func(ctx context.Context, code int64) (ip1 *model.InviteCode, err error)) *InviteRepositoryMock {
	if mmFindByCode.defaultExpectation != nil {
		mmFindByCode.mock.t.Fatalf("Default expectation is already set for the InviteRepository.FindByCode method")
	}

	if len(mmFindByCode.expectations) > 0 {
		mmFindByCode.mock.t.Fatalf("Some expectations are already set for the InviteRepository.FindByCode method")
	}

	mmFindByCode.mock.funcFindByCode = f
	mmFindByCode.mock.funcFindByCodeOrigin = minimock.CallerInfo(1)
	return mmFindByCode.mock
}

// When sets expectation for the InviteRepository.FindByCode which will trigger the result defined by the following
// Then helper
func (mmFindByCode *mInviteRepositoryMockFindByCode) When(ctx context.Context, code int64) *InviteRepositoryMockFindByCodeExpectation {
	if mmFindByCode.mock.funcFindByCode != nil {
		mmFindByCode.mock.t.Fatalf("InviteRepositoryMock.FindByCode mock is already set by Set")
	}

	expectation := &InviteRepositoryMockFindByCodeExpectation{
		mock:               mmFindByCode.mock,
		params:             &InviteRepositoryMockFindByCodeParams{ctx, code},
		expectationOrigins: InviteRepositoryMockFindByCodeExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmFindByCode.expectations = append(mmFindByCode.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.FindByCode return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockFindByCodeExpectation) Then(ip1 *model.InviteCode, err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockFindByCodeResults{ip1, err}
	return e.mock
}

// Times sets number of times InviteRepository.FindByCode should be invoked
func (mmFindByCode *mInviteRepositoryMockFindByCode) Times(n uint64) *mInviteRepositoryMockFindByCode {
	if n == 0 {
		mmFindByCode.mock.t.Fatalf("Times of InviteRepositoryMock.FindByCode mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmFindByCode.expectedInvocations, n)
	mmFindByCode.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmFindByCode
}

func (mmFindByCode *mInviteRepositoryMockFindByCode) invocationsDone() bool {
	if len(mmFindByCode.expectations) == 0 && mmFindByCode.defaultExpectation == nil && mmFindByCode.mock.funcFindByCode == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmFindByCode.mock.afterFindByCodeCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmFindByCode.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// FindByCode implements mm_repository.InviteRepository
func (mmFindByCode *InviteRepositoryMock) FindByCode(ctx context.Context, code int64) (ip1 *model.InviteCode, err error) {
	mm_atomic.AddUint64(&mmFindByCode.beforeFindByCodeCounter, 1)
	defer mm_atomic.AddUint64(&mmFindByCode.afterFindByCodeCounter, 1)

	mmFindByCode.t.Helper()

	if mmFindByCode.inspectFuncFindByCode != nil {
		mmFindByCode.inspectFuncFindByCode(ctx, code)
	}

	mm_params := InviteRepositoryMockFindByCodeParams{ctx, code}

	// Record call args
	mmFindByCode.FindByCodeMock.mutex.Lock()
	mmFindByCode.FindByCodeMock.callArgs = append(mmFindByCode.FindByCodeMock.callArgs, &mm_params)
	mmFindByCode.FindByCodeMock.mutex.Unlock()

	for _, e := range mmFindByCode.FindByCodeMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.ip1, e.results.err
		}
	}

	if mmFindByCode.FindByCodeMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmFindByCode.FindByCodeMock.defaultExpectation.Counter, 1)
		mm_want := mmFindByCode.FindByCodeMock.defaultExpectation.params
		mm_want_ptrs := mmFindByCode.FindByCodeMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockFindByCodeParams{ctx, code}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmFindByCode.t.Errorf("InviteRepositoryMock.FindByCode got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindByCode.FindByCodeMock.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) {
				mmFindByCode.t.Errorf("InviteRepositoryMock.FindByCode got unexpected parameter code, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmFindByCode.FindByCodeMock.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) {
			mmFindByCode.t.Errorf("InviteRepositoryMock.FindByCode got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmFindByCode.FindByCodeMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmFindByCode.FindByCodeMock.defaultExpectation.results
		if mm_results == nil {
			mmFindByCode.t.Fatal("No results are set for the InviteRepositoryMock.FindByCode")
		}
		return (*mm_results).ip1, (*mm_results).err
	}
	if mmFindByCode.funcFindByCode != nil {
		return mmFindByCode.funcFindByCode(ctx, code)
	}
	mmFindByCode.t.Fatalf("Unexpected call to InviteRepositoryMock.FindByCode. %v %v", ctx, code)
	return
}

// FindByCodeAfterCounter returns a count of finished InviteRepositoryMock.FindByCode invocations
func (mmFindByCode *InviteRepositoryMock) FindByCodeAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindByCode.afterFindByCodeCounter)
}

// FindByCodeBeforeCounter returns a count of InviteRepositoryMock.FindByCode invocations
func (mmFindByCode *InviteRepositoryMock) FindByCodeBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmFindByCode.beforeFindByCodeCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.FindByCode.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmFindByCode *mInviteRepositoryMockFindByCode) Calls() []*InviteRepositoryMockFindByCodeParams {
	mmFindByCode.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockFindByCodeParams, len(mmFindByCode.callArgs))
	copy(argCopy, mmFindByCode.callArgs)

	mmFindByCode.mutex.RUnlock()

	return argCopy
}

// MinimockFindByCodeDone returns true if the count of the FindByCode invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockFindByCodeDone() bool {
	if m.FindByCodeMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.FindByCodeMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.FindByCodeMock.invocationsDone()
}

// MinimockFindByCodeInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockFindByCodeInspect() {
	for _, e := range m.FindByCodeMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindByCode at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterFindByCodeCounter := mm_atomic.LoadUint64(&m.afterFindByCodeCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.FindByCodeMock.defaultExpectation != nil && afterFindByCodeCounter < 1 {
		if m.FindByCodeMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindByCode at\n%s", m.FindByCodeMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.FindByCode at\n%s with params: %#v", m.FindByCodeMock.defaultExpectation.expectationOrigins.origin, *m.FindByCodeMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcFindByCode != nil && afterFindByCodeCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.FindByCode at\n%s", m.funcFindByCodeOrigin)
	}

	if !m.FindByCodeMock.invocationsDone() && afterFindByCodeCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.FindByCode at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.FindByCodeMock.expectedInvocations), m.FindByCodeMock.expectedInvocationsOrigin, afterFindByCodeCounter)
	}
}

type mInviteRepositoryMockGetUserInvites struct {
	optional           bool
	mock               *InviteRepositoryMock
	defaultExpectation *InviteRepositoryMockGetUserInvitesExpectation
	expectations       []*InviteRepositoryMockGetUserInvitesExpectation

	callArgs []*InviteRepositoryMockGetUserInvitesParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// InviteRepositoryMockGetUserInvitesExpectation specifies expectation struct of the InviteRepository.GetUserInvites
type InviteRepositoryMockGetUserInvitesExpectation struct {
	mock               *InviteRepositoryMock
	params             *InviteRepositoryMockGetUserInvitesParams
	paramPtrs          *InviteRepositoryMockGetUserInvitesParamPtrs
	expectationOrigins InviteRepositoryMockGetUserInvitesExpectationOrigins
	results            *InviteRepositoryMockGetUserInvitesResults
	returnOrigin       string
	Counter            uint64
}

// InviteRepositoryMockGetUserInvitesParams contains parameters of the InviteRepository.GetUserInvites
type InviteRepositoryMockGetUserInvitesParams struct {
	ctx    context.Context
	userID int
}

// InviteRepositoryMockGetUserInvitesParamPtrs contains pointers to parameters of the InviteRepository.GetUserInvites
type InviteRepositoryMockGetUserInvitesParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// InviteRepositoryMockGetUserInvitesResults contains results of the InviteRepository.GetUserInvites
type InviteRepositoryMockGetUserInvitesResults struct {
	ipa1 []*model.InviteCode
	err  error
}

// InviteRepositoryMockGetUserInvitesOrigins contains origins of expectations of the InviteRepository.GetUserInvites
type InviteRepositoryMockGetUserInvitesExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID 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 (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Optional() *mInviteRepositoryMockGetUserInvites {
	mmGetUserInvites.optional = true
	return mmGetUserInvites
}

// Expect sets up expected params for InviteRepository.GetUserInvites
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Expect(ctx context.Context, userID int) *mInviteRepositoryMockGetUserInvites {
	if mmGetUserInvites.mock.funcGetUserInvites != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Set")
	}

	if mmGetUserInvites.defaultExpectation == nil {
		mmGetUserInvites.defaultExpectation = &InviteRepositoryMockGetUserInvitesExpectation{}
	}

	if mmGetUserInvites.defaultExpectation.paramPtrs != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by ExpectParams functions")
	}

	mmGetUserInvites.defaultExpectation.params = &InviteRepositoryMockGetUserInvitesParams{ctx, userID}
	mmGetUserInvites.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
	for _, e := range mmGetUserInvites.expectations {
		if minimock.Equal(e.params, mmGetUserInvites.defaultExpectation.params) {
			mmGetUserInvites.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetUserInvites.defaultExpectation.params)
		}
	}

	return mmGetUserInvites
}

// ExpectCtxParam1 sets up expected param ctx for InviteRepository.GetUserInvites
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) ExpectCtxParam1(ctx context.Context) *mInviteRepositoryMockGetUserInvites {
	if mmGetUserInvites.mock.funcGetUserInvites != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Set")
	}

	if mmGetUserInvites.defaultExpectation == nil {
		mmGetUserInvites.defaultExpectation = &InviteRepositoryMockGetUserInvitesExpectation{}
	}

	if mmGetUserInvites.defaultExpectation.params != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Expect")
	}

	if mmGetUserInvites.defaultExpectation.paramPtrs == nil {
		mmGetUserInvites.defaultExpectation.paramPtrs = &InviteRepositoryMockGetUserInvitesParamPtrs{}
	}
	mmGetUserInvites.defaultExpectation.paramPtrs.ctx = &ctx
	mmGetUserInvites.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)

	return mmGetUserInvites
}

// ExpectUserIDParam2 sets up expected param userID for InviteRepository.GetUserInvites
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) ExpectUserIDParam2(userID int) *mInviteRepositoryMockGetUserInvites {
	if mmGetUserInvites.mock.funcGetUserInvites != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Set")
	}

	if mmGetUserInvites.defaultExpectation == nil {
		mmGetUserInvites.defaultExpectation = &InviteRepositoryMockGetUserInvitesExpectation{}
	}

	if mmGetUserInvites.defaultExpectation.params != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Expect")
	}

	if mmGetUserInvites.defaultExpectation.paramPtrs == nil {
		mmGetUserInvites.defaultExpectation.paramPtrs = &InviteRepositoryMockGetUserInvitesParamPtrs{}
	}
	mmGetUserInvites.defaultExpectation.paramPtrs.userID = &userID
	mmGetUserInvites.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)

	return mmGetUserInvites
}

// Inspect accepts an inspector function that has same arguments as the InviteRepository.GetUserInvites
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Inspect(f func(ctx context.Context, userID int)) *mInviteRepositoryMockGetUserInvites {
	if mmGetUserInvites.mock.inspectFuncGetUserInvites != nil {
		mmGetUserInvites.mock.t.Fatalf("Inspect function is already set for InviteRepositoryMock.GetUserInvites")
	}

	mmGetUserInvites.mock.inspectFuncGetUserInvites = f

	return mmGetUserInvites
}

// Return sets up results that will be returned by InviteRepository.GetUserInvites
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Return(ipa1 []*model.InviteCode, err error) *InviteRepositoryMock {
	if mmGetUserInvites.mock.funcGetUserInvites != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Set")
	}

	if mmGetUserInvites.defaultExpectation == nil {
		mmGetUserInvites.defaultExpectation = &InviteRepositoryMockGetUserInvitesExpectation{mock: mmGetUserInvites.mock}
	}
	mmGetUserInvites.defaultExpectation.results = &InviteRepositoryMockGetUserInvitesResults{ipa1, err}
	mmGetUserInvites.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetUserInvites.mock
}

// Set uses given function f to mock the InviteRepository.GetUserInvites method
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Set(f func(ctx context.Context, userID int) (ipa1 []*model.InviteCode, err error)) *InviteRepositoryMock {
	if mmGetUserInvites.defaultExpectation != nil {
		mmGetUserInvites.mock.t.Fatalf("Default expectation is already set for the InviteRepository.GetUserInvites method")
	}

	if len(mmGetUserInvites.expectations) > 0 {
		mmGetUserInvites.mock.t.Fatalf("Some expectations are already set for the InviteRepository.GetUserInvites method")
	}

	mmGetUserInvites.mock.funcGetUserInvites = f
	mmGetUserInvites.mock.funcGetUserInvitesOrigin = minimock.CallerInfo(1)
	return mmGetUserInvites.mock
}

// When sets expectation for the InviteRepository.GetUserInvites which will trigger the result defined by the following
// Then helper
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) When(ctx context.Context, userID int) *InviteRepositoryMockGetUserInvitesExpectation {
	if mmGetUserInvites.mock.funcGetUserInvites != nil {
		mmGetUserInvites.mock.t.Fatalf("InviteRepositoryMock.GetUserInvites mock is already set by Set")
	}

	expectation := &InviteRepositoryMockGetUserInvitesExpectation{
		mock:               mmGetUserInvites.mock,
		params:             &InviteRepositoryMockGetUserInvitesParams{ctx, userID},
		expectationOrigins: InviteRepositoryMockGetUserInvitesExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetUserInvites.expectations = append(mmGetUserInvites.expectations, expectation)
	return expectation
}

// Then sets up InviteRepository.GetUserInvites return parameters for the expectation previously defined by the When method
func (e *InviteRepositoryMockGetUserInvitesExpectation) Then(ipa1 []*model.InviteCode, err error) *InviteRepositoryMock {
	e.results = &InviteRepositoryMockGetUserInvitesResults{ipa1, err}
	return e.mock
}

// Times sets number of times InviteRepository.GetUserInvites should be invoked
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Times(n uint64) *mInviteRepositoryMockGetUserInvites {
	if n == 0 {
		mmGetUserInvites.mock.t.Fatalf("Times of InviteRepositoryMock.GetUserInvites mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetUserInvites.expectedInvocations, n)
	mmGetUserInvites.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetUserInvites
}

func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) invocationsDone() bool {
	if len(mmGetUserInvites.expectations) == 0 && mmGetUserInvites.defaultExpectation == nil && mmGetUserInvites.mock.funcGetUserInvites == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetUserInvites.mock.afterGetUserInvitesCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetUserInvites.expectedInvocations)

	return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
}

// GetUserInvites implements mm_repository.InviteRepository
func (mmGetUserInvites *InviteRepositoryMock) GetUserInvites(ctx context.Context, userID int) (ipa1 []*model.InviteCode, err error) {
	mm_atomic.AddUint64(&mmGetUserInvites.beforeGetUserInvitesCounter, 1)
	defer mm_atomic.AddUint64(&mmGetUserInvites.afterGetUserInvitesCounter, 1)

	mmGetUserInvites.t.Helper()

	if mmGetUserInvites.inspectFuncGetUserInvites != nil {
		mmGetUserInvites.inspectFuncGetUserInvites(ctx, userID)
	}

	mm_params := InviteRepositoryMockGetUserInvitesParams{ctx, userID}

	// Record call args
	mmGetUserInvites.GetUserInvitesMock.mutex.Lock()
	mmGetUserInvites.GetUserInvitesMock.callArgs = append(mmGetUserInvites.GetUserInvitesMock.callArgs, &mm_params)
	mmGetUserInvites.GetUserInvitesMock.mutex.Unlock()

	for _, e := range mmGetUserInvites.GetUserInvitesMock.expectations {
		if minimock.Equal(*e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.ipa1, e.results.err
		}
	}

	if mmGetUserInvites.GetUserInvitesMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetUserInvites.GetUserInvitesMock.defaultExpectation.Counter, 1)
		mm_want := mmGetUserInvites.GetUserInvitesMock.defaultExpectation.params
		mm_want_ptrs := mmGetUserInvites.GetUserInvitesMock.defaultExpectation.paramPtrs

		mm_got := InviteRepositoryMockGetUserInvitesParams{ctx, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmGetUserInvites.t.Errorf("InviteRepositoryMock.GetUserInvites got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetUserInvites.GetUserInvitesMock.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) {
				mmGetUserInvites.t.Errorf("InviteRepositoryMock.GetUserInvites got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetUserInvites.GetUserInvitesMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

		} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetUserInvites.t.Errorf("InviteRepositoryMock.GetUserInvites got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
				mmGetUserInvites.GetUserInvitesMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetUserInvites.GetUserInvitesMock.defaultExpectation.results
		if mm_results == nil {
			mmGetUserInvites.t.Fatal("No results are set for the InviteRepositoryMock.GetUserInvites")
		}
		return (*mm_results).ipa1, (*mm_results).err
	}
	if mmGetUserInvites.funcGetUserInvites != nil {
		return mmGetUserInvites.funcGetUserInvites(ctx, userID)
	}
	mmGetUserInvites.t.Fatalf("Unexpected call to InviteRepositoryMock.GetUserInvites. %v %v", ctx, userID)
	return
}

// GetUserInvitesAfterCounter returns a count of finished InviteRepositoryMock.GetUserInvites invocations
func (mmGetUserInvites *InviteRepositoryMock) GetUserInvitesAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetUserInvites.afterGetUserInvitesCounter)
}

// GetUserInvitesBeforeCounter returns a count of InviteRepositoryMock.GetUserInvites invocations
func (mmGetUserInvites *InviteRepositoryMock) GetUserInvitesBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetUserInvites.beforeGetUserInvitesCounter)
}

// Calls returns a list of arguments used in each call to InviteRepositoryMock.GetUserInvites.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetUserInvites *mInviteRepositoryMockGetUserInvites) Calls() []*InviteRepositoryMockGetUserInvitesParams {
	mmGetUserInvites.mutex.RLock()

	argCopy := make([]*InviteRepositoryMockGetUserInvitesParams, len(mmGetUserInvites.callArgs))
	copy(argCopy, mmGetUserInvites.callArgs)

	mmGetUserInvites.mutex.RUnlock()

	return argCopy
}

// MinimockGetUserInvitesDone returns true if the count of the GetUserInvites invocations corresponds
// the number of defined expectations
func (m *InviteRepositoryMock) MinimockGetUserInvitesDone() bool {
	if m.GetUserInvitesMock.optional {
		// Optional methods provide '0 or more' call count restriction.
		return true
	}

	for _, e := range m.GetUserInvitesMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	return m.GetUserInvitesMock.invocationsDone()
}

// MinimockGetUserInvitesInspect logs each unmet expectation
func (m *InviteRepositoryMock) MinimockGetUserInvitesInspect() {
	for _, e := range m.GetUserInvitesMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to InviteRepositoryMock.GetUserInvites at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
		}
	}

	afterGetUserInvitesCounter := mm_atomic.LoadUint64(&m.afterGetUserInvitesCounter)
	// if default expectation was set then invocations count should be greater than zero
	if m.GetUserInvitesMock.defaultExpectation != nil && afterGetUserInvitesCounter < 1 {
		if m.GetUserInvitesMock.defaultExpectation.params == nil {
			m.t.Errorf("Expected call to InviteRepositoryMock.GetUserInvites at\n%s", m.GetUserInvitesMock.defaultExpectation.returnOrigin)
		} else {
			m.t.Errorf("Expected call to InviteRepositoryMock.GetUserInvites at\n%s with params: %#v", m.GetUserInvitesMock.defaultExpectation.expectationOrigins.origin, *m.GetUserInvitesMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetUserInvites != nil && afterGetUserInvitesCounter < 1 {
		m.t.Errorf("Expected call to InviteRepositoryMock.GetUserInvites at\n%s", m.funcGetUserInvitesOrigin)
	}

	if !m.GetUserInvitesMock.invocationsDone() && afterGetUserInvitesCounter > 0 {
		m.t.Errorf("Expected %d calls to InviteRepositoryMock.GetUserInvites at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetUserInvitesMock.expectedInvocations), m.GetUserInvitesMock.expectedInvocationsOrigin, afterGetUserInvitesCounter)
	}
}

// MinimockFinish checks that all mocked methods have been called the expected number of times
func (m *InviteRepositoryMock) MinimockFinish() {
	m.finishOnce.Do(func() {
		if !m.minimockDone() {
			m.MinimockCreateInspect()

			m.MinimockCreateTxInspect()

			m.MinimockDeactivateExpiredInspect()

			m.MinimockDecrementCanBeUsedCountTxInspect()

			m.MinimockFindActiveByCodeInspect()

			m.MinimockFindActiveByUserIDInspect()

			m.MinimockFindByCodeInspect()

			m.MinimockGetUserInvitesInspect()
		}
	})
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *InviteRepositoryMock) 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 *InviteRepositoryMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockCreateDone() &&
		m.MinimockCreateTxDone() &&
		m.MinimockDeactivateExpiredDone() &&
		m.MinimockDecrementCanBeUsedCountTxDone() &&
		m.MinimockFindActiveByCodeDone() &&
		m.MinimockFindActiveByUserIDDone() &&
		m.MinimockFindByCodeDone() &&
		m.MinimockGetUserInvitesDone()
}