// 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.RequestService -o request_service_mock.go -n RequestServiceMock -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"
)

// RequestServiceMock implements mm_service.RequestService
type RequestServiceMock struct {
	t          minimock.Tester
	finishOnce sync.Once

	funcApproveTZ          func(ctx context.Context, requestID uuid.UUID, tzText string, userID int) (spa1 []*model.Supplier, err error)
	funcApproveTZOrigin    string
	inspectFuncApproveTZ   func(ctx context.Context, requestID uuid.UUID, tzText string, userID int)
	afterApproveTZCounter  uint64
	beforeApproveTZCounter uint64
	ApproveTZMock          mRequestServiceMockApproveTZ

	funcCreateTZ          func(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string) (u1 uuid.UUID, s1 string, err error)
	funcCreateTZOrigin    string
	inspectFuncCreateTZ   func(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string)
	afterCreateTZCounter  uint64
	beforeCreateTZCounter uint64
	CreateTZMock          mRequestServiceMockCreateTZ

	funcGetMailingList          func(ctx context.Context, userID int) (rpa1 []*model.Request, err error)
	funcGetMailingListOrigin    string
	inspectFuncGetMailingList   func(ctx context.Context, userID int)
	afterGetMailingListCounter  uint64
	beforeGetMailingListCounter uint64
	GetMailingListMock          mRequestServiceMockGetMailingList

	funcGetMailingListByID          func(ctx context.Context, requestID uuid.UUID, userID int) (rp1 *model.RequestDetail, err error)
	funcGetMailingListByIDOrigin    string
	inspectFuncGetMailingListByID   func(ctx context.Context, requestID uuid.UUID, userID int)
	afterGetMailingListByIDCounter  uint64
	beforeGetMailingListByIDCounter uint64
	GetMailingListByIDMock          mRequestServiceMockGetMailingListByID
}

// NewRequestServiceMock returns a mock for mm_service.RequestService
func NewRequestServiceMock(t minimock.Tester) *RequestServiceMock {
	m := &RequestServiceMock{t: t}

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

	m.ApproveTZMock = mRequestServiceMockApproveTZ{mock: m}
	m.ApproveTZMock.callArgs = []*RequestServiceMockApproveTZParams{}

	m.CreateTZMock = mRequestServiceMockCreateTZ{mock: m}
	m.CreateTZMock.callArgs = []*RequestServiceMockCreateTZParams{}

	m.GetMailingListMock = mRequestServiceMockGetMailingList{mock: m}
	m.GetMailingListMock.callArgs = []*RequestServiceMockGetMailingListParams{}

	m.GetMailingListByIDMock = mRequestServiceMockGetMailingListByID{mock: m}
	m.GetMailingListByIDMock.callArgs = []*RequestServiceMockGetMailingListByIDParams{}

	t.Cleanup(m.MinimockFinish)

	return m
}

type mRequestServiceMockApproveTZ struct {
	optional           bool
	mock               *RequestServiceMock
	defaultExpectation *RequestServiceMockApproveTZExpectation
	expectations       []*RequestServiceMockApproveTZExpectation

	callArgs []*RequestServiceMockApproveTZParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// RequestServiceMockApproveTZExpectation specifies expectation struct of the RequestService.ApproveTZ
type RequestServiceMockApproveTZExpectation struct {
	mock               *RequestServiceMock
	params             *RequestServiceMockApproveTZParams
	paramPtrs          *RequestServiceMockApproveTZParamPtrs
	expectationOrigins RequestServiceMockApproveTZExpectationOrigins
	results            *RequestServiceMockApproveTZResults
	returnOrigin       string
	Counter            uint64
}

// RequestServiceMockApproveTZParams contains parameters of the RequestService.ApproveTZ
type RequestServiceMockApproveTZParams struct {
	ctx       context.Context
	requestID uuid.UUID
	tzText    string
	userID    int
}

// RequestServiceMockApproveTZParamPtrs contains pointers to parameters of the RequestService.ApproveTZ
type RequestServiceMockApproveTZParamPtrs struct {
	ctx       *context.Context
	requestID *uuid.UUID
	tzText    *string
	userID    *int
}

// RequestServiceMockApproveTZResults contains results of the RequestService.ApproveTZ
type RequestServiceMockApproveTZResults struct {
	spa1 []*model.Supplier
	err  error
}

// RequestServiceMockApproveTZOrigins contains origins of expectations of the RequestService.ApproveTZ
type RequestServiceMockApproveTZExpectationOrigins struct {
	origin          string
	originCtx       string
	originRequestID string
	originTzText    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 (mmApproveTZ *mRequestServiceMockApproveTZ) Optional() *mRequestServiceMockApproveTZ {
	mmApproveTZ.optional = true
	return mmApproveTZ
}

// Expect sets up expected params for RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) Expect(ctx context.Context, requestID uuid.UUID, tzText string, userID int) *mRequestServiceMockApproveTZ {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	if mmApproveTZ.defaultExpectation == nil {
		mmApproveTZ.defaultExpectation = &RequestServiceMockApproveTZExpectation{}
	}

	if mmApproveTZ.defaultExpectation.paramPtrs != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by ExpectParams functions")
	}

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

	return mmApproveTZ
}

// ExpectCtxParam1 sets up expected param ctx for RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) ExpectCtxParam1(ctx context.Context) *mRequestServiceMockApproveTZ {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	if mmApproveTZ.defaultExpectation == nil {
		mmApproveTZ.defaultExpectation = &RequestServiceMockApproveTZExpectation{}
	}

	if mmApproveTZ.defaultExpectation.params != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Expect")
	}

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

	return mmApproveTZ
}

// ExpectRequestIDParam2 sets up expected param requestID for RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) ExpectRequestIDParam2(requestID uuid.UUID) *mRequestServiceMockApproveTZ {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	if mmApproveTZ.defaultExpectation == nil {
		mmApproveTZ.defaultExpectation = &RequestServiceMockApproveTZExpectation{}
	}

	if mmApproveTZ.defaultExpectation.params != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Expect")
	}

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

	return mmApproveTZ
}

