// 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.SupplierRepository -o supplier_repository_mock.go -n SupplierRepositoryMock -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/google/uuid"
	"github.com/jackc/pgx/v5"
)

// SupplierRepositoryMock implements mm_repository.SupplierRepository
type SupplierRepositoryMock struct {
	t          minimock.Tester
	finishOnce sync.Once

	funcBulkInsert          func(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier) (err error)
	funcBulkInsertOrigin    string
	inspectFuncBulkInsert   func(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier)
	afterBulkInsertCounter  uint64
	beforeBulkInsertCounter uint64
	BulkInsertMock          mSupplierRepositoryMockBulkInsert

	funcBulkInsertTx          func(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier) (err error)
	funcBulkInsertTxOrigin    string
	inspectFuncBulkInsertTx   func(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier)
	afterBulkInsertTxCounter  uint64
	beforeBulkInsertTxCounter uint64
	BulkInsertTxMock          mSupplierRepositoryMockBulkInsertTx

	funcDeleteByRequestID          func(ctx context.Context, requestID uuid.UUID) (err error)
	funcDeleteByRequestIDOrigin    string
	inspectFuncDeleteByRequestID   func(ctx context.Context, requestID uuid.UUID)
	afterDeleteByRequestIDCounter  uint64
	beforeDeleteByRequestIDCounter uint64
	DeleteByRequestIDMock          mSupplierRepositoryMockDeleteByRequestID

	funcGetByRequestID          func(ctx context.Context, requestID uuid.UUID) (spa1 []*model.Supplier, err error)
	funcGetByRequestIDOrigin    string
	inspectFuncGetByRequestID   func(ctx context.Context, requestID uuid.UUID)
	afterGetByRequestIDCounter  uint64
	beforeGetByRequestIDCounter uint64
	GetByRequestIDMock          mSupplierRepositoryMockGetByRequestID
}

// NewSupplierRepositoryMock returns a mock for mm_repository.SupplierRepository
func NewSupplierRepositoryMock(t minimock.Tester) *SupplierRepositoryMock {
	m := &SupplierRepositoryMock{t: t}

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

	m.BulkInsertMock = mSupplierRepositoryMockBulkInsert{mock: m}
	m.BulkInsertMock.callArgs = []*SupplierRepositoryMockBulkInsertParams{}

	m.BulkInsertTxMock = mSupplierRepositoryMockBulkInsertTx{mock: m}
	m.BulkInsertTxMock.callArgs = []*SupplierRepositoryMockBulkInsertTxParams{}

	m.DeleteByRequestIDMock = mSupplierRepositoryMockDeleteByRequestID{mock: m}
	m.DeleteByRequestIDMock.callArgs = []*SupplierRepositoryMockDeleteByRequestIDParams{}

	m.GetByRequestIDMock = mSupplierRepositoryMockGetByRequestID{mock: m}
	m.GetByRequestIDMock.callArgs = []*SupplierRepositoryMockGetByRequestIDParams{}

	t.Cleanup(m.MinimockFinish)

	return m
}

type mSupplierRepositoryMockBulkInsert struct {
	optional           bool
	mock               *SupplierRepositoryMock
	defaultExpectation *SupplierRepositoryMockBulkInsertExpectation
	expectations       []*SupplierRepositoryMockBulkInsertExpectation

	callArgs []*SupplierRepositoryMockBulkInsertParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// SupplierRepositoryMockBulkInsertExpectation specifies expectation struct of the SupplierRepository.BulkInsert
type SupplierRepositoryMockBulkInsertExpectation struct {
	mock               *SupplierRepositoryMock
	params             *SupplierRepositoryMockBulkInsertParams
	paramPtrs          *SupplierRepositoryMockBulkInsertParamPtrs
	expectationOrigins SupplierRepositoryMockBulkInsertExpectationOrigins
	results            *SupplierRepositoryMockBulkInsertResults
	returnOrigin       string
	Counter            uint64
}

// SupplierRepositoryMockBulkInsertParams contains parameters of the SupplierRepository.BulkInsert
type SupplierRepositoryMockBulkInsertParams struct {
	ctx       context.Context
	requestID uuid.UUID
	suppliers []*model.Supplier
}

// SupplierRepositoryMockBulkInsertParamPtrs contains pointers to parameters of the SupplierRepository.BulkInsert
type SupplierRepositoryMockBulkInsertParamPtrs struct {
	ctx       *context.Context
	requestID *uuid.UUID
	suppliers *[]*model.Supplier
}

// SupplierRepositoryMockBulkInsertResults contains results of the SupplierRepository.BulkInsert
type SupplierRepositoryMockBulkInsertResults struct {
	err error
}

// SupplierRepositoryMockBulkInsertOrigins contains origins of expectations of the SupplierRepository.BulkInsert
type SupplierRepositoryMockBulkInsertExpectationOrigins struct {
	origin          string
	originCtx       string
	originRequestID string
	originSuppliers 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 (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Optional() *mSupplierRepositoryMockBulkInsert {
	mmBulkInsert.optional = true
	return mmBulkInsert
}

// Expect sets up expected params for SupplierRepository.BulkInsert
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Expect(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier) *mSupplierRepositoryMockBulkInsert {
	if mmBulkInsert.mock.funcBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Set")
	}

	if mmBulkInsert.defaultExpectation == nil {
		mmBulkInsert.defaultExpectation = &SupplierRepositoryMockBulkInsertExpectation{}
	}

	if mmBulkInsert.defaultExpectation.paramPtrs != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by ExpectParams functions")
	}

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

	return mmBulkInsert
}

// ExpectCtxParam1 sets up expected param ctx for SupplierRepository.BulkInsert
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) ExpectCtxParam1(ctx context.Context) *mSupplierRepositoryMockBulkInsert {
	if mmBulkInsert.mock.funcBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Set")
	}

	if mmBulkInsert.defaultExpectation == nil {
		mmBulkInsert.defaultExpectation = &SupplierRepositoryMockBulkInsertExpectation{}
	}

	if mmBulkInsert.defaultExpectation.params != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Expect")
	}

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

	return mmBulkInsert
}

// ExpectRequestIDParam2 sets up expected param requestID for SupplierRepository.BulkInsert
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) ExpectRequestIDParam2(requestID uuid.UUID) *mSupplierRepositoryMockBulkInsert {
	if mmBulkInsert.mock.funcBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Set")
	}

	if mmBulkInsert.defaultExpectation == nil {
		mmBulkInsert.defaultExpectation = &SupplierRepositoryMockBulkInsertExpectation{}
	}

	if mmBulkInsert.defaultExpectation.params != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Expect")
	}

	if mmBulkInsert.defaultExpectation.paramPtrs == nil {
		mmBulkInsert.defaultExpectation.paramPtrs = &SupplierRepositoryMockBulkInsertParamPtrs{}
	}
	mmBulkInsert.defaultExpectation.paramPtrs.requestID = &requestID
	mmBulkInsert.defaultExpectation.expectationOrigins.originRequestID = minimock.CallerInfo(1)

	return mmBulkInsert
}

