// 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/service.SupplierService -o supplier_service_mock.go -n SupplierServiceMock -p mocks

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

	"github.com/gojuno/minimock/v3"
	"github.com/google/uuid"
)

// SupplierServiceMock implements mm_service.SupplierService
type SupplierServiceMock struct {
	t          minimock.Tester
	finishOnce sync.Once

	funcExportExcel          func(ctx context.Context, requestID uuid.UUID, userID int) (ba1 []byte, err error)
	funcExportExcelOrigin    string
	inspectFuncExportExcel   func(ctx context.Context, requestID uuid.UUID, userID int)
	afterExportExcelCounter  uint64
	beforeExportExcelCounter uint64
	ExportExcelMock          mSupplierServiceMockExportExcel
}

// NewSupplierServiceMock returns a mock for mm_service.SupplierService
func NewSupplierServiceMock(t minimock.Tester) *SupplierServiceMock {
	m := &SupplierServiceMock{t: t}

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

	m.ExportExcelMock = mSupplierServiceMockExportExcel{mock: m}
	m.ExportExcelMock.callArgs = []*SupplierServiceMockExportExcelParams{}

	t.Cleanup(m.MinimockFinish)

	return m
}

type mSupplierServiceMockExportExcel struct {
	optional           bool
	mock               *SupplierServiceMock
	defaultExpectation *SupplierServiceMockExportExcelExpectation
	expectations       []*SupplierServiceMockExportExcelExpectation

	callArgs []*SupplierServiceMockExportExcelParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// SupplierServiceMockExportExcelExpectation specifies expectation struct of the SupplierService.ExportExcel
type SupplierServiceMockExportExcelExpectation struct {
	mock               *SupplierServiceMock
	params             *SupplierServiceMockExportExcelParams
	paramPtrs          *SupplierServiceMockExportExcelParamPtrs
	expectationOrigins SupplierServiceMockExportExcelExpectationOrigins
	results            *SupplierServiceMockExportExcelResults
	returnOrigin       string
	Counter            uint64
}

// SupplierServiceMockExportExcelParams contains parameters of the SupplierService.ExportExcel
type SupplierServiceMockExportExcelParams struct {
	ctx       context.Context
	requestID uuid.UUID
	userID    int
}

// SupplierServiceMockExportExcelParamPtrs contains pointers to parameters of the SupplierService.ExportExcel
type SupplierServiceMockExportExcelParamPtrs struct {
	ctx       *context.Context
	requestID *uuid.UUID
	userID    *int
}

// SupplierServiceMockExportExcelResults contains results of the SupplierService.ExportExcel
type SupplierServiceMockExportExcelResults struct {
	ba1 []byte
	err error
}

// SupplierServiceMockExportExcelOrigins contains origins of expectations of the SupplierService.ExportExcel
type SupplierServiceMockExportExcelExpectationOrigins struct {
	origin          string
	originCtx       string
	originRequestID string
	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 (mmExportExcel *mSupplierServiceMockExportExcel) Optional() *mSupplierServiceMockExportExcel {
	mmExportExcel.optional = true
	return mmExportExcel
}

// Expect sets up expected params for SupplierService.ExportExcel
func (mmExportExcel *mSupplierServiceMockExportExcel) Expect(ctx context.Context, requestID uuid.UUID, userID int) *mSupplierServiceMockExportExcel {
	if mmExportExcel.mock.funcExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
	}

	if mmExportExcel.defaultExpectation == nil {
		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
	}

	if mmExportExcel.defaultExpectation.paramPtrs != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by ExpectParams functions")
	}

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

	return mmExportExcel
}

// ExpectCtxParam1 sets up expected param ctx for SupplierService.ExportExcel
func (mmExportExcel *mSupplierServiceMockExportExcel) ExpectCtxParam1(ctx context.Context) *mSupplierServiceMockExportExcel {
	if mmExportExcel.mock.funcExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
	}

	if mmExportExcel.defaultExpectation == nil {
		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
	}

	if mmExportExcel.defaultExpectation.params != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Expect")
	}

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

	return mmExportExcel
}