// ExpectTzTextParam3 sets up expected param tzText for RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) ExpectTzTextParam3(tzText string) *mRequestServiceMockApproveTZ {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	if mmApproveTZ.defaultExpectation == nil {
		mmApproveTZ.defaultExpectation = &RequestServiceMockApproveTZExpectation{}
	}

	if mmApproveTZ.defaultExpectation.params != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Expect")
	}

	if mmApproveTZ.defaultExpectation.paramPtrs == nil {
		mmApproveTZ.defaultExpectation.paramPtrs = &RequestServiceMockApproveTZParamPtrs{}
	}
	mmApproveTZ.defaultExpectation.paramPtrs.tzText = &tzText
	mmApproveTZ.defaultExpectation.expectationOrigins.originTzText = minimock.CallerInfo(1)

	return mmApproveTZ
}

// ExpectUserIDParam4 sets up expected param userID for RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) ExpectUserIDParam4(userID int) *mRequestServiceMockApproveTZ {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	if mmApproveTZ.defaultExpectation == nil {
		mmApproveTZ.defaultExpectation = &RequestServiceMockApproveTZExpectation{}
	}

	if mmApproveTZ.defaultExpectation.params != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Expect")
	}

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

	return mmApproveTZ
}

// Inspect accepts an inspector function that has same arguments as the RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) Inspect(f func(ctx context.Context, requestID uuid.UUID, tzText string, userID int)) *mRequestServiceMockApproveTZ {
	if mmApproveTZ.mock.inspectFuncApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("Inspect function is already set for RequestServiceMock.ApproveTZ")
	}

	mmApproveTZ.mock.inspectFuncApproveTZ = f

	return mmApproveTZ
}

// Return sets up results that will be returned by RequestService.ApproveTZ
func (mmApproveTZ *mRequestServiceMockApproveTZ) Return(spa1 []*model.Supplier, err error) *RequestServiceMock {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	if mmApproveTZ.defaultExpectation == nil {
		mmApproveTZ.defaultExpectation = &RequestServiceMockApproveTZExpectation{mock: mmApproveTZ.mock}
	}
	mmApproveTZ.defaultExpectation.results = &RequestServiceMockApproveTZResults{spa1, err}
	mmApproveTZ.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmApproveTZ.mock
}

// Set uses given function f to mock the RequestService.ApproveTZ method
func (mmApproveTZ *mRequestServiceMockApproveTZ) Set(f func(ctx context.Context, requestID uuid.UUID, tzText string, userID int) (spa1 []*model.Supplier, err error)) *RequestServiceMock {
	if mmApproveTZ.defaultExpectation != nil {
		mmApproveTZ.mock.t.Fatalf("Default expectation is already set for the RequestService.ApproveTZ method")
	}

	if len(mmApproveTZ.expectations) > 0 {
		mmApproveTZ.mock.t.Fatalf("Some expectations are already set for the RequestService.ApproveTZ method")
	}

	mmApproveTZ.mock.funcApproveTZ = f
	mmApproveTZ.mock.funcApproveTZOrigin = minimock.CallerInfo(1)
	return mmApproveTZ.mock
}

// When sets expectation for the RequestService.ApproveTZ which will trigger the result defined by the following
// Then helper
func (mmApproveTZ *mRequestServiceMockApproveTZ) When(ctx context.Context, requestID uuid.UUID, tzText string, userID int) *RequestServiceMockApproveTZExpectation {
	if mmApproveTZ.mock.funcApproveTZ != nil {
		mmApproveTZ.mock.t.Fatalf("RequestServiceMock.ApproveTZ mock is already set by Set")
	}

	expectation := &RequestServiceMockApproveTZExpectation{
		mock:               mmApproveTZ.mock,
		params:             &RequestServiceMockApproveTZParams{ctx, requestID, tzText, userID},
		expectationOrigins: RequestServiceMockApproveTZExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmApproveTZ.expectations = append(mmApproveTZ.expectations, expectation)
	return expectation
}

// Then sets up RequestService.ApproveTZ return parameters for the expectation previously defined by the When method
func (e *RequestServiceMockApproveTZExpectation) Then(spa1 []*model.Supplier, err error) *RequestServiceMock {
	e.results = &RequestServiceMockApproveTZResults{spa1, err}
	return e.mock
}

// Times sets number of times RequestService.ApproveTZ should be invoked
func (mmApproveTZ *mRequestServiceMockApproveTZ) Times(n uint64) *mRequestServiceMockApproveTZ {
	if n == 0 {
		mmApproveTZ.mock.t.Fatalf("Times of RequestServiceMock.ApproveTZ mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmApproveTZ.expectedInvocations, n)
	mmApproveTZ.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmApproveTZ
}

func (mmApproveTZ *mRequestServiceMockApproveTZ) invocationsDone() bool {
	if len(mmApproveTZ.expectations) == 0 && mmApproveTZ.defaultExpectation == nil && mmApproveTZ.mock.funcApproveTZ == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmApproveTZ.mock.afterApproveTZCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmApproveTZ.expectedInvocations)

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

// ApproveTZ implements mm_service.RequestService
func (mmApproveTZ *RequestServiceMock) ApproveTZ(ctx context.Context, requestID uuid.UUID, tzText string, userID int) (spa1 []*model.Supplier, err error) {
	mm_atomic.AddUint64(&mmApproveTZ.beforeApproveTZCounter, 1)
	defer mm_atomic.AddUint64(&mmApproveTZ.afterApproveTZCounter, 1)

	mmApproveTZ.t.Helper()

	if mmApproveTZ.inspectFuncApproveTZ != nil {
		mmApproveTZ.inspectFuncApproveTZ(ctx, requestID, tzText, userID)
	}

	mm_params := RequestServiceMockApproveTZParams{ctx, requestID, tzText, userID}

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

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

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

		mm_got := RequestServiceMockApproveTZParams{ctx, requestID, tzText, userID}

		if mm_want_ptrs != nil {

			if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
				mmApproveTZ.t.Errorf("RequestServiceMock.ApproveTZ got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmApproveTZ.ApproveTZMock.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) {
				mmApproveTZ.t.Errorf("RequestServiceMock.ApproveTZ got unexpected parameter requestID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmApproveTZ.ApproveTZMock.defaultExpectation.expectationOrigins.originRequestID, *mm_want_ptrs.requestID, mm_got.requestID, minimock.Diff(*mm_want_ptrs.requestID, mm_got.requestID))
			}

			if mm_want_ptrs.tzText != nil && !minimock.Equal(*mm_want_ptrs.tzText, mm_got.tzText) {
				mmApproveTZ.t.Errorf("RequestServiceMock.ApproveTZ got unexpected parameter tzText, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmApproveTZ.ApproveTZMock.defaultExpectation.expectationOrigins.originTzText, *mm_want_ptrs.tzText, mm_got.tzText, minimock.Diff(*mm_want_ptrs.tzText, mm_got.tzText))
			}

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

		mm_results := mmApproveTZ.ApproveTZMock.defaultExpectation.results
		if mm_results == nil {
			mmApproveTZ.t.Fatal("No results are set for the RequestServiceMock.ApproveTZ")
		}
		return (*mm_results).spa1, (*mm_results).err
	}
	if mmApproveTZ.funcApproveTZ != nil {
		return mmApproveTZ.funcApproveTZ(ctx, requestID, tzText, userID)
	}
	mmApproveTZ.t.Fatalf("Unexpected call to RequestServiceMock.ApproveTZ. %v %v %v %v", ctx, requestID, tzText, userID)
	return
}

// ApproveTZAfterCounter returns a count of finished RequestServiceMock.ApproveTZ invocations
func (mmApproveTZ *RequestServiceMock) ApproveTZAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmApproveTZ.afterApproveTZCounter)
}

// ApproveTZBeforeCounter returns a count of RequestServiceMock.ApproveTZ invocations
func (mmApproveTZ *RequestServiceMock) ApproveTZBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmApproveTZ.beforeApproveTZCounter)
}

// Calls returns a list of arguments used in each call to RequestServiceMock.ApproveTZ.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmApproveTZ *mRequestServiceMockApproveTZ) Calls() []*RequestServiceMockApproveTZParams {
	mmApproveTZ.mutex.RLock()

	argCopy := make([]*RequestServiceMockApproveTZParams, len(mmApproveTZ.callArgs))
	copy(argCopy, mmApproveTZ.callArgs)

	mmApproveTZ.mutex.RUnlock()

	return argCopy
}

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

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

	return m.ApproveTZMock.invocationsDone()
}

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

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

	if !m.ApproveTZMock.invocationsDone() && afterApproveTZCounter > 0 {
		m.t.Errorf("Expected %d calls to RequestServiceMock.ApproveTZ at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.ApproveTZMock.expectedInvocations), m.ApproveTZMock.expectedInvocationsOrigin, afterApproveTZCounter)
	}
}