// ExpectSuppliersParam3 sets up expected param suppliers for SupplierRepository.BulkInsert
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) ExpectSuppliersParam3(suppliers []*model.Supplier) *mSupplierRepositoryMockBulkInsert {
	if mmBulkInsert.mock.funcBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Set")
	}

	if mmBulkInsert.defaultExpectation == nil {
		mmBulkInsert.defaultExpectation = &SupplierRepositoryMockBulkInsertExpectation{}
	}

	if mmBulkInsert.defaultExpectation.params != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Expect")
	}

	if mmBulkInsert.defaultExpectation.paramPtrs == nil {
		mmBulkInsert.defaultExpectation.paramPtrs = &SupplierRepositoryMockBulkInsertParamPtrs{}
	}
	mmBulkInsert.defaultExpectation.paramPtrs.suppliers = &suppliers
	mmBulkInsert.defaultExpectation.expectationOrigins.originSuppliers = minimock.CallerInfo(1)

	return mmBulkInsert
}

// Inspect accepts an inspector function that has same arguments as the SupplierRepository.BulkInsert
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Inspect(f func(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier)) *mSupplierRepositoryMockBulkInsert {
	if mmBulkInsert.mock.inspectFuncBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("Inspect function is already set for SupplierRepositoryMock.BulkInsert")
	}

	mmBulkInsert.mock.inspectFuncBulkInsert = f

	return mmBulkInsert
}

// Return sets up results that will be returned by SupplierRepository.BulkInsert
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Return(err error) *SupplierRepositoryMock {
	if mmBulkInsert.mock.funcBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Set")
	}

	if mmBulkInsert.defaultExpectation == nil {
		mmBulkInsert.defaultExpectation = &SupplierRepositoryMockBulkInsertExpectation{mock: mmBulkInsert.mock}
	}
	mmBulkInsert.defaultExpectation.results = &SupplierRepositoryMockBulkInsertResults{err}
	mmBulkInsert.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmBulkInsert.mock
}

// Set uses given function f to mock the SupplierRepository.BulkInsert method
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Set(f func(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier) (err error)) *SupplierRepositoryMock {
	if mmBulkInsert.defaultExpectation != nil {
		mmBulkInsert.mock.t.Fatalf("Default expectation is already set for the SupplierRepository.BulkInsert method")
	}

	if len(mmBulkInsert.expectations) > 0 {
		mmBulkInsert.mock.t.Fatalf("Some expectations are already set for the SupplierRepository.BulkInsert method")
	}

	mmBulkInsert.mock.funcBulkInsert = f
	mmBulkInsert.mock.funcBulkInsertOrigin = minimock.CallerInfo(1)
	return mmBulkInsert.mock
}

// When sets expectation for the SupplierRepository.BulkInsert which will trigger the result defined by the following
// Then helper
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) When(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier) *SupplierRepositoryMockBulkInsertExpectation {
	if mmBulkInsert.mock.funcBulkInsert != nil {
		mmBulkInsert.mock.t.Fatalf("SupplierRepositoryMock.BulkInsert mock is already set by Set")
	}

	expectation := &SupplierRepositoryMockBulkInsertExpectation{
		mock:               mmBulkInsert.mock,
		params:             &SupplierRepositoryMockBulkInsertParams{ctx, requestID, suppliers},
		expectationOrigins: SupplierRepositoryMockBulkInsertExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmBulkInsert.expectations = append(mmBulkInsert.expectations, expectation)
	return expectation
}

// Then sets up SupplierRepository.BulkInsert return parameters for the expectation previously defined by the When method
func (e *SupplierRepositoryMockBulkInsertExpectation) Then(err error) *SupplierRepositoryMock {
	e.results = &SupplierRepositoryMockBulkInsertResults{err}
	return e.mock
}

// Times sets number of times SupplierRepository.BulkInsert should be invoked
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Times(n uint64) *mSupplierRepositoryMockBulkInsert {
	if n == 0 {
		mmBulkInsert.mock.t.Fatalf("Times of SupplierRepositoryMock.BulkInsert mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmBulkInsert.expectedInvocations, n)
	mmBulkInsert.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmBulkInsert
}

func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) invocationsDone() bool {
	if len(mmBulkInsert.expectations) == 0 && mmBulkInsert.defaultExpectation == nil && mmBulkInsert.mock.funcBulkInsert == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmBulkInsert.mock.afterBulkInsertCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmBulkInsert.expectedInvocations)

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

// BulkInsert implements mm_repository.SupplierRepository
func (mmBulkInsert *SupplierRepositoryMock) BulkInsert(ctx context.Context, requestID uuid.UUID, suppliers []*model.Supplier) (err error) {
	mm_atomic.AddUint64(&mmBulkInsert.beforeBulkInsertCounter, 1)
	defer mm_atomic.AddUint64(&mmBulkInsert.afterBulkInsertCounter, 1)

	mmBulkInsert.t.Helper()

	if mmBulkInsert.inspectFuncBulkInsert != nil {
		mmBulkInsert.inspectFuncBulkInsert(ctx, requestID, suppliers)
	}

	mm_params := SupplierRepositoryMockBulkInsertParams{ctx, requestID, suppliers}

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

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

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

		mm_got := SupplierRepositoryMockBulkInsertParams{ctx, requestID, suppliers}

		if mm_want_ptrs != nil {

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

			if mm_want_ptrs.requestID != nil && !minimock.Equal(*mm_want_ptrs.requestID, mm_got.requestID) {
				mmBulkInsert.t.Errorf("SupplierRepositoryMock.BulkInsert got unexpected parameter requestID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmBulkInsert.BulkInsertMock.defaultExpectation.expectationOrigins.originRequestID, *mm_want_ptrs.requestID, mm_got.requestID, minimock.Diff(*mm_want_ptrs.requestID, mm_got.requestID))
			}

			if mm_want_ptrs.suppliers != nil && !minimock.Equal(*mm_want_ptrs.suppliers, mm_got.suppliers) {
				mmBulkInsert.t.Errorf("SupplierRepositoryMock.BulkInsert got unexpected parameter suppliers, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmBulkInsert.BulkInsertMock.defaultExpectation.expectationOrigins.originSuppliers, *mm_want_ptrs.suppliers, mm_got.suppliers, minimock.Diff(*mm_want_ptrs.suppliers, mm_got.suppliers))
			}

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

		mm_results := mmBulkInsert.BulkInsertMock.defaultExpectation.results
		if mm_results == nil {
			mmBulkInsert.t.Fatal("No results are set for the SupplierRepositoryMock.BulkInsert")
		}
		return (*mm_results).err
	}
	if mmBulkInsert.funcBulkInsert != nil {
		return mmBulkInsert.funcBulkInsert(ctx, requestID, suppliers)
	}
	mmBulkInsert.t.Fatalf("Unexpected call to SupplierRepositoryMock.BulkInsert. %v %v %v", ctx, requestID, suppliers)
	return
}

// BulkInsertAfterCounter returns a count of finished SupplierRepositoryMock.BulkInsert invocations
func (mmBulkInsert *SupplierRepositoryMock) BulkInsertAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmBulkInsert.afterBulkInsertCounter)
}

// BulkInsertBeforeCounter returns a count of SupplierRepositoryMock.BulkInsert invocations
func (mmBulkInsert *SupplierRepositoryMock) BulkInsertBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmBulkInsert.beforeBulkInsertCounter)
}

