// 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) (u1 uuid.UUID, s1 string, err error)
	funcCreateTZOrigin    string
	inspectFuncCreateTZ   func(ctx context.Context, userID int, requestTxt 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
}

// RequestServiceMockCreateTZParamPtrs contains pointers to parameters of the RequestService.CreateTZ
type RequestServiceMockCreateTZParamPtrs struct {
	ctx        *context.Context
	userID     *int
	requestTxt *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
}

// 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) *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}
	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
}

// 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)) *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) (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) *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},
		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) (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)
	}

	mm_params := RequestServiceMockCreateTZParams{ctx, userID, requestTxt}

	// 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}

		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))
			}

		} 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)
	}
	mmCreateTZ.t.Fatalf("Unexpected call to RequestServiceMock.CreateTZ. %v %v %v", ctx, userID, requestTxt)
	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()
}