type mRequestServiceMockCreateTZ struct {
	optional           bool
	mock               *RequestServiceMock
	defaultExpectation *RequestServiceMockCreateTZExpectation
	expectations       []*RequestServiceMockCreateTZExpectation

	callArgs []*RequestServiceMockCreateTZParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// RequestServiceMockCreateTZExpectation specifies expectation struct of the RequestService.CreateTZ
type RequestServiceMockCreateTZExpectation struct {
	mock               *RequestServiceMock
	params             *RequestServiceMockCreateTZParams
	paramPtrs          *RequestServiceMockCreateTZParamPtrs
	expectationOrigins RequestServiceMockCreateTZExpectationOrigins
	results            *RequestServiceMockCreateTZResults
	returnOrigin       string
	Counter            uint64
}

// RequestServiceMockCreateTZParams contains parameters of the RequestService.CreateTZ
type RequestServiceMockCreateTZParams struct {
	ctx        context.Context
	userID     int
	requestTxt string
	fileData   []byte
	fileName   string
}

// RequestServiceMockCreateTZParamPtrs contains pointers to parameters of the RequestService.CreateTZ
type RequestServiceMockCreateTZParamPtrs struct {
	ctx        *context.Context
	userID     *int
	requestTxt *string
	fileData   *[]byte
	fileName   *string
}

// RequestServiceMockCreateTZResults contains results of the RequestService.CreateTZ
type RequestServiceMockCreateTZResults struct {
	u1  uuid.UUID
	s1  string
	err error
}

// RequestServiceMockCreateTZOrigins contains origins of expectations of the RequestService.CreateTZ
type RequestServiceMockCreateTZExpectationOrigins struct {
	origin           string
	originCtx        string
	originUserID     string
	originRequestTxt string
	originFileData   string
	originFileName   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 (mmCreateTZ *mRequestServiceMockCreateTZ) Optional() *mRequestServiceMockCreateTZ {
	mmCreateTZ.optional = true
	return mmCreateTZ
}

// Expect sets up expected params for RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) Expect(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{}
	}

	if mmCreateTZ.defaultExpectation.paramPtrs != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by ExpectParams functions")
	}

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

	return mmCreateTZ
}

// ExpectCtxParam1 sets up expected param ctx for RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) ExpectCtxParam1(ctx context.Context) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{}
	}

	if mmCreateTZ.defaultExpectation.params != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Expect")
	}

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

	return mmCreateTZ
}

// ExpectUserIDParam2 sets up expected param userID for RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) ExpectUserIDParam2(userID int) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{}
	}

	if mmCreateTZ.defaultExpectation.params != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Expect")
	}

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

	return mmCreateTZ
}

// ExpectRequestTxtParam3 sets up expected param requestTxt for RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) ExpectRequestTxtParam3(requestTxt string) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{}
	}

	if mmCreateTZ.defaultExpectation.params != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Expect")
	}

	if mmCreateTZ.defaultExpectation.paramPtrs == nil {
		mmCreateTZ.defaultExpectation.paramPtrs = &RequestServiceMockCreateTZParamPtrs{}
	}
	mmCreateTZ.defaultExpectation.paramPtrs.requestTxt = &requestTxt
	mmCreateTZ.defaultExpectation.expectationOrigins.originRequestTxt = minimock.CallerInfo(1)

	return mmCreateTZ
}

// ExpectFileDataParam4 sets up expected param fileData for RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) ExpectFileDataParam4(fileData []byte) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{}
	}

	if mmCreateTZ.defaultExpectation.params != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Expect")
	}

	if mmCreateTZ.defaultExpectation.paramPtrs == nil {
		mmCreateTZ.defaultExpectation.paramPtrs = &RequestServiceMockCreateTZParamPtrs{}
	}
	mmCreateTZ.defaultExpectation.paramPtrs.fileData = &fileData
	mmCreateTZ.defaultExpectation.expectationOrigins.originFileData = minimock.CallerInfo(1)

	return mmCreateTZ
}