// Calls returns a list of arguments used in each call to SupplierRepositoryMock.BulkInsert.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmBulkInsert *mSupplierRepositoryMockBulkInsert) Calls() []*SupplierRepositoryMockBulkInsertParams {
	mmBulkInsert.mutex.RLock()

	argCopy := make([]*SupplierRepositoryMockBulkInsertParams, len(mmBulkInsert.callArgs))
	copy(argCopy, mmBulkInsert.callArgs)

	mmBulkInsert.mutex.RUnlock()

	return argCopy
}

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

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

	return m.BulkInsertMock.invocationsDone()
}

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

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

	if !m.BulkInsertMock.invocationsDone() && afterBulkInsertCounter > 0 {
		m.t.Errorf("Expected %d calls to SupplierRepositoryMock.BulkInsert at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.BulkInsertMock.expectedInvocations), m.BulkInsertMock.expectedInvocationsOrigin, afterBulkInsertCounter)
	}
}

type mSupplierRepositoryMockBulkInsertTx struct {
	optional           bool
	mock               *SupplierRepositoryMock
	defaultExpectation *SupplierRepositoryMockBulkInsertTxExpectation
	expectations       []*SupplierRepositoryMockBulkInsertTxExpectation

	callArgs []*SupplierRepositoryMockBulkInsertTxParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// SupplierRepositoryMockBulkInsertTxExpectation specifies expectation struct of the SupplierRepository.BulkInsertTx
type SupplierRepositoryMockBulkInsertTxExpectation struct {
	mock               *SupplierRepositoryMock
	params             *SupplierRepositoryMockBulkInsertTxParams
	paramPtrs          *SupplierRepositoryMockBulkInsertTxParamPtrs
	expectationOrigins SupplierRepositoryMockBulkInsertTxExpectationOrigins
	results            *SupplierRepositoryMockBulkInsertTxResults
	returnOrigin       string
	Counter            uint64
}

// SupplierRepositoryMockBulkInsertTxParams contains parameters of the SupplierRepository.BulkInsertTx
type SupplierRepositoryMockBulkInsertTxParams struct {
	ctx       context.Context
	tx        pgx.Tx
	requestID uuid.UUID
	suppliers []*model.Supplier
}

// SupplierRepositoryMockBulkInsertTxParamPtrs contains pointers to parameters of the SupplierRepository.BulkInsertTx
type SupplierRepositoryMockBulkInsertTxParamPtrs struct {
	ctx       *context.Context
	tx        *pgx.Tx
	requestID *uuid.UUID
	suppliers *[]*model.Supplier
}

// SupplierRepositoryMockBulkInsertTxResults contains results of the SupplierRepository.BulkInsertTx
type SupplierRepositoryMockBulkInsertTxResults struct {
	err error
}

// SupplierRepositoryMockBulkInsertTxOrigins contains origins of expectations of the SupplierRepository.BulkInsertTx
type SupplierRepositoryMockBulkInsertTxExpectationOrigins struct {
	origin          string
	originCtx       string
	originTx        string
	originRequestID string
	originSuppliers 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 (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Optional() *mSupplierRepositoryMockBulkInsertTx {
	mmBulkInsertTx.optional = true
	return mmBulkInsertTx
}

// Expect sets up expected params for SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Expect(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier) *mSupplierRepositoryMockBulkInsertTx {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	if mmBulkInsertTx.defaultExpectation == nil {
		mmBulkInsertTx.defaultExpectation = &SupplierRepositoryMockBulkInsertTxExpectation{}
	}

	if mmBulkInsertTx.defaultExpectation.paramPtrs != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by ExpectParams functions")
	}

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

	return mmBulkInsertTx
}

// ExpectCtxParam1 sets up expected param ctx for SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) ExpectCtxParam1(ctx context.Context) *mSupplierRepositoryMockBulkInsertTx {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	if mmBulkInsertTx.defaultExpectation == nil {
		mmBulkInsertTx.defaultExpectation = &SupplierRepositoryMockBulkInsertTxExpectation{}
	}

	if mmBulkInsertTx.defaultExpectation.params != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Expect")
	}

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

	return mmBulkInsertTx
}

// ExpectTxParam2 sets up expected param tx for SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) ExpectTxParam2(tx pgx.Tx) *mSupplierRepositoryMockBulkInsertTx {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	if mmBulkInsertTx.defaultExpectation == nil {
		mmBulkInsertTx.defaultExpectation = &SupplierRepositoryMockBulkInsertTxExpectation{}
	}

	if mmBulkInsertTx.defaultExpectation.params != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Expect")
	}

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

	return mmBulkInsertTx
}

// ExpectRequestIDParam3 sets up expected param requestID for SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) ExpectRequestIDParam3(requestID uuid.UUID) *mSupplierRepositoryMockBulkInsertTx {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	if mmBulkInsertTx.defaultExpectation == nil {
		mmBulkInsertTx.defaultExpectation = &SupplierRepositoryMockBulkInsertTxExpectation{}
	}

	if mmBulkInsertTx.defaultExpectation.params != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Expect")
	}

	if mmBulkInsertTx.defaultExpectation.paramPtrs == nil {
		mmBulkInsertTx.defaultExpectation.paramPtrs = &SupplierRepositoryMockBulkInsertTxParamPtrs{}
	}
	mmBulkInsertTx.defaultExpectation.paramPtrs.requestID = &requestID
	mmBulkInsertTx.defaultExpectation.expectationOrigins.originRequestID = minimock.CallerInfo(1)

	return mmBulkInsertTx
}