// ExpectRequestIDParam2 sets up expected param requestID for SupplierService.ExportExcel
func (mmExportExcel *mSupplierServiceMockExportExcel) ExpectRequestIDParam2(requestID uuid.UUID) *mSupplierServiceMockExportExcel {
	if mmExportExcel.mock.funcExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
	}

	if mmExportExcel.defaultExpectation == nil {
		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
	}

	if mmExportExcel.defaultExpectation.params != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Expect")
	}

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

	return mmExportExcel
}

// ExpectUserIDParam3 sets up expected param userID for SupplierService.ExportExcel
func (mmExportExcel *mSupplierServiceMockExportExcel) ExpectUserIDParam3(userID int) *mSupplierServiceMockExportExcel {
	if mmExportExcel.mock.funcExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
	}

	if mmExportExcel.defaultExpectation == nil {
		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{}
	}

	if mmExportExcel.defaultExpectation.params != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Expect")
	}

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

	return mmExportExcel
}

// Inspect accepts an inspector function that has same arguments as the SupplierService.ExportExcel
func (mmExportExcel *mSupplierServiceMockExportExcel) Inspect(f func(ctx context.Context, requestID uuid.UUID, userID int)) *mSupplierServiceMockExportExcel {
	if mmExportExcel.mock.inspectFuncExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("Inspect function is already set for SupplierServiceMock.ExportExcel")
	}

	mmExportExcel.mock.inspectFuncExportExcel = f

	return mmExportExcel
}

// Return sets up results that will be returned by SupplierService.ExportExcel
func (mmExportExcel *mSupplierServiceMockExportExcel) Return(ba1 []byte, err error) *SupplierServiceMock {
	if mmExportExcel.mock.funcExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
	}

	if mmExportExcel.defaultExpectation == nil {
		mmExportExcel.defaultExpectation = &SupplierServiceMockExportExcelExpectation{mock: mmExportExcel.mock}
	}
	mmExportExcel.defaultExpectation.results = &SupplierServiceMockExportExcelResults{ba1, err}
	mmExportExcel.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmExportExcel.mock
}

// Set uses given function f to mock the SupplierService.ExportExcel method
func (mmExportExcel *mSupplierServiceMockExportExcel) Set(f func(ctx context.Context, requestID uuid.UUID, userID int) (ba1 []byte, err error)) *SupplierServiceMock {
	if mmExportExcel.defaultExpectation != nil {
		mmExportExcel.mock.t.Fatalf("Default expectation is already set for the SupplierService.ExportExcel method")
	}

	if len(mmExportExcel.expectations) > 0 {
		mmExportExcel.mock.t.Fatalf("Some expectations are already set for the SupplierService.ExportExcel method")
	}

	mmExportExcel.mock.funcExportExcel = f
	mmExportExcel.mock.funcExportExcelOrigin = minimock.CallerInfo(1)
	return mmExportExcel.mock
}