// ExpectFileNameParam5 sets up expected param fileName for RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) ExpectFileNameParam5(fileName string) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{}
	}

	if mmCreateTZ.defaultExpectation.params != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Expect")
	}

	if mmCreateTZ.defaultExpectation.paramPtrs == nil {
		mmCreateTZ.defaultExpectation.paramPtrs = &RequestServiceMockCreateTZParamPtrs{}
	}
	mmCreateTZ.defaultExpectation.paramPtrs.fileName = &fileName
	mmCreateTZ.defaultExpectation.expectationOrigins.originFileName = minimock.CallerInfo(1)

	return mmCreateTZ
}

// Inspect accepts an inspector function that has same arguments as the RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) Inspect(f func(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string)) *mRequestServiceMockCreateTZ {
	if mmCreateTZ.mock.inspectFuncCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("Inspect function is already set for RequestServiceMock.CreateTZ")
	}

	mmCreateTZ.mock.inspectFuncCreateTZ = f

	return mmCreateTZ
}

// Return sets up results that will be returned by RequestService.CreateTZ
func (mmCreateTZ *mRequestServiceMockCreateTZ) Return(u1 uuid.UUID, s1 string, err error) *RequestServiceMock {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	if mmCreateTZ.defaultExpectation == nil {
		mmCreateTZ.defaultExpectation = &RequestServiceMockCreateTZExpectation{mock: mmCreateTZ.mock}
	}
	mmCreateTZ.defaultExpectation.results = &RequestServiceMockCreateTZResults{u1, s1, err}
	mmCreateTZ.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmCreateTZ.mock
}

// Set uses given function f to mock the RequestService.CreateTZ method
func (mmCreateTZ *mRequestServiceMockCreateTZ) Set(f func(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string) (u1 uuid.UUID, s1 string, err error)) *RequestServiceMock {
	if mmCreateTZ.defaultExpectation != nil {
		mmCreateTZ.mock.t.Fatalf("Default expectation is already set for the RequestService.CreateTZ method")
	}

	if len(mmCreateTZ.expectations) > 0 {
		mmCreateTZ.mock.t.Fatalf("Some expectations are already set for the RequestService.CreateTZ method")
	}

	mmCreateTZ.mock.funcCreateTZ = f
	mmCreateTZ.mock.funcCreateTZOrigin = minimock.CallerInfo(1)
	return mmCreateTZ.mock
}

// When sets expectation for the RequestService.CreateTZ which will trigger the result defined by the following
// Then helper
func (mmCreateTZ *mRequestServiceMockCreateTZ) When(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string) *RequestServiceMockCreateTZExpectation {
	if mmCreateTZ.mock.funcCreateTZ != nil {
		mmCreateTZ.mock.t.Fatalf("RequestServiceMock.CreateTZ mock is already set by Set")
	}

	expectation := &RequestServiceMockCreateTZExpectation{
		mock:               mmCreateTZ.mock,
		params:             &RequestServiceMockCreateTZParams{ctx, userID, requestTxt, fileData, fileName},
		expectationOrigins: RequestServiceMockCreateTZExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmCreateTZ.expectations = append(mmCreateTZ.expectations, expectation)
	return expectation
}

// Then sets up RequestService.CreateTZ return parameters for the expectation previously defined by the When method
func (e *RequestServiceMockCreateTZExpectation) Then(u1 uuid.UUID, s1 string, err error) *RequestServiceMock {
	e.results = &RequestServiceMockCreateTZResults{u1, s1, err}
	return e.mock
}

// Times sets number of times RequestService.CreateTZ should be invoked
func (mmCreateTZ *mRequestServiceMockCreateTZ) Times(n uint64) *mRequestServiceMockCreateTZ {
	if n == 0 {
		mmCreateTZ.mock.t.Fatalf("Times of RequestServiceMock.CreateTZ mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmCreateTZ.expectedInvocations, n)
	mmCreateTZ.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmCreateTZ
}

func (mmCreateTZ *mRequestServiceMockCreateTZ) invocationsDone() bool {
	if len(mmCreateTZ.expectations) == 0 && mmCreateTZ.defaultExpectation == nil && mmCreateTZ.mock.funcCreateTZ == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmCreateTZ.mock.afterCreateTZCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmCreateTZ.expectedInvocations)

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

// CreateTZ implements mm_service.RequestService
func (mmCreateTZ *RequestServiceMock) CreateTZ(ctx context.Context, userID int, requestTxt string, fileData []byte, fileName string) (u1 uuid.UUID, s1 string, err error) {
	mm_atomic.AddUint64(&mmCreateTZ.beforeCreateTZCounter, 1)
	defer mm_atomic.AddUint64(&mmCreateTZ.afterCreateTZCounter, 1)

	mmCreateTZ.t.Helper()

	if mmCreateTZ.inspectFuncCreateTZ != nil {
		mmCreateTZ.inspectFuncCreateTZ(ctx, userID, requestTxt, fileData, fileName)
	}

	mm_params := RequestServiceMockCreateTZParams{ctx, userID, requestTxt, fileData, fileName}

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

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

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

		mm_got := RequestServiceMockCreateTZParams{ctx, userID, requestTxt, fileData, fileName}

		if mm_want_ptrs != nil {

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

			if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
				mmCreateTZ.t.Errorf("RequestServiceMock.CreateTZ got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTZ.CreateTZMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
			}

			if mm_want_ptrs.requestTxt != nil && !minimock.Equal(*mm_want_ptrs.requestTxt, mm_got.requestTxt) {
				mmCreateTZ.t.Errorf("RequestServiceMock.CreateTZ got unexpected parameter requestTxt, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTZ.CreateTZMock.defaultExpectation.expectationOrigins.originRequestTxt, *mm_want_ptrs.requestTxt, mm_got.requestTxt, minimock.Diff(*mm_want_ptrs.requestTxt, mm_got.requestTxt))
			}

			if mm_want_ptrs.fileData != nil && !minimock.Equal(*mm_want_ptrs.fileData, mm_got.fileData) {
				mmCreateTZ.t.Errorf("RequestServiceMock.CreateTZ got unexpected parameter fileData, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTZ.CreateTZMock.defaultExpectation.expectationOrigins.originFileData, *mm_want_ptrs.fileData, mm_got.fileData, minimock.Diff(*mm_want_ptrs.fileData, mm_got.fileData))
			}

			if mm_want_ptrs.fileName != nil && !minimock.Equal(*mm_want_ptrs.fileName, mm_got.fileName) {
				mmCreateTZ.t.Errorf("RequestServiceMock.CreateTZ got unexpected parameter fileName, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
					mmCreateTZ.CreateTZMock.defaultExpectation.expectationOrigins.originFileName, *mm_want_ptrs.fileName, mm_got.fileName, minimock.Diff(*mm_want_ptrs.fileName, mm_got.fileName))
			}

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

		mm_results := mmCreateTZ.CreateTZMock.defaultExpectation.results
		if mm_results == nil {
			mmCreateTZ.t.Fatal("No results are set for the RequestServiceMock.CreateTZ")
		}
		return (*mm_results).u1, (*mm_results).s1, (*mm_results).err
	}
	if mmCreateTZ.funcCreateTZ != nil {
		return mmCreateTZ.funcCreateTZ(ctx, userID, requestTxt, fileData, fileName)
	}
	mmCreateTZ.t.Fatalf("Unexpected call to RequestServiceMock.CreateTZ. %v %v %v %v %v", ctx, userID, requestTxt, fileData, fileName)
	return
}

// CreateTZAfterCounter returns a count of finished RequestServiceMock.CreateTZ invocations
func (mmCreateTZ *RequestServiceMock) CreateTZAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreateTZ.afterCreateTZCounter)
}

// CreateTZBeforeCounter returns a count of RequestServiceMock.CreateTZ invocations
func (mmCreateTZ *RequestServiceMock) CreateTZBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmCreateTZ.beforeCreateTZCounter)
}

// Calls returns a list of arguments used in each call to RequestServiceMock.CreateTZ.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmCreateTZ *mRequestServiceMockCreateTZ) Calls() []*RequestServiceMockCreateTZParams {
	mmCreateTZ.mutex.RLock()

	argCopy := make([]*RequestServiceMockCreateTZParams, len(mmCreateTZ.callArgs))
	copy(argCopy, mmCreateTZ.callArgs)

	mmCreateTZ.mutex.RUnlock()

	return argCopy
}

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

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

	return m.CreateTZMock.invocationsDone()
}

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

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

	if !m.CreateTZMock.invocationsDone() && afterCreateTZCounter > 0 {
		m.t.Errorf("Expected %d calls to RequestServiceMock.CreateTZ at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.CreateTZMock.expectedInvocations), m.CreateTZMock.expectedInvocationsOrigin, afterCreateTZCounter)
	}
}