// ExpectSuppliersParam4 sets up expected param suppliers for SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) ExpectSuppliersParam4(suppliers []*model.Supplier) *mSupplierRepositoryMockBulkInsertTx {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	if mmBulkInsertTx.defaultExpectation == nil {
		mmBulkInsertTx.defaultExpectation = &SupplierRepositoryMockBulkInsertTxExpectation{}
	}

	if mmBulkInsertTx.defaultExpectation.params != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Expect")
	}

	if mmBulkInsertTx.defaultExpectation.paramPtrs == nil {
		mmBulkInsertTx.defaultExpectation.paramPtrs = &SupplierRepositoryMockBulkInsertTxParamPtrs{}
	}
	mmBulkInsertTx.defaultExpectation.paramPtrs.suppliers = &suppliers
	mmBulkInsertTx.defaultExpectation.expectationOrigins.originSuppliers = minimock.CallerInfo(1)

	return mmBulkInsertTx
}

// Inspect accepts an inspector function that has same arguments as the SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Inspect(f func(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier)) *mSupplierRepositoryMockBulkInsertTx {
	if mmBulkInsertTx.mock.inspectFuncBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("Inspect function is already set for SupplierRepositoryMock.BulkInsertTx")
	}

	mmBulkInsertTx.mock.inspectFuncBulkInsertTx = f

	return mmBulkInsertTx
}

// Return sets up results that will be returned by SupplierRepository.BulkInsertTx
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Return(err error) *SupplierRepositoryMock {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	if mmBulkInsertTx.defaultExpectation == nil {
		mmBulkInsertTx.defaultExpectation = &SupplierRepositoryMockBulkInsertTxExpectation{mock: mmBulkInsertTx.mock}
	}
	mmBulkInsertTx.defaultExpectation.results = &SupplierRepositoryMockBulkInsertTxResults{err}
	mmBulkInsertTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmBulkInsertTx.mock
}

// Set uses given function f to mock the SupplierRepository.BulkInsertTx method
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Set(f func(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier) (err error)) *SupplierRepositoryMock {
	if mmBulkInsertTx.defaultExpectation != nil {
		mmBulkInsertTx.mock.t.Fatalf("Default expectation is already set for the SupplierRepository.BulkInsertTx method")
	}

	if len(mmBulkInsertTx.expectations) > 0 {
		mmBulkInsertTx.mock.t.Fatalf("Some expectations are already set for the SupplierRepository.BulkInsertTx method")
	}

	mmBulkInsertTx.mock.funcBulkInsertTx = f
	mmBulkInsertTx.mock.funcBulkInsertTxOrigin = minimock.CallerInfo(1)
	return mmBulkInsertTx.mock
}

// When sets expectation for the SupplierRepository.BulkInsertTx which will trigger the result defined by the following
// Then helper
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) When(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier) *SupplierRepositoryMockBulkInsertTxExpectation {
	if mmBulkInsertTx.mock.funcBulkInsertTx != nil {
		mmBulkInsertTx.mock.t.Fatalf("SupplierRepositoryMock.BulkInsertTx mock is already set by Set")
	}

	expectation := &SupplierRepositoryMockBulkInsertTxExpectation{
		mock:               mmBulkInsertTx.mock,
		params:             &SupplierRepositoryMockBulkInsertTxParams{ctx, tx, requestID, suppliers},
		expectationOrigins: SupplierRepositoryMockBulkInsertTxExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmBulkInsertTx.expectations = append(mmBulkInsertTx.expectations, expectation)
	return expectation
}

// Then sets up SupplierRepository.BulkInsertTx return parameters for the expectation previously defined by the When method
func (e *SupplierRepositoryMockBulkInsertTxExpectation) Then(err error) *SupplierRepositoryMock {
	e.results = &SupplierRepositoryMockBulkInsertTxResults{err}
	return e.mock
}

// Times sets number of times SupplierRepository.BulkInsertTx should be invoked
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Times(n uint64) *mSupplierRepositoryMockBulkInsertTx {
	if n == 0 {
		mmBulkInsertTx.mock.t.Fatalf("Times of SupplierRepositoryMock.BulkInsertTx mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmBulkInsertTx.expectedInvocations, n)
	mmBulkInsertTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmBulkInsertTx
}

func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) invocationsDone() bool {
	if len(mmBulkInsertTx.expectations) == 0 && mmBulkInsertTx.defaultExpectation == nil && mmBulkInsertTx.mock.funcBulkInsertTx == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmBulkInsertTx.mock.afterBulkInsertTxCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmBulkInsertTx.expectedInvocations)

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

// BulkInsertTx implements mm_repository.SupplierRepository
func (mmBulkInsertTx *SupplierRepositoryMock) BulkInsertTx(ctx context.Context, tx pgx.Tx, requestID uuid.UUID, suppliers []*model.Supplier) (err error) {
	mm_atomic.AddUint64(&mmBulkInsertTx.beforeBulkInsertTxCounter, 1)
	defer mm_atomic.AddUint64(&mmBulkInsertTx.afterBulkInsertTxCounter, 1)

	mmBulkInsertTx.t.Helper()

	if mmBulkInsertTx.inspectFuncBulkInsertTx != nil {
		mmBulkInsertTx.inspectFuncBulkInsertTx(ctx, tx, requestID, suppliers)
	}

	mm_params := SupplierRepositoryMockBulkInsertTxParams{ctx, tx, requestID, suppliers}

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

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

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

		mm_got := SupplierRepositoryMockBulkInsertTxParams{ctx, tx, requestID, suppliers}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmBulkInsertTx.t.Errorf("SupplierRepositoryMock.BulkInsertTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmBulkInsertTx.BulkInsertTxMock.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) {
				mmBulkInsertTx.t.Errorf("SupplierRepositoryMock.BulkInsertTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmBulkInsertTx.BulkInsertTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
			}

			if mm_want_ptrs.requestID != nil && !minimock.Equal(*mm_want_ptrs.requestID, mm_got.requestID) {
				mmBulkInsertTx.t.Errorf("SupplierRepositoryMock.BulkInsertTx got unexpected parameter requestID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmBulkInsertTx.BulkInsertTxMock.defaultExpectation.expectationOrigins.originRequestID, *mm_want_ptrs.requestID, mm_got.requestID, minimock.Diff(*mm_want_ptrs.requestID, mm_got.requestID))
			}

			if mm_want_ptrs.suppliers != nil && !minimock.Equal(*mm_want_ptrs.suppliers, mm_got.suppliers) {
				mmBulkInsertTx.t.Errorf("SupplierRepositoryMock.BulkInsertTx got unexpected parameter suppliers, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmBulkInsertTx.BulkInsertTxMock.defaultExpectation.expectationOrigins.originSuppliers, *mm_want_ptrs.suppliers, mm_got.suppliers, minimock.Diff(*mm_want_ptrs.suppliers, mm_got.suppliers))
			}

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

		mm_results := mmBulkInsertTx.BulkInsertTxMock.defaultExpectation.results
		if mm_results == nil {
			mmBulkInsertTx.t.Fatal("No results are set for the SupplierRepositoryMock.BulkInsertTx")
		}
		return (*mm_results).err
	}
	if mmBulkInsertTx.funcBulkInsertTx != nil {
		return mmBulkInsertTx.funcBulkInsertTx(ctx, tx, requestID, suppliers)
	}
	mmBulkInsertTx.t.Fatalf("Unexpected call to SupplierRepositoryMock.BulkInsertTx. %v %v %v %v", ctx, tx, requestID, suppliers)
	return
}

// BulkInsertTxAfterCounter returns a count of finished SupplierRepositoryMock.BulkInsertTx invocations
func (mmBulkInsertTx *SupplierRepositoryMock) BulkInsertTxAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmBulkInsertTx.afterBulkInsertTxCounter)
}

// BulkInsertTxBeforeCounter returns a count of SupplierRepositoryMock.BulkInsertTx invocations
func (mmBulkInsertTx *SupplierRepositoryMock) BulkInsertTxBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmBulkInsertTx.beforeBulkInsertTxCounter)
}