// When sets expectation for the SupplierService.ExportExcel which will trigger the result defined by the following
// Then helper
func (mmExportExcel *mSupplierServiceMockExportExcel) When(ctx context.Context, requestID uuid.UUID, userID int) *SupplierServiceMockExportExcelExpectation {
	if mmExportExcel.mock.funcExportExcel != nil {
		mmExportExcel.mock.t.Fatalf("SupplierServiceMock.ExportExcel mock is already set by Set")
	}

	expectation := &SupplierServiceMockExportExcelExpectation{
		mock:               mmExportExcel.mock,
		params:             &SupplierServiceMockExportExcelParams{ctx, requestID, userID},
		expectationOrigins: SupplierServiceMockExportExcelExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmExportExcel.expectations = append(mmExportExcel.expectations, expectation)
	return expectation
}

// Then sets up SupplierService.ExportExcel return parameters for the expectation previously defined by the When method
func (e *SupplierServiceMockExportExcelExpectation) Then(ba1 []byte, err error) *SupplierServiceMock {
	e.results = &SupplierServiceMockExportExcelResults{ba1, err}
	return e.mock
}

// Times sets number of times SupplierService.ExportExcel should be invoked
func (mmExportExcel *mSupplierServiceMockExportExcel) Times(n uint64) *mSupplierServiceMockExportExcel {
	if n == 0 {
		mmExportExcel.mock.t.Fatalf("Times of SupplierServiceMock.ExportExcel mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmExportExcel.expectedInvocations, n)
	mmExportExcel.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmExportExcel
}

func (mmExportExcel *mSupplierServiceMockExportExcel) invocationsDone() bool {
	if len(mmExportExcel.expectations) == 0 && mmExportExcel.defaultExpectation == nil && mmExportExcel.mock.funcExportExcel == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmExportExcel.mock.afterExportExcelCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmExportExcel.expectedInvocations)

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

// ExportExcel implements mm_service.SupplierService
func (mmExportExcel *SupplierServiceMock) ExportExcel(ctx context.Context, requestID uuid.UUID, userID int) (ba1 []byte, err error) {
	mm_atomic.AddUint64(&mmExportExcel.beforeExportExcelCounter, 1)
	defer mm_atomic.AddUint64(&mmExportExcel.afterExportExcelCounter, 1)

	mmExportExcel.t.Helper()

	if mmExportExcel.inspectFuncExportExcel != nil {
		mmExportExcel.inspectFuncExportExcel(ctx, requestID, userID)
	}

	mm_params := SupplierServiceMockExportExcelParams{ctx, requestID, userID}

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

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

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

		mm_got := SupplierServiceMockExportExcelParams{ctx, requestID, userID}

		if mm_want_ptrs != nil {

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

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

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

		mm_results := mmExportExcel.ExportExcelMock.defaultExpectation.results
		if mm_results == nil {
			mmExportExcel.t.Fatal("No results are set for the SupplierServiceMock.ExportExcel")
		}
		return (*mm_results).ba1, (*mm_results).err
	}
	if mmExportExcel.funcExportExcel != nil {
		return mmExportExcel.funcExportExcel(ctx, requestID, userID)
	}
	mmExportExcel.t.Fatalf("Unexpected call to SupplierServiceMock.ExportExcel. %v %v %v", ctx, requestID, userID)
	return
}

// ExportExcelAfterCounter returns a count of finished SupplierServiceMock.ExportExcel invocations
func (mmExportExcel *SupplierServiceMock) ExportExcelAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmExportExcel.afterExportExcelCounter)
}

// ExportExcelBeforeCounter returns a count of SupplierServiceMock.ExportExcel invocations
func (mmExportExcel *SupplierServiceMock) ExportExcelBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmExportExcel.beforeExportExcelCounter)
}

// Calls returns a list of arguments used in each call to SupplierServiceMock.ExportExcel.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmExportExcel *mSupplierServiceMockExportExcel) Calls() []*SupplierServiceMockExportExcelParams {
	mmExportExcel.mutex.RLock()

	argCopy := make([]*SupplierServiceMockExportExcelParams, len(mmExportExcel.callArgs))
	copy(argCopy, mmExportExcel.callArgs)

	mmExportExcel.mutex.RUnlock()

	return argCopy
}

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

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

	return m.ExportExcelMock.invocationsDone()
}

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

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

	if !m.ExportExcelMock.invocationsDone() && afterExportExcelCounter > 0 {
		m.t.Errorf("Expected %d calls to SupplierServiceMock.ExportExcel at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.ExportExcelMock.expectedInvocations), m.ExportExcelMock.expectedInvocationsOrigin, afterExportExcelCounter)
	}
}

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

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *SupplierServiceMock) MinimockWait(timeout mm_time.Duration) {
	timeoutCh := mm_time.After(timeout)
	for {
		if m.minimockDone() {
			return
		}
		select {
		case <-timeoutCh:
			m.MinimockFinish()
			return
		case <-mm_time.After(10 * mm_time.Millisecond):
		}
	}
}

func (m *SupplierServiceMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockExportExcelDone()
}