type mRequestServiceMockGetMailingList struct {
	optional           bool
	mock               *RequestServiceMock
	defaultExpectation *RequestServiceMockGetMailingListExpectation
	expectations       []*RequestServiceMockGetMailingListExpectation

	callArgs []*RequestServiceMockGetMailingListParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// RequestServiceMockGetMailingListExpectation specifies expectation struct of the RequestService.GetMailingList
type RequestServiceMockGetMailingListExpectation struct {
	mock               *RequestServiceMock
	params             *RequestServiceMockGetMailingListParams
	paramPtrs          *RequestServiceMockGetMailingListParamPtrs
	expectationOrigins RequestServiceMockGetMailingListExpectationOrigins
	results            *RequestServiceMockGetMailingListResults
	returnOrigin       string
	Counter            uint64
}

// RequestServiceMockGetMailingListParams contains parameters of the RequestService.GetMailingList
type RequestServiceMockGetMailingListParams struct {
	ctx    context.Context
	userID int
}

// RequestServiceMockGetMailingListParamPtrs contains pointers to parameters of the RequestService.GetMailingList
type RequestServiceMockGetMailingListParamPtrs struct {
	ctx    *context.Context
	userID *int
}

// RequestServiceMockGetMailingListResults contains results of the RequestService.GetMailingList
type RequestServiceMockGetMailingListResults struct {
	rpa1 []*model.Request
	err  error
}

// RequestServiceMockGetMailingListOrigins contains origins of expectations of the RequestService.GetMailingList
type RequestServiceMockGetMailingListExpectationOrigins struct {
	origin       string
	originCtx    string
	originUserID string
}

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

// Expect sets up expected params for RequestService.GetMailingList
func (mmGetMailingList *mRequestServiceMockGetMailingList) Expect(ctx context.Context, userID int) *mRequestServiceMockGetMailingList {
	if mmGetMailingList.mock.funcGetMailingList != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Set")
	}

	if mmGetMailingList.defaultExpectation == nil {
		mmGetMailingList.defaultExpectation = &RequestServiceMockGetMailingListExpectation{}
	}

	if mmGetMailingList.defaultExpectation.paramPtrs != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by ExpectParams functions")
	}

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

	return mmGetMailingList
}

// ExpectCtxParam1 sets up expected param ctx for RequestService.GetMailingList
func (mmGetMailingList *mRequestServiceMockGetMailingList) ExpectCtxParam1(ctx context.Context) *mRequestServiceMockGetMailingList {
	if mmGetMailingList.mock.funcGetMailingList != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Set")
	}

	if mmGetMailingList.defaultExpectation == nil {
		mmGetMailingList.defaultExpectation = &RequestServiceMockGetMailingListExpectation{}
	}

	if mmGetMailingList.defaultExpectation.params != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Expect")
	}

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

	return mmGetMailingList
}

// ExpectUserIDParam2 sets up expected param userID for RequestService.GetMailingList
func (mmGetMailingList *mRequestServiceMockGetMailingList) ExpectUserIDParam2(userID int) *mRequestServiceMockGetMailingList {
	if mmGetMailingList.mock.funcGetMailingList != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Set")
	}

	if mmGetMailingList.defaultExpectation == nil {
		mmGetMailingList.defaultExpectation = &RequestServiceMockGetMailingListExpectation{}
	}

	if mmGetMailingList.defaultExpectation.params != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Expect")
	}

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

	return mmGetMailingList
}