// Calls returns a list of arguments used in each call to SupplierRepositoryMock.BulkInsertTx.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmBulkInsertTx *mSupplierRepositoryMockBulkInsertTx) Calls() []*SupplierRepositoryMockBulkInsertTxParams {
	mmBulkInsertTx.mutex.RLock()

	argCopy := make([]*SupplierRepositoryMockBulkInsertTxParams, len(mmBulkInsertTx.callArgs))
	copy(argCopy, mmBulkInsertTx.callArgs)

	mmBulkInsertTx.mutex.RUnlock()

	return argCopy
}

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

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

	return m.BulkInsertTxMock.invocationsDone()
}

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

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

	if !m.BulkInsertTxMock.invocationsDone() && afterBulkInsertTxCounter > 0 {
		m.t.Errorf("Expected %d calls to SupplierRepositoryMock.BulkInsertTx at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.BulkInsertTxMock.expectedInvocations), m.BulkInsertTxMock.expectedInvocationsOrigin, afterBulkInsertTxCounter)
	}
}

type mSupplierRepositoryMockDeleteByRequestID struct {
	optional           bool
	mock               *SupplierRepositoryMock
	defaultExpectation *SupplierRepositoryMockDeleteByRequestIDExpectation
	expectations       []*SupplierRepositoryMockDeleteByRequestIDExpectation

	callArgs []*SupplierRepositoryMockDeleteByRequestIDParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// SupplierRepositoryMockDeleteByRequestIDExpectation specifies expectation struct of the SupplierRepository.DeleteByRequestID
type SupplierRepositoryMockDeleteByRequestIDExpectation struct {
	mock               *SupplierRepositoryMock
	params             *SupplierRepositoryMockDeleteByRequestIDParams
	paramPtrs          *SupplierRepositoryMockDeleteByRequestIDParamPtrs
	expectationOrigins SupplierRepositoryMockDeleteByRequestIDExpectationOrigins
	results            *SupplierRepositoryMockDeleteByRequestIDResults
	returnOrigin       string
	Counter            uint64
}

// SupplierRepositoryMockDeleteByRequestIDParams contains parameters of the SupplierRepository.DeleteByRequestID
type SupplierRepositoryMockDeleteByRequestIDParams struct {
	ctx       context.Context
	requestID uuid.UUID
}

// SupplierRepositoryMockDeleteByRequestIDParamPtrs contains pointers to parameters of the SupplierRepository.DeleteByRequestID
type SupplierRepositoryMockDeleteByRequestIDParamPtrs struct {
	ctx       *context.Context
	requestID *uuid.UUID
}

// SupplierRepositoryMockDeleteByRequestIDResults contains results of the SupplierRepository.DeleteByRequestID
type SupplierRepositoryMockDeleteByRequestIDResults struct {
	err error
}

// SupplierRepositoryMockDeleteByRequestIDOrigins contains origins of expectations of the SupplierRepository.DeleteByRequestID
type SupplierRepositoryMockDeleteByRequestIDExpectationOrigins struct {
	origin          string
	originCtx       string
	originRequestID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Optional() *mSupplierRepositoryMockDeleteByRequestID {
	mmDeleteByRequestID.optional = true
	return mmDeleteByRequestID
}

// Expect sets up expected params for SupplierRepository.DeleteByRequestID
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Expect(ctx context.Context, requestID uuid.UUID) *mSupplierRepositoryMockDeleteByRequestID {
	if mmDeleteByRequestID.mock.funcDeleteByRequestID != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Set")
	}

	if mmDeleteByRequestID.defaultExpectation == nil {
		mmDeleteByRequestID.defaultExpectation = &SupplierRepositoryMockDeleteByRequestIDExpectation{}
	}

	if mmDeleteByRequestID.defaultExpectation.paramPtrs != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by ExpectParams functions")
	}

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

	return mmDeleteByRequestID
}

// ExpectCtxParam1 sets up expected param ctx for SupplierRepository.DeleteByRequestID
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) ExpectCtxParam1(ctx context.Context) *mSupplierRepositoryMockDeleteByRequestID {
	if mmDeleteByRequestID.mock.funcDeleteByRequestID != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Set")
	}

	if mmDeleteByRequestID.defaultExpectation == nil {
		mmDeleteByRequestID.defaultExpectation = &SupplierRepositoryMockDeleteByRequestIDExpectation{}
	}

	if mmDeleteByRequestID.defaultExpectation.params != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Expect")
	}

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

	return mmDeleteByRequestID
}

// ExpectRequestIDParam2 sets up expected param requestID for SupplierRepository.DeleteByRequestID
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) ExpectRequestIDParam2(requestID uuid.UUID) *mSupplierRepositoryMockDeleteByRequestID {
	if mmDeleteByRequestID.mock.funcDeleteByRequestID != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Set")
	}

	if mmDeleteByRequestID.defaultExpectation == nil {
		mmDeleteByRequestID.defaultExpectation = &SupplierRepositoryMockDeleteByRequestIDExpectation{}
	}

	if mmDeleteByRequestID.defaultExpectation.params != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Expect")
	}

	if mmDeleteByRequestID.defaultExpectation.paramPtrs == nil {
		mmDeleteByRequestID.defaultExpectation.paramPtrs = &SupplierRepositoryMockDeleteByRequestIDParamPtrs{}
	}
	mmDeleteByRequestID.defaultExpectation.paramPtrs.requestID = &requestID
	mmDeleteByRequestID.defaultExpectation.expectationOrigins.originRequestID = minimock.CallerInfo(1)

	return mmDeleteByRequestID
}