// Inspect accepts an inspector function that has same arguments as the RequestService.GetMailingList
func (mmGetMailingList *mRequestServiceMockGetMailingList) Inspect(f func(ctx context.Context, userID int)) *mRequestServiceMockGetMailingList {
	if mmGetMailingList.mock.inspectFuncGetMailingList != nil {
		mmGetMailingList.mock.t.Fatalf("Inspect function is already set for RequestServiceMock.GetMailingList")
	}

	mmGetMailingList.mock.inspectFuncGetMailingList = f

	return mmGetMailingList
}

// Return sets up results that will be returned by RequestService.GetMailingList
func (mmGetMailingList *mRequestServiceMockGetMailingList) Return(rpa1 []*model.Request, err error) *RequestServiceMock {
	if mmGetMailingList.mock.funcGetMailingList != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Set")
	}

	if mmGetMailingList.defaultExpectation == nil {
		mmGetMailingList.defaultExpectation = &RequestServiceMockGetMailingListExpectation{mock: mmGetMailingList.mock}
	}
	mmGetMailingList.defaultExpectation.results = &RequestServiceMockGetMailingListResults{rpa1, err}
	mmGetMailingList.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetMailingList.mock
}

// Set uses given function f to mock the RequestService.GetMailingList method
func (mmGetMailingList *mRequestServiceMockGetMailingList) Set(f func(ctx context.Context, userID int) (rpa1 []*model.Request, err error)) *RequestServiceMock {
	if mmGetMailingList.defaultExpectation != nil {
		mmGetMailingList.mock.t.Fatalf("Default expectation is already set for the RequestService.GetMailingList method")
	}

	if len(mmGetMailingList.expectations) > 0 {
		mmGetMailingList.mock.t.Fatalf("Some expectations are already set for the RequestService.GetMailingList method")
	}

	mmGetMailingList.mock.funcGetMailingList = f
	mmGetMailingList.mock.funcGetMailingListOrigin = minimock.CallerInfo(1)
	return mmGetMailingList.mock
}

// When sets expectation for the RequestService.GetMailingList which will trigger the result defined by the following
// Then helper
func (mmGetMailingList *mRequestServiceMockGetMailingList) When(ctx context.Context, userID int) *RequestServiceMockGetMailingListExpectation {
	if mmGetMailingList.mock.funcGetMailingList != nil {
		mmGetMailingList.mock.t.Fatalf("RequestServiceMock.GetMailingList mock is already set by Set")
	}

	expectation := &RequestServiceMockGetMailingListExpectation{
		mock:               mmGetMailingList.mock,
		params:             &RequestServiceMockGetMailingListParams{ctx, userID},
		expectationOrigins: RequestServiceMockGetMailingListExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetMailingList.expectations = append(mmGetMailingList.expectations, expectation)
	return expectation
}

// Then sets up RequestService.GetMailingList return parameters for the expectation previously defined by the When method
func (e *RequestServiceMockGetMailingListExpectation) Then(rpa1 []*model.Request, err error) *RequestServiceMock {
	e.results = &RequestServiceMockGetMailingListResults{rpa1, err}
	return e.mock
}

// Times sets number of times RequestService.GetMailingList should be invoked
func (mmGetMailingList *mRequestServiceMockGetMailingList) Times(n uint64) *mRequestServiceMockGetMailingList {
	if n == 0 {
		mmGetMailingList.mock.t.Fatalf("Times of RequestServiceMock.GetMailingList mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetMailingList.expectedInvocations, n)
	mmGetMailingList.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetMailingList
}

func (mmGetMailingList *mRequestServiceMockGetMailingList) invocationsDone() bool {
	if len(mmGetMailingList.expectations) == 0 && mmGetMailingList.defaultExpectation == nil && mmGetMailingList.mock.funcGetMailingList == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetMailingList.mock.afterGetMailingListCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetMailingList.expectedInvocations)

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

// GetMailingList implements mm_service.RequestService
func (mmGetMailingList *RequestServiceMock) GetMailingList(ctx context.Context, userID int) (rpa1 []*model.Request, err error) {
	mm_atomic.AddUint64(&mmGetMailingList.beforeGetMailingListCounter, 1)
	defer mm_atomic.AddUint64(&mmGetMailingList.afterGetMailingListCounter, 1)

	mmGetMailingList.t.Helper()

	if mmGetMailingList.inspectFuncGetMailingList != nil {
		mmGetMailingList.inspectFuncGetMailingList(ctx, userID)
	}

	mm_params := RequestServiceMockGetMailingListParams{ctx, userID}

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

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

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

		mm_got := RequestServiceMockGetMailingListParams{ctx, userID}

		if mm_want_ptrs != nil {

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

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

		mm_results := mmGetMailingList.GetMailingListMock.defaultExpectation.results
		if mm_results == nil {
			mmGetMailingList.t.Fatal("No results are set for the RequestServiceMock.GetMailingList")
		}
		return (*mm_results).rpa1, (*mm_results).err
	}
	if mmGetMailingList.funcGetMailingList != nil {
		return mmGetMailingList.funcGetMailingList(ctx, userID)
	}
	mmGetMailingList.t.Fatalf("Unexpected call to RequestServiceMock.GetMailingList. %v %v", ctx, userID)
	return
}

// GetMailingListAfterCounter returns a count of finished RequestServiceMock.GetMailingList invocations
func (mmGetMailingList *RequestServiceMock) GetMailingListAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetMailingList.afterGetMailingListCounter)
}

// GetMailingListBeforeCounter returns a count of RequestServiceMock.GetMailingList invocations
func (mmGetMailingList *RequestServiceMock) GetMailingListBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetMailingList.beforeGetMailingListCounter)
}

// Calls returns a list of arguments used in each call to RequestServiceMock.GetMailingList.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetMailingList *mRequestServiceMockGetMailingList) Calls() []*RequestServiceMockGetMailingListParams {
	mmGetMailingList.mutex.RLock()

	argCopy := make([]*RequestServiceMockGetMailingListParams, len(mmGetMailingList.callArgs))
	copy(argCopy, mmGetMailingList.callArgs)

	mmGetMailingList.mutex.RUnlock()

	return argCopy
}

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

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

	return m.GetMailingListMock.invocationsDone()
}

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

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

	if !m.GetMailingListMock.invocationsDone() && afterGetMailingListCounter > 0 {
		m.t.Errorf("Expected %d calls to RequestServiceMock.GetMailingList at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetMailingListMock.expectedInvocations), m.GetMailingListMock.expectedInvocationsOrigin, afterGetMailingListCounter)
	}
}