// Inspect accepts an inspector function that has same arguments as the SupplierRepository.DeleteByRequestID
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Inspect(f func(ctx context.Context, requestID uuid.UUID)) *mSupplierRepositoryMockDeleteByRequestID {
	if mmDeleteByRequestID.mock.inspectFuncDeleteByRequestID != nil {
		mmDeleteByRequestID.mock.t.Fatalf("Inspect function is already set for SupplierRepositoryMock.DeleteByRequestID")
	}

	mmDeleteByRequestID.mock.inspectFuncDeleteByRequestID = f

	return mmDeleteByRequestID
}

// Return sets up results that will be returned by SupplierRepository.DeleteByRequestID
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Return(err error) *SupplierRepositoryMock {
	if mmDeleteByRequestID.mock.funcDeleteByRequestID != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Set")
	}

	if mmDeleteByRequestID.defaultExpectation == nil {
		mmDeleteByRequestID.defaultExpectation = &SupplierRepositoryMockDeleteByRequestIDExpectation{mock: mmDeleteByRequestID.mock}
	}
	mmDeleteByRequestID.defaultExpectation.results = &SupplierRepositoryMockDeleteByRequestIDResults{err}
	mmDeleteByRequestID.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmDeleteByRequestID.mock
}

// Set uses given function f to mock the SupplierRepository.DeleteByRequestID method
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Set(f func(ctx context.Context, requestID uuid.UUID) (err error)) *SupplierRepositoryMock {
	if mmDeleteByRequestID.defaultExpectation != nil {
		mmDeleteByRequestID.mock.t.Fatalf("Default expectation is already set for the SupplierRepository.DeleteByRequestID method")
	}

	if len(mmDeleteByRequestID.expectations) > 0 {
		mmDeleteByRequestID.mock.t.Fatalf("Some expectations are already set for the SupplierRepository.DeleteByRequestID method")
	}

	mmDeleteByRequestID.mock.funcDeleteByRequestID = f
	mmDeleteByRequestID.mock.funcDeleteByRequestIDOrigin = minimock.CallerInfo(1)
	return mmDeleteByRequestID.mock
}

// When sets expectation for the SupplierRepository.DeleteByRequestID which will trigger the result defined by the following
// Then helper
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) When(ctx context.Context, requestID uuid.UUID) *SupplierRepositoryMockDeleteByRequestIDExpectation {
	if mmDeleteByRequestID.mock.funcDeleteByRequestID != nil {
		mmDeleteByRequestID.mock.t.Fatalf("SupplierRepositoryMock.DeleteByRequestID mock is already set by Set")
	}

	expectation := &SupplierRepositoryMockDeleteByRequestIDExpectation{
		mock:               mmDeleteByRequestID.mock,
		params:             &SupplierRepositoryMockDeleteByRequestIDParams{ctx, requestID},
		expectationOrigins: SupplierRepositoryMockDeleteByRequestIDExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmDeleteByRequestID.expectations = append(mmDeleteByRequestID.expectations, expectation)
	return expectation
}

// Then sets up SupplierRepository.DeleteByRequestID return parameters for the expectation previously defined by the When method
func (e *SupplierRepositoryMockDeleteByRequestIDExpectation) Then(err error) *SupplierRepositoryMock {
	e.results = &SupplierRepositoryMockDeleteByRequestIDResults{err}
	return e.mock
}

// Times sets number of times SupplierRepository.DeleteByRequestID should be invoked
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Times(n uint64) *mSupplierRepositoryMockDeleteByRequestID {
	if n == 0 {
		mmDeleteByRequestID.mock.t.Fatalf("Times of SupplierRepositoryMock.DeleteByRequestID mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmDeleteByRequestID.expectedInvocations, n)
	mmDeleteByRequestID.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmDeleteByRequestID
}

func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) invocationsDone() bool {
	if len(mmDeleteByRequestID.expectations) == 0 && mmDeleteByRequestID.defaultExpectation == nil && mmDeleteByRequestID.mock.funcDeleteByRequestID == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmDeleteByRequestID.mock.afterDeleteByRequestIDCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmDeleteByRequestID.expectedInvocations)

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

// DeleteByRequestID implements mm_repository.SupplierRepository
func (mmDeleteByRequestID *SupplierRepositoryMock) DeleteByRequestID(ctx context.Context, requestID uuid.UUID) (err error) {
	mm_atomic.AddUint64(&mmDeleteByRequestID.beforeDeleteByRequestIDCounter, 1)
	defer mm_atomic.AddUint64(&mmDeleteByRequestID.afterDeleteByRequestIDCounter, 1)

	mmDeleteByRequestID.t.Helper()

	if mmDeleteByRequestID.inspectFuncDeleteByRequestID != nil {
		mmDeleteByRequestID.inspectFuncDeleteByRequestID(ctx, requestID)
	}

	mm_params := SupplierRepositoryMockDeleteByRequestIDParams{ctx, requestID}

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

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

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

		mm_got := SupplierRepositoryMockDeleteByRequestIDParams{ctx, requestID}

		if mm_want_ptrs != nil {

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

			if mm_want_ptrs.requestID != nil && !minimock.Equal(*mm_want_ptrs.requestID, mm_got.requestID) {
				mmDeleteByRequestID.t.Errorf("SupplierRepositoryMock.DeleteByRequestID got unexpected parameter requestID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmDeleteByRequestID.DeleteByRequestIDMock.defaultExpectation.expectationOrigins.originRequestID, *mm_want_ptrs.requestID, mm_got.requestID, minimock.Diff(*mm_want_ptrs.requestID, mm_got.requestID))
			}

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

		mm_results := mmDeleteByRequestID.DeleteByRequestIDMock.defaultExpectation.results
		if mm_results == nil {
			mmDeleteByRequestID.t.Fatal("No results are set for the SupplierRepositoryMock.DeleteByRequestID")
		}
		return (*mm_results).err
	}
	if mmDeleteByRequestID.funcDeleteByRequestID != nil {
		return mmDeleteByRequestID.funcDeleteByRequestID(ctx, requestID)
	}
	mmDeleteByRequestID.t.Fatalf("Unexpected call to SupplierRepositoryMock.DeleteByRequestID. %v %v", ctx, requestID)
	return
}

// DeleteByRequestIDAfterCounter returns a count of finished SupplierRepositoryMock.DeleteByRequestID invocations
func (mmDeleteByRequestID *SupplierRepositoryMock) DeleteByRequestIDAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDeleteByRequestID.afterDeleteByRequestIDCounter)
}

// DeleteByRequestIDBeforeCounter returns a count of SupplierRepositoryMock.DeleteByRequestID invocations
func (mmDeleteByRequestID *SupplierRepositoryMock) DeleteByRequestIDBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDeleteByRequestID.beforeDeleteByRequestIDCounter)
}