type mRequestServiceMockGetMailingListByID struct {
	optional           bool
	mock               *RequestServiceMock
	defaultExpectation *RequestServiceMockGetMailingListByIDExpectation
	expectations       []*RequestServiceMockGetMailingListByIDExpectation

	callArgs []*RequestServiceMockGetMailingListByIDParams
	mutex    sync.RWMutex

	expectedInvocations       uint64
	expectedInvocationsOrigin string
}

// RequestServiceMockGetMailingListByIDExpectation specifies expectation struct of the RequestService.GetMailingListByID
type RequestServiceMockGetMailingListByIDExpectation struct {
	mock               *RequestServiceMock
	params             *RequestServiceMockGetMailingListByIDParams
	paramPtrs          *RequestServiceMockGetMailingListByIDParamPtrs
	expectationOrigins RequestServiceMockGetMailingListByIDExpectationOrigins
	results            *RequestServiceMockGetMailingListByIDResults
	returnOrigin       string
	Counter            uint64
}

// RequestServiceMockGetMailingListByIDParams contains parameters of the RequestService.GetMailingListByID
type RequestServiceMockGetMailingListByIDParams struct {
	ctx       context.Context
	requestID uuid.UUID
	userID    int
}

// RequestServiceMockGetMailingListByIDParamPtrs contains pointers to parameters of the RequestService.GetMailingListByID
type RequestServiceMockGetMailingListByIDParamPtrs struct {
	ctx       *context.Context
	requestID *uuid.UUID
	userID    *int
}

// RequestServiceMockGetMailingListByIDResults contains results of the RequestService.GetMailingListByID
type RequestServiceMockGetMailingListByIDResults struct {
	rp1 *model.RequestDetail
	err error
}

// RequestServiceMockGetMailingListByIDOrigins contains origins of expectations of the RequestService.GetMailingListByID
type RequestServiceMockGetMailingListByIDExpectationOrigins 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 (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Optional() *mRequestServiceMockGetMailingListByID {
	mmGetMailingListByID.optional = true
	return mmGetMailingListByID
}

// Expect sets up expected params for RequestService.GetMailingListByID
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Expect(ctx context.Context, requestID uuid.UUID, userID int) *mRequestServiceMockGetMailingListByID {
	if mmGetMailingListByID.mock.funcGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Set")
	}

	if mmGetMailingListByID.defaultExpectation == nil {
		mmGetMailingListByID.defaultExpectation = &RequestServiceMockGetMailingListByIDExpectation{}
	}

	if mmGetMailingListByID.defaultExpectation.paramPtrs != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by ExpectParams functions")
	}

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

	return mmGetMailingListByID
}

// ExpectCtxParam1 sets up expected param ctx for RequestService.GetMailingListByID
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) ExpectCtxParam1(ctx context.Context) *mRequestServiceMockGetMailingListByID {
	if mmGetMailingListByID.mock.funcGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Set")
	}

	if mmGetMailingListByID.defaultExpectation == nil {
		mmGetMailingListByID.defaultExpectation = &RequestServiceMockGetMailingListByIDExpectation{}
	}

	if mmGetMailingListByID.defaultExpectation.params != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Expect")
	}

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

	return mmGetMailingListByID
}

// ExpectRequestIDParam2 sets up expected param requestID for RequestService.GetMailingListByID
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) ExpectRequestIDParam2(requestID uuid.UUID) *mRequestServiceMockGetMailingListByID {
	if mmGetMailingListByID.mock.funcGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Set")
	}

	if mmGetMailingListByID.defaultExpectation == nil {
		mmGetMailingListByID.defaultExpectation = &RequestServiceMockGetMailingListByIDExpectation{}
	}

	if mmGetMailingListByID.defaultExpectation.params != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Expect")
	}

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

	return mmGetMailingListByID
}

// ExpectUserIDParam3 sets up expected param userID for RequestService.GetMailingListByID
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) ExpectUserIDParam3(userID int) *mRequestServiceMockGetMailingListByID {
	if mmGetMailingListByID.mock.funcGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Set")
	}

	if mmGetMailingListByID.defaultExpectation == nil {
		mmGetMailingListByID.defaultExpectation = &RequestServiceMockGetMailingListByIDExpectation{}
	}

	if mmGetMailingListByID.defaultExpectation.params != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Expect")
	}

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

	return mmGetMailingListByID
}

// Inspect accepts an inspector function that has same arguments as the RequestService.GetMailingListByID
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Inspect(f func(ctx context.Context, requestID uuid.UUID, userID int)) *mRequestServiceMockGetMailingListByID {
	if mmGetMailingListByID.mock.inspectFuncGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("Inspect function is already set for RequestServiceMock.GetMailingListByID")
	}

	mmGetMailingListByID.mock.inspectFuncGetMailingListByID = f

	return mmGetMailingListByID
}

// Return sets up results that will be returned by RequestService.GetMailingListByID
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Return(rp1 *model.RequestDetail, err error) *RequestServiceMock {
	if mmGetMailingListByID.mock.funcGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Set")
	}

	if mmGetMailingListByID.defaultExpectation == nil {
		mmGetMailingListByID.defaultExpectation = &RequestServiceMockGetMailingListByIDExpectation{mock: mmGetMailingListByID.mock}
	}
	mmGetMailingListByID.defaultExpectation.results = &RequestServiceMockGetMailingListByIDResults{rp1, err}
	mmGetMailingListByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
	return mmGetMailingListByID.mock
}

// Set uses given function f to mock the RequestService.GetMailingListByID method
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Set(f func(ctx context.Context, requestID uuid.UUID, userID int) (rp1 *model.RequestDetail, err error)) *RequestServiceMock {
	if mmGetMailingListByID.defaultExpectation != nil {
		mmGetMailingListByID.mock.t.Fatalf("Default expectation is already set for the RequestService.GetMailingListByID method")
	}

	if len(mmGetMailingListByID.expectations) > 0 {
		mmGetMailingListByID.mock.t.Fatalf("Some expectations are already set for the RequestService.GetMailingListByID method")
	}

	mmGetMailingListByID.mock.funcGetMailingListByID = f
	mmGetMailingListByID.mock.funcGetMailingListByIDOrigin = minimock.CallerInfo(1)
	return mmGetMailingListByID.mock
}