// Calls returns a list of arguments used in each call to SupplierRepositoryMock.DeleteByRequestID.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmDeleteByRequestID *mSupplierRepositoryMockDeleteByRequestID) Calls() []*SupplierRepositoryMockDeleteByRequestIDParams {
	mmDeleteByRequestID.mutex.RLock()

	argCopy := make([]*SupplierRepositoryMockDeleteByRequestIDParams, len(mmDeleteByRequestID.callArgs))
	copy(argCopy, mmDeleteByRequestID.callArgs)

	mmDeleteByRequestID.mutex.RUnlock()

	return argCopy
}

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

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

	return m.DeleteByRequestIDMock.invocationsDone()
}

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

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

	if !m.DeleteByRequestIDMock.invocationsDone() && afterDeleteByRequestIDCounter > 0 {
		m.t.Errorf("Expected %d calls to SupplierRepositoryMock.DeleteByRequestID at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.DeleteByRequestIDMock.expectedInvocations), m.DeleteByRequestIDMock.expectedInvocationsOrigin, afterDeleteByRequestIDCounter)
	}
}

type mSupplierRepositoryMockGetByRequestID struct {
	optional           bool
	mock               *SupplierRepositoryMock
	defaultExpectation *SupplierRepositoryMockGetByRequestIDExpectation
	expectations       []*SupplierRepositoryMockGetByRequestIDExpectation

	callArgs []*SupplierRepositoryMockGetByRequestIDParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// SupplierRepositoryMockGetByRequestIDExpectation specifies expectation struct of the SupplierRepository.GetByRequestID
type SupplierRepositoryMockGetByRequestIDExpectation struct {
	mock               *SupplierRepositoryMock
	params             *SupplierRepositoryMockGetByRequestIDParams
	paramPtrs          *SupplierRepositoryMockGetByRequestIDParamPtrs
	expectationOrigins SupplierRepositoryMockGetByRequestIDExpectationOrigins
	results            *SupplierRepositoryMockGetByRequestIDResults
	returnOrigin       string
	Counter            uint64
}

// SupplierRepositoryMockGetByRequestIDParams contains parameters of the SupplierRepository.GetByRequestID
type SupplierRepositoryMockGetByRequestIDParams struct {
	ctx       context.Context
	requestID uuid.UUID
}

// SupplierRepositoryMockGetByRequestIDParamPtrs contains pointers to parameters of the SupplierRepository.GetByRequestID
type SupplierRepositoryMockGetByRequestIDParamPtrs struct {
	ctx       *context.Context
	requestID *uuid.UUID
}

// SupplierRepositoryMockGetByRequestIDResults contains results of the SupplierRepository.GetByRequestID
type SupplierRepositoryMockGetByRequestIDResults struct {
	spa1 []*model.Supplier
	err  error
}

// SupplierRepositoryMockGetByRequestIDOrigins contains origins of expectations of the SupplierRepository.GetByRequestID
type SupplierRepositoryMockGetByRequestIDExpectationOrigins struct {
	origin          string
	originCtx       string
	originRequestID string
}

// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
// Optional() makes method check to work in '0 or more' mode.
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
// catch the problems when the expected method call is totally skipped during test run.
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Optional() *mSupplierRepositoryMockGetByRequestID {
	mmGetByRequestID.optional = true
	return mmGetByRequestID
}

// Expect sets up expected params for SupplierRepository.GetByRequestID
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Expect(ctx context.Context, requestID uuid.UUID) *mSupplierRepositoryMockGetByRequestID {
	if mmGetByRequestID.mock.funcGetByRequestID != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Set")
	}

	if mmGetByRequestID.defaultExpectation == nil {
		mmGetByRequestID.defaultExpectation = &SupplierRepositoryMockGetByRequestIDExpectation{}
	}

	if mmGetByRequestID.defaultExpectation.paramPtrs != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by ExpectParams functions")
	}

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

	return mmGetByRequestID
}

// ExpectCtxParam1 sets up expected param ctx for SupplierRepository.GetByRequestID
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) ExpectCtxParam1(ctx context.Context) *mSupplierRepositoryMockGetByRequestID {
	if mmGetByRequestID.mock.funcGetByRequestID != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Set")
	}

	if mmGetByRequestID.defaultExpectation == nil {
		mmGetByRequestID.defaultExpectation = &SupplierRepositoryMockGetByRequestIDExpectation{}
	}

	if mmGetByRequestID.defaultExpectation.params != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Expect")
	}

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

	return mmGetByRequestID
}

// ExpectRequestIDParam2 sets up expected param requestID for SupplierRepository.GetByRequestID
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) ExpectRequestIDParam2(requestID uuid.UUID) *mSupplierRepositoryMockGetByRequestID {
	if mmGetByRequestID.mock.funcGetByRequestID != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Set")
	}

	if mmGetByRequestID.defaultExpectation == nil {
		mmGetByRequestID.defaultExpectation = &SupplierRepositoryMockGetByRequestIDExpectation{}
	}

	if mmGetByRequestID.defaultExpectation.params != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Expect")
	}

	if mmGetByRequestID.defaultExpectation.paramPtrs == nil {
		mmGetByRequestID.defaultExpectation.paramPtrs = &SupplierRepositoryMockGetByRequestIDParamPtrs{}
	}
	mmGetByRequestID.defaultExpectation.paramPtrs.requestID = &requestID
	mmGetByRequestID.defaultExpectation.expectationOrigins.originRequestID = minimock.CallerInfo(1)

	return mmGetByRequestID
}

// Inspect accepts an inspector function that has same arguments as the SupplierRepository.GetByRequestID
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Inspect(f func(ctx context.Context, requestID uuid.UUID)) *mSupplierRepositoryMockGetByRequestID {
	if mmGetByRequestID.mock.inspectFuncGetByRequestID != nil {
		mmGetByRequestID.mock.t.Fatalf("Inspect function is already set for SupplierRepositoryMock.GetByRequestID")
	}

	mmGetByRequestID.mock.inspectFuncGetByRequestID = f

	return mmGetByRequestID
}

// Return sets up results that will be returned by SupplierRepository.GetByRequestID
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Return(spa1 []*model.Supplier, err error) *SupplierRepositoryMock {
	if mmGetByRequestID.mock.funcGetByRequestID != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Set")
	}

	if mmGetByRequestID.defaultExpectation == nil {
		mmGetByRequestID.defaultExpectation = &SupplierRepositoryMockGetByRequestIDExpectation{mock: mmGetByRequestID.mock}
	}
	mmGetByRequestID.defaultExpectation.results = &SupplierRepositoryMockGetByRequestIDResults{spa1, err}
	mmGetByRequestID.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetByRequestID.mock
}

// Set uses given function f to mock the SupplierRepository.GetByRequestID method
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Set(f func(ctx context.Context, requestID uuid.UUID) (spa1 []*model.Supplier, err error)) *SupplierRepositoryMock {
	if mmGetByRequestID.defaultExpectation != nil {
		mmGetByRequestID.mock.t.Fatalf("Default expectation is already set for the SupplierRepository.GetByRequestID method")
	}

	if len(mmGetByRequestID.expectations) > 0 {
		mmGetByRequestID.mock.t.Fatalf("Some expectations are already set for the SupplierRepository.GetByRequestID method")
	}

	mmGetByRequestID.mock.funcGetByRequestID = f
	mmGetByRequestID.mock.funcGetByRequestIDOrigin = minimock.CallerInfo(1)
	return mmGetByRequestID.mock
}

// When sets expectation for the SupplierRepository.GetByRequestID which will trigger the result defined by the following
// Then helper
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) When(ctx context.Context, requestID uuid.UUID) *SupplierRepositoryMockGetByRequestIDExpectation {
	if mmGetByRequestID.mock.funcGetByRequestID != nil {
		mmGetByRequestID.mock.t.Fatalf("SupplierRepositoryMock.GetByRequestID mock is already set by Set")
	}

	expectation := &SupplierRepositoryMockGetByRequestIDExpectation{
		mock:               mmGetByRequestID.mock,
		params:             &SupplierRepositoryMockGetByRequestIDParams{ctx, requestID},
		expectationOrigins: SupplierRepositoryMockGetByRequestIDExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetByRequestID.expectations = append(mmGetByRequestID.expectations, expectation)
	return expectation
}

// Then sets up SupplierRepository.GetByRequestID return parameters for the expectation previously defined by the When method
func (e *SupplierRepositoryMockGetByRequestIDExpectation) Then(spa1 []*model.Supplier, err error) *SupplierRepositoryMock {
	e.results = &SupplierRepositoryMockGetByRequestIDResults{spa1, err}
	return e.mock
}

// Times sets number of times SupplierRepository.GetByRequestID should be invoked
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Times(n uint64) *mSupplierRepositoryMockGetByRequestID {
	if n == 0 {
		mmGetByRequestID.mock.t.Fatalf("Times of SupplierRepositoryMock.GetByRequestID mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetByRequestID.expectedInvocations, n)
	mmGetByRequestID.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetByRequestID
}

func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) invocationsDone() bool {
	if len(mmGetByRequestID.expectations) == 0 && mmGetByRequestID.defaultExpectation == nil && mmGetByRequestID.mock.funcGetByRequestID == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetByRequestID.mock.afterGetByRequestIDCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetByRequestID.expectedInvocations)

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

// GetByRequestID implements mm_repository.SupplierRepository
func (mmGetByRequestID *SupplierRepositoryMock) GetByRequestID(ctx context.Context, requestID uuid.UUID) (spa1 []*model.Supplier, err error) {
	mm_atomic.AddUint64(&mmGetByRequestID.beforeGetByRequestIDCounter, 1)
	defer mm_atomic.AddUint64(&mmGetByRequestID.afterGetByRequestIDCounter, 1)

	mmGetByRequestID.t.Helper()

	if mmGetByRequestID.inspectFuncGetByRequestID != nil {
		mmGetByRequestID.inspectFuncGetByRequestID(ctx, requestID)
	}

	mm_params := SupplierRepositoryMockGetByRequestIDParams{ctx, requestID}

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

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

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

		mm_got := SupplierRepositoryMockGetByRequestIDParams{ctx, requestID}

		if mm_want_ptrs != nil {

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

			if mm_want_ptrs.requestID != nil && !minimock.Equal(*mm_want_ptrs.requestID, mm_got.requestID) {
				mmGetByRequestID.t.Errorf("SupplierRepositoryMock.GetByRequestID got unexpected parameter requestID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmGetByRequestID.GetByRequestIDMock.defaultExpectation.expectationOrigins.originRequestID, *mm_want_ptrs.requestID, mm_got.requestID, minimock.Diff(*mm_want_ptrs.requestID, mm_got.requestID))
			}

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

		mm_results := mmGetByRequestID.GetByRequestIDMock.defaultExpectation.results
		if mm_results == nil {
			mmGetByRequestID.t.Fatal("No results are set for the SupplierRepositoryMock.GetByRequestID")
		}
		return (*mm_results).spa1, (*mm_results).err
	}
	if mmGetByRequestID.funcGetByRequestID != nil {
		return mmGetByRequestID.funcGetByRequestID(ctx, requestID)
	}
	mmGetByRequestID.t.Fatalf("Unexpected call to SupplierRepositoryMock.GetByRequestID. %v %v", ctx, requestID)
	return
}

// GetByRequestIDAfterCounter returns a count of finished SupplierRepositoryMock.GetByRequestID invocations
func (mmGetByRequestID *SupplierRepositoryMock) GetByRequestIDAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetByRequestID.afterGetByRequestIDCounter)
}

// GetByRequestIDBeforeCounter returns a count of SupplierRepositoryMock.GetByRequestID invocations
func (mmGetByRequestID *SupplierRepositoryMock) GetByRequestIDBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetByRequestID.beforeGetByRequestIDCounter)
}

// Calls returns a list of arguments used in each call to SupplierRepositoryMock.GetByRequestID.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetByRequestID *mSupplierRepositoryMockGetByRequestID) Calls() []*SupplierRepositoryMockGetByRequestIDParams {
	mmGetByRequestID.mutex.RLock()

	argCopy := make([]*SupplierRepositoryMockGetByRequestIDParams, len(mmGetByRequestID.callArgs))
	copy(argCopy, mmGetByRequestID.callArgs)

	mmGetByRequestID.mutex.RUnlock()

	return argCopy
}

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

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

	return m.GetByRequestIDMock.invocationsDone()
}

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

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

	if !m.GetByRequestIDMock.invocationsDone() && afterGetByRequestIDCounter > 0 {
		m.t.Errorf("Expected %d calls to SupplierRepositoryMock.GetByRequestID at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetByRequestIDMock.expectedInvocations), m.GetByRequestIDMock.expectedInvocationsOrigin, afterGetByRequestIDCounter)
	}
}

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

			m.MinimockBulkInsertTxInspect()

			m.MinimockDeleteByRequestIDInspect()

			m.MinimockGetByRequestIDInspect()
		}
	})
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *SupplierRepositoryMock) 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 *SupplierRepositoryMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockBulkInsertDone() &&
		m.MinimockBulkInsertTxDone() &&
		m.MinimockDeleteByRequestIDDone() &&
		m.MinimockGetByRequestIDDone()
}