// When sets expectation for the RequestService.GetMailingListByID which will trigger the result defined by the following
// Then helper
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) When(ctx context.Context, requestID uuid.UUID, userID int) *RequestServiceMockGetMailingListByIDExpectation {
	if mmGetMailingListByID.mock.funcGetMailingListByID != nil {
		mmGetMailingListByID.mock.t.Fatalf("RequestServiceMock.GetMailingListByID mock is already set by Set")
	}

	expectation := &RequestServiceMockGetMailingListByIDExpectation{
		mock:               mmGetMailingListByID.mock,
		params:             &RequestServiceMockGetMailingListByIDParams{ctx, requestID, userID},
		expectationOrigins: RequestServiceMockGetMailingListByIDExpectationOrigins{origin: minimock.CallerInfo(1)},
	}
	mmGetMailingListByID.expectations = append(mmGetMailingListByID.expectations, expectation)
	return expectation
}

// Then sets up RequestService.GetMailingListByID return parameters for the expectation previously defined by the When method
func (e *RequestServiceMockGetMailingListByIDExpectation) Then(rp1 *model.RequestDetail, err error) *RequestServiceMock {
	e.results = &RequestServiceMockGetMailingListByIDResults{rp1, err}
	return e.mock
}

// Times sets number of times RequestService.GetMailingListByID should be invoked
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Times(n uint64) *mRequestServiceMockGetMailingListByID {
	if n == 0 {
		mmGetMailingListByID.mock.t.Fatalf("Times of RequestServiceMock.GetMailingListByID mock can not be zero")
	}
	mm_atomic.StoreUint64(&mmGetMailingListByID.expectedInvocations, n)
	mmGetMailingListByID.expectedInvocationsOrigin = minimock.CallerInfo(1)
	return mmGetMailingListByID
}

func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) invocationsDone() bool {
	if len(mmGetMailingListByID.expectations) == 0 && mmGetMailingListByID.defaultExpectation == nil && mmGetMailingListByID.mock.funcGetMailingListByID == nil {
		return true
	}

	totalInvocations := mm_atomic.LoadUint64(&mmGetMailingListByID.mock.afterGetMailingListByIDCounter)
	expectedInvocations := mm_atomic.LoadUint64(&mmGetMailingListByID.expectedInvocations)

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

// GetMailingListByID implements mm_service.RequestService
func (mmGetMailingListByID *RequestServiceMock) GetMailingListByID(ctx context.Context, requestID uuid.UUID, userID int) (rp1 *model.RequestDetail, err error) {
	mm_atomic.AddUint64(&mmGetMailingListByID.beforeGetMailingListByIDCounter, 1)
	defer mm_atomic.AddUint64(&mmGetMailingListByID.afterGetMailingListByIDCounter, 1)

	mmGetMailingListByID.t.Helper()

	if mmGetMailingListByID.inspectFuncGetMailingListByID != nil {
		mmGetMailingListByID.inspectFuncGetMailingListByID(ctx, requestID, userID)
	}

	mm_params := RequestServiceMockGetMailingListByIDParams{ctx, requestID, userID}

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

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

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

		mm_got := RequestServiceMockGetMailingListByIDParams{ctx, requestID, userID}

		if mm_want_ptrs != nil {

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

		mm_results := mmGetMailingListByID.GetMailingListByIDMock.defaultExpectation.results
		if mm_results == nil {
			mmGetMailingListByID.t.Fatal("No results are set for the RequestServiceMock.GetMailingListByID")
		}
		return (*mm_results).rp1, (*mm_results).err
	}
	if mmGetMailingListByID.funcGetMailingListByID != nil {
		return mmGetMailingListByID.funcGetMailingListByID(ctx, requestID, userID)
	}
	mmGetMailingListByID.t.Fatalf("Unexpected call to RequestServiceMock.GetMailingListByID. %v %v %v", ctx, requestID, userID)
	return
}

// GetMailingListByIDAfterCounter returns a count of finished RequestServiceMock.GetMailingListByID invocations
func (mmGetMailingListByID *RequestServiceMock) GetMailingListByIDAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetMailingListByID.afterGetMailingListByIDCounter)
}

// GetMailingListByIDBeforeCounter returns a count of RequestServiceMock.GetMailingListByID invocations
func (mmGetMailingListByID *RequestServiceMock) GetMailingListByIDBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetMailingListByID.beforeGetMailingListByIDCounter)
}

// Calls returns a list of arguments used in each call to RequestServiceMock.GetMailingListByID.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetMailingListByID *mRequestServiceMockGetMailingListByID) Calls() []*RequestServiceMockGetMailingListByIDParams {
	mmGetMailingListByID.mutex.RLock()

	argCopy := make([]*RequestServiceMockGetMailingListByIDParams, len(mmGetMailingListByID.callArgs))
	copy(argCopy, mmGetMailingListByID.callArgs)

	mmGetMailingListByID.mutex.RUnlock()

	return argCopy
}

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

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

	return m.GetMailingListByIDMock.invocationsDone()
}

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

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

	if !m.GetMailingListByIDMock.invocationsDone() && afterGetMailingListByIDCounter > 0 {
		m.t.Errorf("Expected %d calls to RequestServiceMock.GetMailingListByID at\n%s but found %d calls",
			mm_atomic.LoadUint64(&m.GetMailingListByIDMock.expectedInvocations), m.GetMailingListByIDMock.expectedInvocationsOrigin, afterGetMailingListByIDCounter)
	}
}

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

			m.MinimockCreateTZInspect()

			m.MinimockGetMailingListInspect()

			m.MinimockGetMailingListByIDInspect()
		}
	})
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *RequestServiceMock) 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 *RequestServiceMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockApproveTZDone() &&
		m.MinimockCreateTZDone() &&
		m.MinimockGetMailingListDone() &&
		m.MinimockGetMailingListByIDDone()
}