80e5f318a9
All checks were successful
Deploy Smart Search Backend Test / deploy (push) Successful in 1m24s
4160 lines
186 KiB
Go
4160 lines
186 KiB
Go
// Code generated by http://github.com/gojuno/minimock (v3.4.7). DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
//go:generate minimock -i git.techease.ru/Smart-search/smart-search-back/internal/repository.UserRepository -o user_repository_mock.go -n UserRepositoryMock -p mocks
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
mm_atomic "sync/atomic"
|
|
mm_time "time"
|
|
|
|
"git.techease.ru/Smart-search/smart-search-back/internal/model"
|
|
"github.com/gojuno/minimock/v3"
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
// UserRepositoryMock implements mm_repository.UserRepository
|
|
type UserRepositoryMock struct {
|
|
t minimock.Tester
|
|
finishOnce sync.Once
|
|
|
|
funcCheckInviteLimit func(ctx context.Context, userID int) (b1 bool, err error)
|
|
funcCheckInviteLimitOrigin string
|
|
inspectFuncCheckInviteLimit func(ctx context.Context, userID int)
|
|
afterCheckInviteLimitCounter uint64
|
|
beforeCheckInviteLimitCounter uint64
|
|
CheckInviteLimitMock mUserRepositoryMockCheckInviteLimit
|
|
|
|
funcCheckInviteLimitTx func(ctx context.Context, tx pgx.Tx, userID int) (b1 bool, err error)
|
|
funcCheckInviteLimitTxOrigin string
|
|
inspectFuncCheckInviteLimitTx func(ctx context.Context, tx pgx.Tx, userID int)
|
|
afterCheckInviteLimitTxCounter uint64
|
|
beforeCheckInviteLimitTxCounter uint64
|
|
CheckInviteLimitTxMock mUserRepositoryMockCheckInviteLimitTx
|
|
|
|
funcCreate func(ctx context.Context, user *model.User) (err error)
|
|
funcCreateOrigin string
|
|
inspectFuncCreate func(ctx context.Context, user *model.User)
|
|
afterCreateCounter uint64
|
|
beforeCreateCounter uint64
|
|
CreateMock mUserRepositoryMockCreate
|
|
|
|
funcCreateTx func(ctx context.Context, tx pgx.Tx, user *model.User) (err error)
|
|
funcCreateTxOrigin string
|
|
inspectFuncCreateTx func(ctx context.Context, tx pgx.Tx, user *model.User)
|
|
afterCreateTxCounter uint64
|
|
beforeCreateTxCounter uint64
|
|
CreateTxMock mUserRepositoryMockCreateTx
|
|
|
|
funcFindByEmailHash func(ctx context.Context, emailHash string) (up1 *model.User, err error)
|
|
funcFindByEmailHashOrigin string
|
|
inspectFuncFindByEmailHash func(ctx context.Context, emailHash string)
|
|
afterFindByEmailHashCounter uint64
|
|
beforeFindByEmailHashCounter uint64
|
|
FindByEmailHashMock mUserRepositoryMockFindByEmailHash
|
|
|
|
funcFindByID func(ctx context.Context, userID int) (up1 *model.User, err error)
|
|
funcFindByIDOrigin string
|
|
inspectFuncFindByID func(ctx context.Context, userID int)
|
|
afterFindByIDCounter uint64
|
|
beforeFindByIDCounter uint64
|
|
FindByIDMock mUserRepositoryMockFindByID
|
|
|
|
funcGetBalance func(ctx context.Context, userID int) (f1 float64, err error)
|
|
funcGetBalanceOrigin string
|
|
inspectFuncGetBalance func(ctx context.Context, userID int)
|
|
afterGetBalanceCounter uint64
|
|
beforeGetBalanceCounter uint64
|
|
GetBalanceMock mUserRepositoryMockGetBalance
|
|
|
|
funcIncrementInvitesIssued func(ctx context.Context, userID int) (err error)
|
|
funcIncrementInvitesIssuedOrigin string
|
|
inspectFuncIncrementInvitesIssued func(ctx context.Context, userID int)
|
|
afterIncrementInvitesIssuedCounter uint64
|
|
beforeIncrementInvitesIssuedCounter uint64
|
|
IncrementInvitesIssuedMock mUserRepositoryMockIncrementInvitesIssued
|
|
|
|
funcIncrementInvitesIssuedTx func(ctx context.Context, tx pgx.Tx, userID int) (err error)
|
|
funcIncrementInvitesIssuedTxOrigin string
|
|
inspectFuncIncrementInvitesIssuedTx func(ctx context.Context, tx pgx.Tx, userID int)
|
|
afterIncrementInvitesIssuedTxCounter uint64
|
|
beforeIncrementInvitesIssuedTxCounter uint64
|
|
IncrementInvitesIssuedTxMock mUserRepositoryMockIncrementInvitesIssuedTx
|
|
|
|
funcUpdateBalance func(ctx context.Context, userID int, delta float64) (err error)
|
|
funcUpdateBalanceOrigin string
|
|
inspectFuncUpdateBalance func(ctx context.Context, userID int, delta float64)
|
|
afterUpdateBalanceCounter uint64
|
|
beforeUpdateBalanceCounter uint64
|
|
UpdateBalanceMock mUserRepositoryMockUpdateBalance
|
|
|
|
funcUpdateBalanceTx func(ctx context.Context, tx pgx.Tx, userID int, delta float64) (err error)
|
|
funcUpdateBalanceTxOrigin string
|
|
inspectFuncUpdateBalanceTx func(ctx context.Context, tx pgx.Tx, userID int, delta float64)
|
|
afterUpdateBalanceTxCounter uint64
|
|
beforeUpdateBalanceTxCounter uint64
|
|
UpdateBalanceTxMock mUserRepositoryMockUpdateBalanceTx
|
|
}
|
|
|
|
// NewUserRepositoryMock returns a mock for mm_repository.UserRepository
|
|
func NewUserRepositoryMock(t minimock.Tester) *UserRepositoryMock {
|
|
m := &UserRepositoryMock{t: t}
|
|
|
|
if controller, ok := t.(minimock.MockController); ok {
|
|
controller.RegisterMocker(m)
|
|
}
|
|
|
|
m.CheckInviteLimitMock = mUserRepositoryMockCheckInviteLimit{mock: m}
|
|
m.CheckInviteLimitMock.callArgs = []*UserRepositoryMockCheckInviteLimitParams{}
|
|
|
|
m.CheckInviteLimitTxMock = mUserRepositoryMockCheckInviteLimitTx{mock: m}
|
|
m.CheckInviteLimitTxMock.callArgs = []*UserRepositoryMockCheckInviteLimitTxParams{}
|
|
|
|
m.CreateMock = mUserRepositoryMockCreate{mock: m}
|
|
m.CreateMock.callArgs = []*UserRepositoryMockCreateParams{}
|
|
|
|
m.CreateTxMock = mUserRepositoryMockCreateTx{mock: m}
|
|
m.CreateTxMock.callArgs = []*UserRepositoryMockCreateTxParams{}
|
|
|
|
m.FindByEmailHashMock = mUserRepositoryMockFindByEmailHash{mock: m}
|
|
m.FindByEmailHashMock.callArgs = []*UserRepositoryMockFindByEmailHashParams{}
|
|
|
|
m.FindByIDMock = mUserRepositoryMockFindByID{mock: m}
|
|
m.FindByIDMock.callArgs = []*UserRepositoryMockFindByIDParams{}
|
|
|
|
m.GetBalanceMock = mUserRepositoryMockGetBalance{mock: m}
|
|
m.GetBalanceMock.callArgs = []*UserRepositoryMockGetBalanceParams{}
|
|
|
|
m.IncrementInvitesIssuedMock = mUserRepositoryMockIncrementInvitesIssued{mock: m}
|
|
m.IncrementInvitesIssuedMock.callArgs = []*UserRepositoryMockIncrementInvitesIssuedParams{}
|
|
|
|
m.IncrementInvitesIssuedTxMock = mUserRepositoryMockIncrementInvitesIssuedTx{mock: m}
|
|
m.IncrementInvitesIssuedTxMock.callArgs = []*UserRepositoryMockIncrementInvitesIssuedTxParams{}
|
|
|
|
m.UpdateBalanceMock = mUserRepositoryMockUpdateBalance{mock: m}
|
|
m.UpdateBalanceMock.callArgs = []*UserRepositoryMockUpdateBalanceParams{}
|
|
|
|
m.UpdateBalanceTxMock = mUserRepositoryMockUpdateBalanceTx{mock: m}
|
|
m.UpdateBalanceTxMock.callArgs = []*UserRepositoryMockUpdateBalanceTxParams{}
|
|
|
|
t.Cleanup(m.MinimockFinish)
|
|
|
|
return m
|
|
}
|
|
|
|
type mUserRepositoryMockCheckInviteLimit struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockCheckInviteLimitExpectation
|
|
expectations []*UserRepositoryMockCheckInviteLimitExpectation
|
|
|
|
callArgs []*UserRepositoryMockCheckInviteLimitParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitExpectation specifies expectation struct of the UserRepository.CheckInviteLimit
|
|
type UserRepositoryMockCheckInviteLimitExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockCheckInviteLimitParams
|
|
paramPtrs *UserRepositoryMockCheckInviteLimitParamPtrs
|
|
expectationOrigins UserRepositoryMockCheckInviteLimitExpectationOrigins
|
|
results *UserRepositoryMockCheckInviteLimitResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitParams contains parameters of the UserRepository.CheckInviteLimit
|
|
type UserRepositoryMockCheckInviteLimitParams struct {
|
|
ctx context.Context
|
|
userID int
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitParamPtrs contains pointers to parameters of the UserRepository.CheckInviteLimit
|
|
type UserRepositoryMockCheckInviteLimitParamPtrs struct {
|
|
ctx *context.Context
|
|
userID *int
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitResults contains results of the UserRepository.CheckInviteLimit
|
|
type UserRepositoryMockCheckInviteLimitResults struct {
|
|
b1 bool
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitOrigins contains origins of expectations of the UserRepository.CheckInviteLimit
|
|
type UserRepositoryMockCheckInviteLimitExpectationOrigins 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 (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Optional() *mUserRepositoryMockCheckInviteLimit {
|
|
mmCheckInviteLimit.optional = true
|
|
return mmCheckInviteLimit
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.CheckInviteLimit
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Expect(ctx context.Context, userID int) *mUserRepositoryMockCheckInviteLimit {
|
|
if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation == nil {
|
|
mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation.paramPtrs != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmCheckInviteLimit.defaultExpectation.params = &UserRepositoryMockCheckInviteLimitParams{ctx, userID}
|
|
mmCheckInviteLimit.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmCheckInviteLimit.expectations {
|
|
if minimock.Equal(e.params, mmCheckInviteLimit.defaultExpectation.params) {
|
|
mmCheckInviteLimit.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckInviteLimit.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmCheckInviteLimit
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.CheckInviteLimit
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCheckInviteLimit {
|
|
if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation == nil {
|
|
mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation.params != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Expect")
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation.paramPtrs == nil {
|
|
mmCheckInviteLimit.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitParamPtrs{}
|
|
}
|
|
mmCheckInviteLimit.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmCheckInviteLimit.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmCheckInviteLimit
|
|
}
|
|
|
|
// ExpectUserIDParam2 sets up expected param userID for UserRepository.CheckInviteLimit
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) ExpectUserIDParam2(userID int) *mUserRepositoryMockCheckInviteLimit {
|
|
if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation == nil {
|
|
mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation.params != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Expect")
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation.paramPtrs == nil {
|
|
mmCheckInviteLimit.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitParamPtrs{}
|
|
}
|
|
mmCheckInviteLimit.defaultExpectation.paramPtrs.userID = &userID
|
|
mmCheckInviteLimit.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmCheckInviteLimit
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.CheckInviteLimit
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockCheckInviteLimit {
|
|
if mmCheckInviteLimit.mock.inspectFuncCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.CheckInviteLimit")
|
|
}
|
|
|
|
mmCheckInviteLimit.mock.inspectFuncCheckInviteLimit = f
|
|
|
|
return mmCheckInviteLimit
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.CheckInviteLimit
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Return(b1 bool, err error) *UserRepositoryMock {
|
|
if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimit.defaultExpectation == nil {
|
|
mmCheckInviteLimit.defaultExpectation = &UserRepositoryMockCheckInviteLimitExpectation{mock: mmCheckInviteLimit.mock}
|
|
}
|
|
mmCheckInviteLimit.defaultExpectation.results = &UserRepositoryMockCheckInviteLimitResults{b1, err}
|
|
mmCheckInviteLimit.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmCheckInviteLimit.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.CheckInviteLimit method
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Set(f func(ctx context.Context, userID int) (b1 bool, err error)) *UserRepositoryMock {
|
|
if mmCheckInviteLimit.defaultExpectation != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("Default expectation is already set for the UserRepository.CheckInviteLimit method")
|
|
}
|
|
|
|
if len(mmCheckInviteLimit.expectations) > 0 {
|
|
mmCheckInviteLimit.mock.t.Fatalf("Some expectations are already set for the UserRepository.CheckInviteLimit method")
|
|
}
|
|
|
|
mmCheckInviteLimit.mock.funcCheckInviteLimit = f
|
|
mmCheckInviteLimit.mock.funcCheckInviteLimitOrigin = minimock.CallerInfo(1)
|
|
return mmCheckInviteLimit.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.CheckInviteLimit which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) When(ctx context.Context, userID int) *UserRepositoryMockCheckInviteLimitExpectation {
|
|
if mmCheckInviteLimit.mock.funcCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimit mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockCheckInviteLimitExpectation{
|
|
mock: mmCheckInviteLimit.mock,
|
|
params: &UserRepositoryMockCheckInviteLimitParams{ctx, userID},
|
|
expectationOrigins: UserRepositoryMockCheckInviteLimitExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmCheckInviteLimit.expectations = append(mmCheckInviteLimit.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.CheckInviteLimit return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockCheckInviteLimitExpectation) Then(b1 bool, err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockCheckInviteLimitResults{b1, err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.CheckInviteLimit should be invoked
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Times(n uint64) *mUserRepositoryMockCheckInviteLimit {
|
|
if n == 0 {
|
|
mmCheckInviteLimit.mock.t.Fatalf("Times of UserRepositoryMock.CheckInviteLimit mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmCheckInviteLimit.expectedInvocations, n)
|
|
mmCheckInviteLimit.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmCheckInviteLimit
|
|
}
|
|
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) invocationsDone() bool {
|
|
if len(mmCheckInviteLimit.expectations) == 0 && mmCheckInviteLimit.defaultExpectation == nil && mmCheckInviteLimit.mock.funcCheckInviteLimit == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimit.mock.afterCheckInviteLimitCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimit.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// CheckInviteLimit implements mm_repository.UserRepository
|
|
func (mmCheckInviteLimit *UserRepositoryMock) CheckInviteLimit(ctx context.Context, userID int) (b1 bool, err error) {
|
|
mm_atomic.AddUint64(&mmCheckInviteLimit.beforeCheckInviteLimitCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmCheckInviteLimit.afterCheckInviteLimitCounter, 1)
|
|
|
|
mmCheckInviteLimit.t.Helper()
|
|
|
|
if mmCheckInviteLimit.inspectFuncCheckInviteLimit != nil {
|
|
mmCheckInviteLimit.inspectFuncCheckInviteLimit(ctx, userID)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockCheckInviteLimitParams{ctx, userID}
|
|
|
|
// Record call args
|
|
mmCheckInviteLimit.CheckInviteLimitMock.mutex.Lock()
|
|
mmCheckInviteLimit.CheckInviteLimitMock.callArgs = append(mmCheckInviteLimit.CheckInviteLimitMock.callArgs, &mm_params)
|
|
mmCheckInviteLimit.CheckInviteLimitMock.mutex.Unlock()
|
|
|
|
for _, e := range mmCheckInviteLimit.CheckInviteLimitMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.b1, e.results.err
|
|
}
|
|
}
|
|
|
|
if mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.params
|
|
mm_want_ptrs := mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockCheckInviteLimitParams{ctx, userID}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmCheckInviteLimit.t.Errorf("UserRepositoryMock.CheckInviteLimit got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimit.CheckInviteLimitMock.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) {
|
|
mmCheckInviteLimit.t.Errorf("UserRepositoryMock.CheckInviteLimit got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimit.CheckInviteLimitMock.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) {
|
|
mmCheckInviteLimit.t.Errorf("UserRepositoryMock.CheckInviteLimit got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmCheckInviteLimit.CheckInviteLimitMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmCheckInviteLimit.t.Fatal("No results are set for the UserRepositoryMock.CheckInviteLimit")
|
|
}
|
|
return (*mm_results).b1, (*mm_results).err
|
|
}
|
|
if mmCheckInviteLimit.funcCheckInviteLimit != nil {
|
|
return mmCheckInviteLimit.funcCheckInviteLimit(ctx, userID)
|
|
}
|
|
mmCheckInviteLimit.t.Fatalf("Unexpected call to UserRepositoryMock.CheckInviteLimit. %v %v", ctx, userID)
|
|
return
|
|
}
|
|
|
|
// CheckInviteLimitAfterCounter returns a count of finished UserRepositoryMock.CheckInviteLimit invocations
|
|
func (mmCheckInviteLimit *UserRepositoryMock) CheckInviteLimitAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCheckInviteLimit.afterCheckInviteLimitCounter)
|
|
}
|
|
|
|
// CheckInviteLimitBeforeCounter returns a count of UserRepositoryMock.CheckInviteLimit invocations
|
|
func (mmCheckInviteLimit *UserRepositoryMock) CheckInviteLimitBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCheckInviteLimit.beforeCheckInviteLimitCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.CheckInviteLimit.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmCheckInviteLimit *mUserRepositoryMockCheckInviteLimit) Calls() []*UserRepositoryMockCheckInviteLimitParams {
|
|
mmCheckInviteLimit.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockCheckInviteLimitParams, len(mmCheckInviteLimit.callArgs))
|
|
copy(argCopy, mmCheckInviteLimit.callArgs)
|
|
|
|
mmCheckInviteLimit.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockCheckInviteLimitDone returns true if the count of the CheckInviteLimit invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockCheckInviteLimitDone() bool {
|
|
if m.CheckInviteLimitMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.CheckInviteLimitMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.CheckInviteLimitMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockCheckInviteLimitInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockCheckInviteLimitInspect() {
|
|
for _, e := range m.CheckInviteLimitMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterCheckInviteLimitCounter := mm_atomic.LoadUint64(&m.afterCheckInviteLimitCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.CheckInviteLimitMock.defaultExpectation != nil && afterCheckInviteLimitCounter < 1 {
|
|
if m.CheckInviteLimitMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s", m.CheckInviteLimitMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s with params: %#v", m.CheckInviteLimitMock.defaultExpectation.expectationOrigins.origin, *m.CheckInviteLimitMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcCheckInviteLimit != nil && afterCheckInviteLimitCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimit at\n%s", m.funcCheckInviteLimitOrigin)
|
|
}
|
|
|
|
if !m.CheckInviteLimitMock.invocationsDone() && afterCheckInviteLimitCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.CheckInviteLimit at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.CheckInviteLimitMock.expectedInvocations), m.CheckInviteLimitMock.expectedInvocationsOrigin, afterCheckInviteLimitCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockCheckInviteLimitTx struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockCheckInviteLimitTxExpectation
|
|
expectations []*UserRepositoryMockCheckInviteLimitTxExpectation
|
|
|
|
callArgs []*UserRepositoryMockCheckInviteLimitTxParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitTxExpectation specifies expectation struct of the UserRepository.CheckInviteLimitTx
|
|
type UserRepositoryMockCheckInviteLimitTxExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockCheckInviteLimitTxParams
|
|
paramPtrs *UserRepositoryMockCheckInviteLimitTxParamPtrs
|
|
expectationOrigins UserRepositoryMockCheckInviteLimitTxExpectationOrigins
|
|
results *UserRepositoryMockCheckInviteLimitTxResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitTxParams contains parameters of the UserRepository.CheckInviteLimitTx
|
|
type UserRepositoryMockCheckInviteLimitTxParams struct {
|
|
ctx context.Context
|
|
tx pgx.Tx
|
|
userID int
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitTxParamPtrs contains pointers to parameters of the UserRepository.CheckInviteLimitTx
|
|
type UserRepositoryMockCheckInviteLimitTxParamPtrs struct {
|
|
ctx *context.Context
|
|
tx *pgx.Tx
|
|
userID *int
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitTxResults contains results of the UserRepository.CheckInviteLimitTx
|
|
type UserRepositoryMockCheckInviteLimitTxResults struct {
|
|
b1 bool
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockCheckInviteLimitTxOrigins contains origins of expectations of the UserRepository.CheckInviteLimitTx
|
|
type UserRepositoryMockCheckInviteLimitTxExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originTx 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 (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Optional() *mUserRepositoryMockCheckInviteLimitTx {
|
|
mmCheckInviteLimitTx.optional = true
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.CheckInviteLimitTx
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Expect(ctx context.Context, tx pgx.Tx, userID int) *mUserRepositoryMockCheckInviteLimitTx {
|
|
if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.paramPtrs != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmCheckInviteLimitTx.defaultExpectation.params = &UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID}
|
|
mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmCheckInviteLimitTx.expectations {
|
|
if minimock.Equal(e.params, mmCheckInviteLimitTx.defaultExpectation.params) {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCheckInviteLimitTx.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.CheckInviteLimitTx
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCheckInviteLimitTx {
|
|
if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.params != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.paramPtrs == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitTxParamPtrs{}
|
|
}
|
|
mmCheckInviteLimitTx.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
// ExpectTxParam2 sets up expected param tx for UserRepository.CheckInviteLimitTx
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockCheckInviteLimitTx {
|
|
if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.params != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.paramPtrs == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitTxParamPtrs{}
|
|
}
|
|
mmCheckInviteLimitTx.defaultExpectation.paramPtrs.tx = &tx
|
|
mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)
|
|
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
// ExpectUserIDParam3 sets up expected param userID for UserRepository.CheckInviteLimitTx
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) ExpectUserIDParam3(userID int) *mUserRepositoryMockCheckInviteLimitTx {
|
|
if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{}
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.params != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation.paramPtrs == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation.paramPtrs = &UserRepositoryMockCheckInviteLimitTxParamPtrs{}
|
|
}
|
|
mmCheckInviteLimitTx.defaultExpectation.paramPtrs.userID = &userID
|
|
mmCheckInviteLimitTx.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.CheckInviteLimitTx
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Inspect(f func(ctx context.Context, tx pgx.Tx, userID int)) *mUserRepositoryMockCheckInviteLimitTx {
|
|
if mmCheckInviteLimitTx.mock.inspectFuncCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.CheckInviteLimitTx")
|
|
}
|
|
|
|
mmCheckInviteLimitTx.mock.inspectFuncCheckInviteLimitTx = f
|
|
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.CheckInviteLimitTx
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Return(b1 bool, err error) *UserRepositoryMock {
|
|
if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.defaultExpectation == nil {
|
|
mmCheckInviteLimitTx.defaultExpectation = &UserRepositoryMockCheckInviteLimitTxExpectation{mock: mmCheckInviteLimitTx.mock}
|
|
}
|
|
mmCheckInviteLimitTx.defaultExpectation.results = &UserRepositoryMockCheckInviteLimitTxResults{b1, err}
|
|
mmCheckInviteLimitTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmCheckInviteLimitTx.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.CheckInviteLimitTx method
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Set(f func(ctx context.Context, tx pgx.Tx, userID int) (b1 bool, err error)) *UserRepositoryMock {
|
|
if mmCheckInviteLimitTx.defaultExpectation != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.CheckInviteLimitTx method")
|
|
}
|
|
|
|
if len(mmCheckInviteLimitTx.expectations) > 0 {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.CheckInviteLimitTx method")
|
|
}
|
|
|
|
mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx = f
|
|
mmCheckInviteLimitTx.mock.funcCheckInviteLimitTxOrigin = minimock.CallerInfo(1)
|
|
return mmCheckInviteLimitTx.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.CheckInviteLimitTx which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) When(ctx context.Context, tx pgx.Tx, userID int) *UserRepositoryMockCheckInviteLimitTxExpectation {
|
|
if mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("UserRepositoryMock.CheckInviteLimitTx mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockCheckInviteLimitTxExpectation{
|
|
mock: mmCheckInviteLimitTx.mock,
|
|
params: &UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID},
|
|
expectationOrigins: UserRepositoryMockCheckInviteLimitTxExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmCheckInviteLimitTx.expectations = append(mmCheckInviteLimitTx.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.CheckInviteLimitTx return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockCheckInviteLimitTxExpectation) Then(b1 bool, err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockCheckInviteLimitTxResults{b1, err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.CheckInviteLimitTx should be invoked
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Times(n uint64) *mUserRepositoryMockCheckInviteLimitTx {
|
|
if n == 0 {
|
|
mmCheckInviteLimitTx.mock.t.Fatalf("Times of UserRepositoryMock.CheckInviteLimitTx mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmCheckInviteLimitTx.expectedInvocations, n)
|
|
mmCheckInviteLimitTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmCheckInviteLimitTx
|
|
}
|
|
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) invocationsDone() bool {
|
|
if len(mmCheckInviteLimitTx.expectations) == 0 && mmCheckInviteLimitTx.defaultExpectation == nil && mmCheckInviteLimitTx.mock.funcCheckInviteLimitTx == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimitTx.mock.afterCheckInviteLimitTxCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmCheckInviteLimitTx.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// CheckInviteLimitTx implements mm_repository.UserRepository
|
|
func (mmCheckInviteLimitTx *UserRepositoryMock) CheckInviteLimitTx(ctx context.Context, tx pgx.Tx, userID int) (b1 bool, err error) {
|
|
mm_atomic.AddUint64(&mmCheckInviteLimitTx.beforeCheckInviteLimitTxCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmCheckInviteLimitTx.afterCheckInviteLimitTxCounter, 1)
|
|
|
|
mmCheckInviteLimitTx.t.Helper()
|
|
|
|
if mmCheckInviteLimitTx.inspectFuncCheckInviteLimitTx != nil {
|
|
mmCheckInviteLimitTx.inspectFuncCheckInviteLimitTx(ctx, tx, userID)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID}
|
|
|
|
// Record call args
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.mutex.Lock()
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.callArgs = append(mmCheckInviteLimitTx.CheckInviteLimitTxMock.callArgs, &mm_params)
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.mutex.Unlock()
|
|
|
|
for _, e := range mmCheckInviteLimitTx.CheckInviteLimitTxMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.b1, e.results.err
|
|
}
|
|
}
|
|
|
|
if mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.params
|
|
mm_want_ptrs := mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockCheckInviteLimitTxParams{ctx, tx, userID}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
|
|
}
|
|
|
|
if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
|
|
mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
|
|
}
|
|
|
|
if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
|
|
mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.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) {
|
|
mmCheckInviteLimitTx.t.Errorf("UserRepositoryMock.CheckInviteLimitTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmCheckInviteLimitTx.CheckInviteLimitTxMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmCheckInviteLimitTx.t.Fatal("No results are set for the UserRepositoryMock.CheckInviteLimitTx")
|
|
}
|
|
return (*mm_results).b1, (*mm_results).err
|
|
}
|
|
if mmCheckInviteLimitTx.funcCheckInviteLimitTx != nil {
|
|
return mmCheckInviteLimitTx.funcCheckInviteLimitTx(ctx, tx, userID)
|
|
}
|
|
mmCheckInviteLimitTx.t.Fatalf("Unexpected call to UserRepositoryMock.CheckInviteLimitTx. %v %v %v", ctx, tx, userID)
|
|
return
|
|
}
|
|
|
|
// CheckInviteLimitTxAfterCounter returns a count of finished UserRepositoryMock.CheckInviteLimitTx invocations
|
|
func (mmCheckInviteLimitTx *UserRepositoryMock) CheckInviteLimitTxAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCheckInviteLimitTx.afterCheckInviteLimitTxCounter)
|
|
}
|
|
|
|
// CheckInviteLimitTxBeforeCounter returns a count of UserRepositoryMock.CheckInviteLimitTx invocations
|
|
func (mmCheckInviteLimitTx *UserRepositoryMock) CheckInviteLimitTxBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCheckInviteLimitTx.beforeCheckInviteLimitTxCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.CheckInviteLimitTx.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmCheckInviteLimitTx *mUserRepositoryMockCheckInviteLimitTx) Calls() []*UserRepositoryMockCheckInviteLimitTxParams {
|
|
mmCheckInviteLimitTx.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockCheckInviteLimitTxParams, len(mmCheckInviteLimitTx.callArgs))
|
|
copy(argCopy, mmCheckInviteLimitTx.callArgs)
|
|
|
|
mmCheckInviteLimitTx.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockCheckInviteLimitTxDone returns true if the count of the CheckInviteLimitTx invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockCheckInviteLimitTxDone() bool {
|
|
if m.CheckInviteLimitTxMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.CheckInviteLimitTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.CheckInviteLimitTxMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockCheckInviteLimitTxInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockCheckInviteLimitTxInspect() {
|
|
for _, e := range m.CheckInviteLimitTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterCheckInviteLimitTxCounter := mm_atomic.LoadUint64(&m.afterCheckInviteLimitTxCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.CheckInviteLimitTxMock.defaultExpectation != nil && afterCheckInviteLimitTxCounter < 1 {
|
|
if m.CheckInviteLimitTxMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s", m.CheckInviteLimitTxMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s with params: %#v", m.CheckInviteLimitTxMock.defaultExpectation.expectationOrigins.origin, *m.CheckInviteLimitTxMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcCheckInviteLimitTx != nil && afterCheckInviteLimitTxCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CheckInviteLimitTx at\n%s", m.funcCheckInviteLimitTxOrigin)
|
|
}
|
|
|
|
if !m.CheckInviteLimitTxMock.invocationsDone() && afterCheckInviteLimitTxCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.CheckInviteLimitTx at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.CheckInviteLimitTxMock.expectedInvocations), m.CheckInviteLimitTxMock.expectedInvocationsOrigin, afterCheckInviteLimitTxCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockCreate struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockCreateExpectation
|
|
expectations []*UserRepositoryMockCreateExpectation
|
|
|
|
callArgs []*UserRepositoryMockCreateParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockCreateExpectation specifies expectation struct of the UserRepository.Create
|
|
type UserRepositoryMockCreateExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockCreateParams
|
|
paramPtrs *UserRepositoryMockCreateParamPtrs
|
|
expectationOrigins UserRepositoryMockCreateExpectationOrigins
|
|
results *UserRepositoryMockCreateResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockCreateParams contains parameters of the UserRepository.Create
|
|
type UserRepositoryMockCreateParams struct {
|
|
ctx context.Context
|
|
user *model.User
|
|
}
|
|
|
|
// UserRepositoryMockCreateParamPtrs contains pointers to parameters of the UserRepository.Create
|
|
type UserRepositoryMockCreateParamPtrs struct {
|
|
ctx *context.Context
|
|
user **model.User
|
|
}
|
|
|
|
// UserRepositoryMockCreateResults contains results of the UserRepository.Create
|
|
type UserRepositoryMockCreateResults struct {
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockCreateOrigins contains origins of expectations of the UserRepository.Create
|
|
type UserRepositoryMockCreateExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originUser string
|
|
}
|
|
|
|
// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
|
|
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
|
|
// Optional() makes method check to work in '0 or more' mode.
|
|
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
|
|
// catch the problems when the expected method call is totally skipped during test run.
|
|
func (mmCreate *mUserRepositoryMockCreate) Optional() *mUserRepositoryMockCreate {
|
|
mmCreate.optional = true
|
|
return mmCreate
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.Create
|
|
func (mmCreate *mUserRepositoryMockCreate) Expect(ctx context.Context, user *model.User) *mUserRepositoryMockCreate {
|
|
if mmCreate.mock.funcCreate != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
|
|
}
|
|
|
|
if mmCreate.defaultExpectation == nil {
|
|
mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{}
|
|
}
|
|
|
|
if mmCreate.defaultExpectation.paramPtrs != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmCreate.defaultExpectation.params = &UserRepositoryMockCreateParams{ctx, user}
|
|
mmCreate.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmCreate.expectations {
|
|
if minimock.Equal(e.params, mmCreate.defaultExpectation.params) {
|
|
mmCreate.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreate.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmCreate
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.Create
|
|
func (mmCreate *mUserRepositoryMockCreate) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCreate {
|
|
if mmCreate.mock.funcCreate != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
|
|
}
|
|
|
|
if mmCreate.defaultExpectation == nil {
|
|
mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{}
|
|
}
|
|
|
|
if mmCreate.defaultExpectation.params != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Expect")
|
|
}
|
|
|
|
if mmCreate.defaultExpectation.paramPtrs == nil {
|
|
mmCreate.defaultExpectation.paramPtrs = &UserRepositoryMockCreateParamPtrs{}
|
|
}
|
|
mmCreate.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmCreate.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmCreate
|
|
}
|
|
|
|
// ExpectUserParam2 sets up expected param user for UserRepository.Create
|
|
func (mmCreate *mUserRepositoryMockCreate) ExpectUserParam2(user *model.User) *mUserRepositoryMockCreate {
|
|
if mmCreate.mock.funcCreate != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
|
|
}
|
|
|
|
if mmCreate.defaultExpectation == nil {
|
|
mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{}
|
|
}
|
|
|
|
if mmCreate.defaultExpectation.params != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Expect")
|
|
}
|
|
|
|
if mmCreate.defaultExpectation.paramPtrs == nil {
|
|
mmCreate.defaultExpectation.paramPtrs = &UserRepositoryMockCreateParamPtrs{}
|
|
}
|
|
mmCreate.defaultExpectation.paramPtrs.user = &user
|
|
mmCreate.defaultExpectation.expectationOrigins.originUser = minimock.CallerInfo(1)
|
|
|
|
return mmCreate
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.Create
|
|
func (mmCreate *mUserRepositoryMockCreate) Inspect(f func(ctx context.Context, user *model.User)) *mUserRepositoryMockCreate {
|
|
if mmCreate.mock.inspectFuncCreate != nil {
|
|
mmCreate.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.Create")
|
|
}
|
|
|
|
mmCreate.mock.inspectFuncCreate = f
|
|
|
|
return mmCreate
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.Create
|
|
func (mmCreate *mUserRepositoryMockCreate) Return(err error) *UserRepositoryMock {
|
|
if mmCreate.mock.funcCreate != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
|
|
}
|
|
|
|
if mmCreate.defaultExpectation == nil {
|
|
mmCreate.defaultExpectation = &UserRepositoryMockCreateExpectation{mock: mmCreate.mock}
|
|
}
|
|
mmCreate.defaultExpectation.results = &UserRepositoryMockCreateResults{err}
|
|
mmCreate.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmCreate.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.Create method
|
|
func (mmCreate *mUserRepositoryMockCreate) Set(f func(ctx context.Context, user *model.User) (err error)) *UserRepositoryMock {
|
|
if mmCreate.defaultExpectation != nil {
|
|
mmCreate.mock.t.Fatalf("Default expectation is already set for the UserRepository.Create method")
|
|
}
|
|
|
|
if len(mmCreate.expectations) > 0 {
|
|
mmCreate.mock.t.Fatalf("Some expectations are already set for the UserRepository.Create method")
|
|
}
|
|
|
|
mmCreate.mock.funcCreate = f
|
|
mmCreate.mock.funcCreateOrigin = minimock.CallerInfo(1)
|
|
return mmCreate.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.Create which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmCreate *mUserRepositoryMockCreate) When(ctx context.Context, user *model.User) *UserRepositoryMockCreateExpectation {
|
|
if mmCreate.mock.funcCreate != nil {
|
|
mmCreate.mock.t.Fatalf("UserRepositoryMock.Create mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockCreateExpectation{
|
|
mock: mmCreate.mock,
|
|
params: &UserRepositoryMockCreateParams{ctx, user},
|
|
expectationOrigins: UserRepositoryMockCreateExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmCreate.expectations = append(mmCreate.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.Create return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockCreateExpectation) Then(err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockCreateResults{err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.Create should be invoked
|
|
func (mmCreate *mUserRepositoryMockCreate) Times(n uint64) *mUserRepositoryMockCreate {
|
|
if n == 0 {
|
|
mmCreate.mock.t.Fatalf("Times of UserRepositoryMock.Create mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmCreate.expectedInvocations, n)
|
|
mmCreate.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmCreate
|
|
}
|
|
|
|
func (mmCreate *mUserRepositoryMockCreate) invocationsDone() bool {
|
|
if len(mmCreate.expectations) == 0 && mmCreate.defaultExpectation == nil && mmCreate.mock.funcCreate == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmCreate.mock.afterCreateCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmCreate.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// Create implements mm_repository.UserRepository
|
|
func (mmCreate *UserRepositoryMock) Create(ctx context.Context, user *model.User) (err error) {
|
|
mm_atomic.AddUint64(&mmCreate.beforeCreateCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmCreate.afterCreateCounter, 1)
|
|
|
|
mmCreate.t.Helper()
|
|
|
|
if mmCreate.inspectFuncCreate != nil {
|
|
mmCreate.inspectFuncCreate(ctx, user)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockCreateParams{ctx, user}
|
|
|
|
// Record call args
|
|
mmCreate.CreateMock.mutex.Lock()
|
|
mmCreate.CreateMock.callArgs = append(mmCreate.CreateMock.callArgs, &mm_params)
|
|
mmCreate.CreateMock.mutex.Unlock()
|
|
|
|
for _, e := range mmCreate.CreateMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.err
|
|
}
|
|
}
|
|
|
|
if mmCreate.CreateMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmCreate.CreateMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmCreate.CreateMock.defaultExpectation.params
|
|
mm_want_ptrs := mmCreate.CreateMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockCreateParams{ctx, user}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmCreate.t.Errorf("UserRepositoryMock.Create got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreate.CreateMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
|
|
}
|
|
|
|
if mm_want_ptrs.user != nil && !minimock.Equal(*mm_want_ptrs.user, mm_got.user) {
|
|
mmCreate.t.Errorf("UserRepositoryMock.Create got unexpected parameter user, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreate.CreateMock.defaultExpectation.expectationOrigins.originUser, *mm_want_ptrs.user, mm_got.user, minimock.Diff(*mm_want_ptrs.user, mm_got.user))
|
|
}
|
|
|
|
} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
|
|
mmCreate.t.Errorf("UserRepositoryMock.Create got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreate.CreateMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmCreate.CreateMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmCreate.t.Fatal("No results are set for the UserRepositoryMock.Create")
|
|
}
|
|
return (*mm_results).err
|
|
}
|
|
if mmCreate.funcCreate != nil {
|
|
return mmCreate.funcCreate(ctx, user)
|
|
}
|
|
mmCreate.t.Fatalf("Unexpected call to UserRepositoryMock.Create. %v %v", ctx, user)
|
|
return
|
|
}
|
|
|
|
// CreateAfterCounter returns a count of finished UserRepositoryMock.Create invocations
|
|
func (mmCreate *UserRepositoryMock) CreateAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCreate.afterCreateCounter)
|
|
}
|
|
|
|
// CreateBeforeCounter returns a count of UserRepositoryMock.Create invocations
|
|
func (mmCreate *UserRepositoryMock) CreateBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCreate.beforeCreateCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.Create.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmCreate *mUserRepositoryMockCreate) Calls() []*UserRepositoryMockCreateParams {
|
|
mmCreate.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockCreateParams, len(mmCreate.callArgs))
|
|
copy(argCopy, mmCreate.callArgs)
|
|
|
|
mmCreate.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockCreateDone returns true if the count of the Create invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockCreateDone() bool {
|
|
if m.CreateMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.CreateMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.CreateMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockCreateInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockCreateInspect() {
|
|
for _, e := range m.CreateMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterCreateCounter := mm_atomic.LoadUint64(&m.afterCreateCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.CreateMock.defaultExpectation != nil && afterCreateCounter < 1 {
|
|
if m.CreateMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s", m.CreateMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s with params: %#v", m.CreateMock.defaultExpectation.expectationOrigins.origin, *m.CreateMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcCreate != nil && afterCreateCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.Create at\n%s", m.funcCreateOrigin)
|
|
}
|
|
|
|
if !m.CreateMock.invocationsDone() && afterCreateCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.Create at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.CreateMock.expectedInvocations), m.CreateMock.expectedInvocationsOrigin, afterCreateCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockCreateTx struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockCreateTxExpectation
|
|
expectations []*UserRepositoryMockCreateTxExpectation
|
|
|
|
callArgs []*UserRepositoryMockCreateTxParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockCreateTxExpectation specifies expectation struct of the UserRepository.CreateTx
|
|
type UserRepositoryMockCreateTxExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockCreateTxParams
|
|
paramPtrs *UserRepositoryMockCreateTxParamPtrs
|
|
expectationOrigins UserRepositoryMockCreateTxExpectationOrigins
|
|
results *UserRepositoryMockCreateTxResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockCreateTxParams contains parameters of the UserRepository.CreateTx
|
|
type UserRepositoryMockCreateTxParams struct {
|
|
ctx context.Context
|
|
tx pgx.Tx
|
|
user *model.User
|
|
}
|
|
|
|
// UserRepositoryMockCreateTxParamPtrs contains pointers to parameters of the UserRepository.CreateTx
|
|
type UserRepositoryMockCreateTxParamPtrs struct {
|
|
ctx *context.Context
|
|
tx *pgx.Tx
|
|
user **model.User
|
|
}
|
|
|
|
// UserRepositoryMockCreateTxResults contains results of the UserRepository.CreateTx
|
|
type UserRepositoryMockCreateTxResults struct {
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockCreateTxOrigins contains origins of expectations of the UserRepository.CreateTx
|
|
type UserRepositoryMockCreateTxExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originTx string
|
|
originUser string
|
|
}
|
|
|
|
// Marks this method to be optional. The default behavior of any method with Return() is '1 or more', meaning
|
|
// the test will fail minimock's automatic final call check if the mocked method was not called at least once.
|
|
// Optional() makes method check to work in '0 or more' mode.
|
|
// It is NOT RECOMMENDED to use this option unless you really need it, as default behaviour helps to
|
|
// catch the problems when the expected method call is totally skipped during test run.
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Optional() *mUserRepositoryMockCreateTx {
|
|
mmCreateTx.optional = true
|
|
return mmCreateTx
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.CreateTx
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Expect(ctx context.Context, tx pgx.Tx, user *model.User) *mUserRepositoryMockCreateTx {
|
|
if mmCreateTx.mock.funcCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation == nil {
|
|
mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.paramPtrs != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmCreateTx.defaultExpectation.params = &UserRepositoryMockCreateTxParams{ctx, tx, user}
|
|
mmCreateTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmCreateTx.expectations {
|
|
if minimock.Equal(e.params, mmCreateTx.defaultExpectation.params) {
|
|
mmCreateTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmCreateTx.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmCreateTx
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.CreateTx
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockCreateTx {
|
|
if mmCreateTx.mock.funcCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation == nil {
|
|
mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.params != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.paramPtrs == nil {
|
|
mmCreateTx.defaultExpectation.paramPtrs = &UserRepositoryMockCreateTxParamPtrs{}
|
|
}
|
|
mmCreateTx.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmCreateTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmCreateTx
|
|
}
|
|
|
|
// ExpectTxParam2 sets up expected param tx for UserRepository.CreateTx
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockCreateTx {
|
|
if mmCreateTx.mock.funcCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation == nil {
|
|
mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.params != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.paramPtrs == nil {
|
|
mmCreateTx.defaultExpectation.paramPtrs = &UserRepositoryMockCreateTxParamPtrs{}
|
|
}
|
|
mmCreateTx.defaultExpectation.paramPtrs.tx = &tx
|
|
mmCreateTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)
|
|
|
|
return mmCreateTx
|
|
}
|
|
|
|
// ExpectUserParam3 sets up expected param user for UserRepository.CreateTx
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) ExpectUserParam3(user *model.User) *mUserRepositoryMockCreateTx {
|
|
if mmCreateTx.mock.funcCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation == nil {
|
|
mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{}
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.params != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation.paramPtrs == nil {
|
|
mmCreateTx.defaultExpectation.paramPtrs = &UserRepositoryMockCreateTxParamPtrs{}
|
|
}
|
|
mmCreateTx.defaultExpectation.paramPtrs.user = &user
|
|
mmCreateTx.defaultExpectation.expectationOrigins.originUser = minimock.CallerInfo(1)
|
|
|
|
return mmCreateTx
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.CreateTx
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Inspect(f func(ctx context.Context, tx pgx.Tx, user *model.User)) *mUserRepositoryMockCreateTx {
|
|
if mmCreateTx.mock.inspectFuncCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.CreateTx")
|
|
}
|
|
|
|
mmCreateTx.mock.inspectFuncCreateTx = f
|
|
|
|
return mmCreateTx
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.CreateTx
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Return(err error) *UserRepositoryMock {
|
|
if mmCreateTx.mock.funcCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
|
|
}
|
|
|
|
if mmCreateTx.defaultExpectation == nil {
|
|
mmCreateTx.defaultExpectation = &UserRepositoryMockCreateTxExpectation{mock: mmCreateTx.mock}
|
|
}
|
|
mmCreateTx.defaultExpectation.results = &UserRepositoryMockCreateTxResults{err}
|
|
mmCreateTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmCreateTx.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.CreateTx method
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Set(f func(ctx context.Context, tx pgx.Tx, user *model.User) (err error)) *UserRepositoryMock {
|
|
if mmCreateTx.defaultExpectation != nil {
|
|
mmCreateTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.CreateTx method")
|
|
}
|
|
|
|
if len(mmCreateTx.expectations) > 0 {
|
|
mmCreateTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.CreateTx method")
|
|
}
|
|
|
|
mmCreateTx.mock.funcCreateTx = f
|
|
mmCreateTx.mock.funcCreateTxOrigin = minimock.CallerInfo(1)
|
|
return mmCreateTx.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.CreateTx which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) When(ctx context.Context, tx pgx.Tx, user *model.User) *UserRepositoryMockCreateTxExpectation {
|
|
if mmCreateTx.mock.funcCreateTx != nil {
|
|
mmCreateTx.mock.t.Fatalf("UserRepositoryMock.CreateTx mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockCreateTxExpectation{
|
|
mock: mmCreateTx.mock,
|
|
params: &UserRepositoryMockCreateTxParams{ctx, tx, user},
|
|
expectationOrigins: UserRepositoryMockCreateTxExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmCreateTx.expectations = append(mmCreateTx.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.CreateTx return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockCreateTxExpectation) Then(err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockCreateTxResults{err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.CreateTx should be invoked
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Times(n uint64) *mUserRepositoryMockCreateTx {
|
|
if n == 0 {
|
|
mmCreateTx.mock.t.Fatalf("Times of UserRepositoryMock.CreateTx mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmCreateTx.expectedInvocations, n)
|
|
mmCreateTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmCreateTx
|
|
}
|
|
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) invocationsDone() bool {
|
|
if len(mmCreateTx.expectations) == 0 && mmCreateTx.defaultExpectation == nil && mmCreateTx.mock.funcCreateTx == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmCreateTx.mock.afterCreateTxCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmCreateTx.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// CreateTx implements mm_repository.UserRepository
|
|
func (mmCreateTx *UserRepositoryMock) CreateTx(ctx context.Context, tx pgx.Tx, user *model.User) (err error) {
|
|
mm_atomic.AddUint64(&mmCreateTx.beforeCreateTxCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmCreateTx.afterCreateTxCounter, 1)
|
|
|
|
mmCreateTx.t.Helper()
|
|
|
|
if mmCreateTx.inspectFuncCreateTx != nil {
|
|
mmCreateTx.inspectFuncCreateTx(ctx, tx, user)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockCreateTxParams{ctx, tx, user}
|
|
|
|
// Record call args
|
|
mmCreateTx.CreateTxMock.mutex.Lock()
|
|
mmCreateTx.CreateTxMock.callArgs = append(mmCreateTx.CreateTxMock.callArgs, &mm_params)
|
|
mmCreateTx.CreateTxMock.mutex.Unlock()
|
|
|
|
for _, e := range mmCreateTx.CreateTxMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.err
|
|
}
|
|
}
|
|
|
|
if mmCreateTx.CreateTxMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmCreateTx.CreateTxMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmCreateTx.CreateTxMock.defaultExpectation.params
|
|
mm_want_ptrs := mmCreateTx.CreateTxMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockCreateTxParams{ctx, tx, user}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
|
|
}
|
|
|
|
if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
|
|
mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
|
|
}
|
|
|
|
if mm_want_ptrs.user != nil && !minimock.Equal(*mm_want_ptrs.user, mm_got.user) {
|
|
mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameter user, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.originUser, *mm_want_ptrs.user, mm_got.user, minimock.Diff(*mm_want_ptrs.user, mm_got.user))
|
|
}
|
|
|
|
} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
|
|
mmCreateTx.t.Errorf("UserRepositoryMock.CreateTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmCreateTx.CreateTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmCreateTx.CreateTxMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmCreateTx.t.Fatal("No results are set for the UserRepositoryMock.CreateTx")
|
|
}
|
|
return (*mm_results).err
|
|
}
|
|
if mmCreateTx.funcCreateTx != nil {
|
|
return mmCreateTx.funcCreateTx(ctx, tx, user)
|
|
}
|
|
mmCreateTx.t.Fatalf("Unexpected call to UserRepositoryMock.CreateTx. %v %v %v", ctx, tx, user)
|
|
return
|
|
}
|
|
|
|
// CreateTxAfterCounter returns a count of finished UserRepositoryMock.CreateTx invocations
|
|
func (mmCreateTx *UserRepositoryMock) CreateTxAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCreateTx.afterCreateTxCounter)
|
|
}
|
|
|
|
// CreateTxBeforeCounter returns a count of UserRepositoryMock.CreateTx invocations
|
|
func (mmCreateTx *UserRepositoryMock) CreateTxBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmCreateTx.beforeCreateTxCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.CreateTx.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmCreateTx *mUserRepositoryMockCreateTx) Calls() []*UserRepositoryMockCreateTxParams {
|
|
mmCreateTx.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockCreateTxParams, len(mmCreateTx.callArgs))
|
|
copy(argCopy, mmCreateTx.callArgs)
|
|
|
|
mmCreateTx.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockCreateTxDone returns true if the count of the CreateTx invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockCreateTxDone() bool {
|
|
if m.CreateTxMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.CreateTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.CreateTxMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockCreateTxInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockCreateTxInspect() {
|
|
for _, e := range m.CreateTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterCreateTxCounter := mm_atomic.LoadUint64(&m.afterCreateTxCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.CreateTxMock.defaultExpectation != nil && afterCreateTxCounter < 1 {
|
|
if m.CreateTxMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s", m.CreateTxMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s with params: %#v", m.CreateTxMock.defaultExpectation.expectationOrigins.origin, *m.CreateTxMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcCreateTx != nil && afterCreateTxCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.CreateTx at\n%s", m.funcCreateTxOrigin)
|
|
}
|
|
|
|
if !m.CreateTxMock.invocationsDone() && afterCreateTxCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.CreateTx at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.CreateTxMock.expectedInvocations), m.CreateTxMock.expectedInvocationsOrigin, afterCreateTxCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockFindByEmailHash struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockFindByEmailHashExpectation
|
|
expectations []*UserRepositoryMockFindByEmailHashExpectation
|
|
|
|
callArgs []*UserRepositoryMockFindByEmailHashParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockFindByEmailHashExpectation specifies expectation struct of the UserRepository.FindByEmailHash
|
|
type UserRepositoryMockFindByEmailHashExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockFindByEmailHashParams
|
|
paramPtrs *UserRepositoryMockFindByEmailHashParamPtrs
|
|
expectationOrigins UserRepositoryMockFindByEmailHashExpectationOrigins
|
|
results *UserRepositoryMockFindByEmailHashResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockFindByEmailHashParams contains parameters of the UserRepository.FindByEmailHash
|
|
type UserRepositoryMockFindByEmailHashParams struct {
|
|
ctx context.Context
|
|
emailHash string
|
|
}
|
|
|
|
// UserRepositoryMockFindByEmailHashParamPtrs contains pointers to parameters of the UserRepository.FindByEmailHash
|
|
type UserRepositoryMockFindByEmailHashParamPtrs struct {
|
|
ctx *context.Context
|
|
emailHash *string
|
|
}
|
|
|
|
// UserRepositoryMockFindByEmailHashResults contains results of the UserRepository.FindByEmailHash
|
|
type UserRepositoryMockFindByEmailHashResults struct {
|
|
up1 *model.User
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockFindByEmailHashOrigins contains origins of expectations of the UserRepository.FindByEmailHash
|
|
type UserRepositoryMockFindByEmailHashExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originEmailHash 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 (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Optional() *mUserRepositoryMockFindByEmailHash {
|
|
mmFindByEmailHash.optional = true
|
|
return mmFindByEmailHash
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.FindByEmailHash
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Expect(ctx context.Context, emailHash string) *mUserRepositoryMockFindByEmailHash {
|
|
if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation == nil {
|
|
mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{}
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation.paramPtrs != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmFindByEmailHash.defaultExpectation.params = &UserRepositoryMockFindByEmailHashParams{ctx, emailHash}
|
|
mmFindByEmailHash.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmFindByEmailHash.expectations {
|
|
if minimock.Equal(e.params, mmFindByEmailHash.defaultExpectation.params) {
|
|
mmFindByEmailHash.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindByEmailHash.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmFindByEmailHash
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.FindByEmailHash
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockFindByEmailHash {
|
|
if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation == nil {
|
|
mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{}
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation.params != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Expect")
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation.paramPtrs == nil {
|
|
mmFindByEmailHash.defaultExpectation.paramPtrs = &UserRepositoryMockFindByEmailHashParamPtrs{}
|
|
}
|
|
mmFindByEmailHash.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmFindByEmailHash.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmFindByEmailHash
|
|
}
|
|
|
|
// ExpectEmailHashParam2 sets up expected param emailHash for UserRepository.FindByEmailHash
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) ExpectEmailHashParam2(emailHash string) *mUserRepositoryMockFindByEmailHash {
|
|
if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation == nil {
|
|
mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{}
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation.params != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Expect")
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation.paramPtrs == nil {
|
|
mmFindByEmailHash.defaultExpectation.paramPtrs = &UserRepositoryMockFindByEmailHashParamPtrs{}
|
|
}
|
|
mmFindByEmailHash.defaultExpectation.paramPtrs.emailHash = &emailHash
|
|
mmFindByEmailHash.defaultExpectation.expectationOrigins.originEmailHash = minimock.CallerInfo(1)
|
|
|
|
return mmFindByEmailHash
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.FindByEmailHash
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Inspect(f func(ctx context.Context, emailHash string)) *mUserRepositoryMockFindByEmailHash {
|
|
if mmFindByEmailHash.mock.inspectFuncFindByEmailHash != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.FindByEmailHash")
|
|
}
|
|
|
|
mmFindByEmailHash.mock.inspectFuncFindByEmailHash = f
|
|
|
|
return mmFindByEmailHash
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.FindByEmailHash
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Return(up1 *model.User, err error) *UserRepositoryMock {
|
|
if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByEmailHash.defaultExpectation == nil {
|
|
mmFindByEmailHash.defaultExpectation = &UserRepositoryMockFindByEmailHashExpectation{mock: mmFindByEmailHash.mock}
|
|
}
|
|
mmFindByEmailHash.defaultExpectation.results = &UserRepositoryMockFindByEmailHashResults{up1, err}
|
|
mmFindByEmailHash.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmFindByEmailHash.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.FindByEmailHash method
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Set(f func(ctx context.Context, emailHash string) (up1 *model.User, err error)) *UserRepositoryMock {
|
|
if mmFindByEmailHash.defaultExpectation != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("Default expectation is already set for the UserRepository.FindByEmailHash method")
|
|
}
|
|
|
|
if len(mmFindByEmailHash.expectations) > 0 {
|
|
mmFindByEmailHash.mock.t.Fatalf("Some expectations are already set for the UserRepository.FindByEmailHash method")
|
|
}
|
|
|
|
mmFindByEmailHash.mock.funcFindByEmailHash = f
|
|
mmFindByEmailHash.mock.funcFindByEmailHashOrigin = minimock.CallerInfo(1)
|
|
return mmFindByEmailHash.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.FindByEmailHash which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) When(ctx context.Context, emailHash string) *UserRepositoryMockFindByEmailHashExpectation {
|
|
if mmFindByEmailHash.mock.funcFindByEmailHash != nil {
|
|
mmFindByEmailHash.mock.t.Fatalf("UserRepositoryMock.FindByEmailHash mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockFindByEmailHashExpectation{
|
|
mock: mmFindByEmailHash.mock,
|
|
params: &UserRepositoryMockFindByEmailHashParams{ctx, emailHash},
|
|
expectationOrigins: UserRepositoryMockFindByEmailHashExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmFindByEmailHash.expectations = append(mmFindByEmailHash.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.FindByEmailHash return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockFindByEmailHashExpectation) Then(up1 *model.User, err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockFindByEmailHashResults{up1, err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.FindByEmailHash should be invoked
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Times(n uint64) *mUserRepositoryMockFindByEmailHash {
|
|
if n == 0 {
|
|
mmFindByEmailHash.mock.t.Fatalf("Times of UserRepositoryMock.FindByEmailHash mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmFindByEmailHash.expectedInvocations, n)
|
|
mmFindByEmailHash.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmFindByEmailHash
|
|
}
|
|
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) invocationsDone() bool {
|
|
if len(mmFindByEmailHash.expectations) == 0 && mmFindByEmailHash.defaultExpectation == nil && mmFindByEmailHash.mock.funcFindByEmailHash == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmFindByEmailHash.mock.afterFindByEmailHashCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmFindByEmailHash.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// FindByEmailHash implements mm_repository.UserRepository
|
|
func (mmFindByEmailHash *UserRepositoryMock) FindByEmailHash(ctx context.Context, emailHash string) (up1 *model.User, err error) {
|
|
mm_atomic.AddUint64(&mmFindByEmailHash.beforeFindByEmailHashCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmFindByEmailHash.afterFindByEmailHashCounter, 1)
|
|
|
|
mmFindByEmailHash.t.Helper()
|
|
|
|
if mmFindByEmailHash.inspectFuncFindByEmailHash != nil {
|
|
mmFindByEmailHash.inspectFuncFindByEmailHash(ctx, emailHash)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockFindByEmailHashParams{ctx, emailHash}
|
|
|
|
// Record call args
|
|
mmFindByEmailHash.FindByEmailHashMock.mutex.Lock()
|
|
mmFindByEmailHash.FindByEmailHashMock.callArgs = append(mmFindByEmailHash.FindByEmailHashMock.callArgs, &mm_params)
|
|
mmFindByEmailHash.FindByEmailHashMock.mutex.Unlock()
|
|
|
|
for _, e := range mmFindByEmailHash.FindByEmailHashMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.up1, e.results.err
|
|
}
|
|
}
|
|
|
|
if mmFindByEmailHash.FindByEmailHashMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.params
|
|
mm_want_ptrs := mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockFindByEmailHashParams{ctx, emailHash}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmFindByEmailHash.t.Errorf("UserRepositoryMock.FindByEmailHash got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
|
|
}
|
|
|
|
if mm_want_ptrs.emailHash != nil && !minimock.Equal(*mm_want_ptrs.emailHash, mm_got.emailHash) {
|
|
mmFindByEmailHash.t.Errorf("UserRepositoryMock.FindByEmailHash got unexpected parameter emailHash, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.expectationOrigins.originEmailHash, *mm_want_ptrs.emailHash, mm_got.emailHash, minimock.Diff(*mm_want_ptrs.emailHash, mm_got.emailHash))
|
|
}
|
|
|
|
} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
|
|
mmFindByEmailHash.t.Errorf("UserRepositoryMock.FindByEmailHash got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmFindByEmailHash.FindByEmailHashMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmFindByEmailHash.t.Fatal("No results are set for the UserRepositoryMock.FindByEmailHash")
|
|
}
|
|
return (*mm_results).up1, (*mm_results).err
|
|
}
|
|
if mmFindByEmailHash.funcFindByEmailHash != nil {
|
|
return mmFindByEmailHash.funcFindByEmailHash(ctx, emailHash)
|
|
}
|
|
mmFindByEmailHash.t.Fatalf("Unexpected call to UserRepositoryMock.FindByEmailHash. %v %v", ctx, emailHash)
|
|
return
|
|
}
|
|
|
|
// FindByEmailHashAfterCounter returns a count of finished UserRepositoryMock.FindByEmailHash invocations
|
|
func (mmFindByEmailHash *UserRepositoryMock) FindByEmailHashAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmFindByEmailHash.afterFindByEmailHashCounter)
|
|
}
|
|
|
|
// FindByEmailHashBeforeCounter returns a count of UserRepositoryMock.FindByEmailHash invocations
|
|
func (mmFindByEmailHash *UserRepositoryMock) FindByEmailHashBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmFindByEmailHash.beforeFindByEmailHashCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.FindByEmailHash.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmFindByEmailHash *mUserRepositoryMockFindByEmailHash) Calls() []*UserRepositoryMockFindByEmailHashParams {
|
|
mmFindByEmailHash.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockFindByEmailHashParams, len(mmFindByEmailHash.callArgs))
|
|
copy(argCopy, mmFindByEmailHash.callArgs)
|
|
|
|
mmFindByEmailHash.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockFindByEmailHashDone returns true if the count of the FindByEmailHash invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockFindByEmailHashDone() bool {
|
|
if m.FindByEmailHashMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.FindByEmailHashMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.FindByEmailHashMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockFindByEmailHashInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockFindByEmailHashInspect() {
|
|
for _, e := range m.FindByEmailHashMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterFindByEmailHashCounter := mm_atomic.LoadUint64(&m.afterFindByEmailHashCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.FindByEmailHashMock.defaultExpectation != nil && afterFindByEmailHashCounter < 1 {
|
|
if m.FindByEmailHashMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s", m.FindByEmailHashMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s with params: %#v", m.FindByEmailHashMock.defaultExpectation.expectationOrigins.origin, *m.FindByEmailHashMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcFindByEmailHash != nil && afterFindByEmailHashCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByEmailHash at\n%s", m.funcFindByEmailHashOrigin)
|
|
}
|
|
|
|
if !m.FindByEmailHashMock.invocationsDone() && afterFindByEmailHashCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.FindByEmailHash at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.FindByEmailHashMock.expectedInvocations), m.FindByEmailHashMock.expectedInvocationsOrigin, afterFindByEmailHashCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockFindByID struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockFindByIDExpectation
|
|
expectations []*UserRepositoryMockFindByIDExpectation
|
|
|
|
callArgs []*UserRepositoryMockFindByIDParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockFindByIDExpectation specifies expectation struct of the UserRepository.FindByID
|
|
type UserRepositoryMockFindByIDExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockFindByIDParams
|
|
paramPtrs *UserRepositoryMockFindByIDParamPtrs
|
|
expectationOrigins UserRepositoryMockFindByIDExpectationOrigins
|
|
results *UserRepositoryMockFindByIDResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockFindByIDParams contains parameters of the UserRepository.FindByID
|
|
type UserRepositoryMockFindByIDParams struct {
|
|
ctx context.Context
|
|
userID int
|
|
}
|
|
|
|
// UserRepositoryMockFindByIDParamPtrs contains pointers to parameters of the UserRepository.FindByID
|
|
type UserRepositoryMockFindByIDParamPtrs struct {
|
|
ctx *context.Context
|
|
userID *int
|
|
}
|
|
|
|
// UserRepositoryMockFindByIDResults contains results of the UserRepository.FindByID
|
|
type UserRepositoryMockFindByIDResults struct {
|
|
up1 *model.User
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockFindByIDOrigins contains origins of expectations of the UserRepository.FindByID
|
|
type UserRepositoryMockFindByIDExpectationOrigins 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 (mmFindByID *mUserRepositoryMockFindByID) Optional() *mUserRepositoryMockFindByID {
|
|
mmFindByID.optional = true
|
|
return mmFindByID
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.FindByID
|
|
func (mmFindByID *mUserRepositoryMockFindByID) Expect(ctx context.Context, userID int) *mUserRepositoryMockFindByID {
|
|
if mmFindByID.mock.funcFindByID != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation == nil {
|
|
mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{}
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation.paramPtrs != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmFindByID.defaultExpectation.params = &UserRepositoryMockFindByIDParams{ctx, userID}
|
|
mmFindByID.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmFindByID.expectations {
|
|
if minimock.Equal(e.params, mmFindByID.defaultExpectation.params) {
|
|
mmFindByID.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmFindByID.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmFindByID
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.FindByID
|
|
func (mmFindByID *mUserRepositoryMockFindByID) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockFindByID {
|
|
if mmFindByID.mock.funcFindByID != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation == nil {
|
|
mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{}
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation.params != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Expect")
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation.paramPtrs == nil {
|
|
mmFindByID.defaultExpectation.paramPtrs = &UserRepositoryMockFindByIDParamPtrs{}
|
|
}
|
|
mmFindByID.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmFindByID.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmFindByID
|
|
}
|
|
|
|
// ExpectUserIDParam2 sets up expected param userID for UserRepository.FindByID
|
|
func (mmFindByID *mUserRepositoryMockFindByID) ExpectUserIDParam2(userID int) *mUserRepositoryMockFindByID {
|
|
if mmFindByID.mock.funcFindByID != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation == nil {
|
|
mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{}
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation.params != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Expect")
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation.paramPtrs == nil {
|
|
mmFindByID.defaultExpectation.paramPtrs = &UserRepositoryMockFindByIDParamPtrs{}
|
|
}
|
|
mmFindByID.defaultExpectation.paramPtrs.userID = &userID
|
|
mmFindByID.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmFindByID
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.FindByID
|
|
func (mmFindByID *mUserRepositoryMockFindByID) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockFindByID {
|
|
if mmFindByID.mock.inspectFuncFindByID != nil {
|
|
mmFindByID.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.FindByID")
|
|
}
|
|
|
|
mmFindByID.mock.inspectFuncFindByID = f
|
|
|
|
return mmFindByID
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.FindByID
|
|
func (mmFindByID *mUserRepositoryMockFindByID) Return(up1 *model.User, err error) *UserRepositoryMock {
|
|
if mmFindByID.mock.funcFindByID != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
|
|
}
|
|
|
|
if mmFindByID.defaultExpectation == nil {
|
|
mmFindByID.defaultExpectation = &UserRepositoryMockFindByIDExpectation{mock: mmFindByID.mock}
|
|
}
|
|
mmFindByID.defaultExpectation.results = &UserRepositoryMockFindByIDResults{up1, err}
|
|
mmFindByID.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmFindByID.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.FindByID method
|
|
func (mmFindByID *mUserRepositoryMockFindByID) Set(f func(ctx context.Context, userID int) (up1 *model.User, err error)) *UserRepositoryMock {
|
|
if mmFindByID.defaultExpectation != nil {
|
|
mmFindByID.mock.t.Fatalf("Default expectation is already set for the UserRepository.FindByID method")
|
|
}
|
|
|
|
if len(mmFindByID.expectations) > 0 {
|
|
mmFindByID.mock.t.Fatalf("Some expectations are already set for the UserRepository.FindByID method")
|
|
}
|
|
|
|
mmFindByID.mock.funcFindByID = f
|
|
mmFindByID.mock.funcFindByIDOrigin = minimock.CallerInfo(1)
|
|
return mmFindByID.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.FindByID which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmFindByID *mUserRepositoryMockFindByID) When(ctx context.Context, userID int) *UserRepositoryMockFindByIDExpectation {
|
|
if mmFindByID.mock.funcFindByID != nil {
|
|
mmFindByID.mock.t.Fatalf("UserRepositoryMock.FindByID mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockFindByIDExpectation{
|
|
mock: mmFindByID.mock,
|
|
params: &UserRepositoryMockFindByIDParams{ctx, userID},
|
|
expectationOrigins: UserRepositoryMockFindByIDExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmFindByID.expectations = append(mmFindByID.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.FindByID return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockFindByIDExpectation) Then(up1 *model.User, err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockFindByIDResults{up1, err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.FindByID should be invoked
|
|
func (mmFindByID *mUserRepositoryMockFindByID) Times(n uint64) *mUserRepositoryMockFindByID {
|
|
if n == 0 {
|
|
mmFindByID.mock.t.Fatalf("Times of UserRepositoryMock.FindByID mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmFindByID.expectedInvocations, n)
|
|
mmFindByID.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmFindByID
|
|
}
|
|
|
|
func (mmFindByID *mUserRepositoryMockFindByID) invocationsDone() bool {
|
|
if len(mmFindByID.expectations) == 0 && mmFindByID.defaultExpectation == nil && mmFindByID.mock.funcFindByID == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmFindByID.mock.afterFindByIDCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmFindByID.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// FindByID implements mm_repository.UserRepository
|
|
func (mmFindByID *UserRepositoryMock) FindByID(ctx context.Context, userID int) (up1 *model.User, err error) {
|
|
mm_atomic.AddUint64(&mmFindByID.beforeFindByIDCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmFindByID.afterFindByIDCounter, 1)
|
|
|
|
mmFindByID.t.Helper()
|
|
|
|
if mmFindByID.inspectFuncFindByID != nil {
|
|
mmFindByID.inspectFuncFindByID(ctx, userID)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockFindByIDParams{ctx, userID}
|
|
|
|
// Record call args
|
|
mmFindByID.FindByIDMock.mutex.Lock()
|
|
mmFindByID.FindByIDMock.callArgs = append(mmFindByID.FindByIDMock.callArgs, &mm_params)
|
|
mmFindByID.FindByIDMock.mutex.Unlock()
|
|
|
|
for _, e := range mmFindByID.FindByIDMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.up1, e.results.err
|
|
}
|
|
}
|
|
|
|
if mmFindByID.FindByIDMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmFindByID.FindByIDMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmFindByID.FindByIDMock.defaultExpectation.params
|
|
mm_want_ptrs := mmFindByID.FindByIDMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockFindByIDParams{ctx, userID}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmFindByID.t.Errorf("UserRepositoryMock.FindByID got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmFindByID.FindByIDMock.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) {
|
|
mmFindByID.t.Errorf("UserRepositoryMock.FindByID got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmFindByID.FindByIDMock.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) {
|
|
mmFindByID.t.Errorf("UserRepositoryMock.FindByID got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmFindByID.FindByIDMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmFindByID.FindByIDMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmFindByID.t.Fatal("No results are set for the UserRepositoryMock.FindByID")
|
|
}
|
|
return (*mm_results).up1, (*mm_results).err
|
|
}
|
|
if mmFindByID.funcFindByID != nil {
|
|
return mmFindByID.funcFindByID(ctx, userID)
|
|
}
|
|
mmFindByID.t.Fatalf("Unexpected call to UserRepositoryMock.FindByID. %v %v", ctx, userID)
|
|
return
|
|
}
|
|
|
|
// FindByIDAfterCounter returns a count of finished UserRepositoryMock.FindByID invocations
|
|
func (mmFindByID *UserRepositoryMock) FindByIDAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmFindByID.afterFindByIDCounter)
|
|
}
|
|
|
|
// FindByIDBeforeCounter returns a count of UserRepositoryMock.FindByID invocations
|
|
func (mmFindByID *UserRepositoryMock) FindByIDBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmFindByID.beforeFindByIDCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.FindByID.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmFindByID *mUserRepositoryMockFindByID) Calls() []*UserRepositoryMockFindByIDParams {
|
|
mmFindByID.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockFindByIDParams, len(mmFindByID.callArgs))
|
|
copy(argCopy, mmFindByID.callArgs)
|
|
|
|
mmFindByID.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockFindByIDDone returns true if the count of the FindByID invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockFindByIDDone() bool {
|
|
if m.FindByIDMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.FindByIDMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.FindByIDMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockFindByIDInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockFindByIDInspect() {
|
|
for _, e := range m.FindByIDMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterFindByIDCounter := mm_atomic.LoadUint64(&m.afterFindByIDCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.FindByIDMock.defaultExpectation != nil && afterFindByIDCounter < 1 {
|
|
if m.FindByIDMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s", m.FindByIDMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s with params: %#v", m.FindByIDMock.defaultExpectation.expectationOrigins.origin, *m.FindByIDMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcFindByID != nil && afterFindByIDCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.FindByID at\n%s", m.funcFindByIDOrigin)
|
|
}
|
|
|
|
if !m.FindByIDMock.invocationsDone() && afterFindByIDCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.FindByID at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.FindByIDMock.expectedInvocations), m.FindByIDMock.expectedInvocationsOrigin, afterFindByIDCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockGetBalance struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockGetBalanceExpectation
|
|
expectations []*UserRepositoryMockGetBalanceExpectation
|
|
|
|
callArgs []*UserRepositoryMockGetBalanceParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockGetBalanceExpectation specifies expectation struct of the UserRepository.GetBalance
|
|
type UserRepositoryMockGetBalanceExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockGetBalanceParams
|
|
paramPtrs *UserRepositoryMockGetBalanceParamPtrs
|
|
expectationOrigins UserRepositoryMockGetBalanceExpectationOrigins
|
|
results *UserRepositoryMockGetBalanceResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockGetBalanceParams contains parameters of the UserRepository.GetBalance
|
|
type UserRepositoryMockGetBalanceParams struct {
|
|
ctx context.Context
|
|
userID int
|
|
}
|
|
|
|
// UserRepositoryMockGetBalanceParamPtrs contains pointers to parameters of the UserRepository.GetBalance
|
|
type UserRepositoryMockGetBalanceParamPtrs struct {
|
|
ctx *context.Context
|
|
userID *int
|
|
}
|
|
|
|
// UserRepositoryMockGetBalanceResults contains results of the UserRepository.GetBalance
|
|
type UserRepositoryMockGetBalanceResults struct {
|
|
f1 float64
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockGetBalanceOrigins contains origins of expectations of the UserRepository.GetBalance
|
|
type UserRepositoryMockGetBalanceExpectationOrigins 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 (mmGetBalance *mUserRepositoryMockGetBalance) Optional() *mUserRepositoryMockGetBalance {
|
|
mmGetBalance.optional = true
|
|
return mmGetBalance
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.GetBalance
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) Expect(ctx context.Context, userID int) *mUserRepositoryMockGetBalance {
|
|
if mmGetBalance.mock.funcGetBalance != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation == nil {
|
|
mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{}
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation.paramPtrs != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmGetBalance.defaultExpectation.params = &UserRepositoryMockGetBalanceParams{ctx, userID}
|
|
mmGetBalance.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmGetBalance.expectations {
|
|
if minimock.Equal(e.params, mmGetBalance.defaultExpectation.params) {
|
|
mmGetBalance.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetBalance.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmGetBalance
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.GetBalance
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockGetBalance {
|
|
if mmGetBalance.mock.funcGetBalance != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation == nil {
|
|
mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{}
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation.params != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Expect")
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation.paramPtrs == nil {
|
|
mmGetBalance.defaultExpectation.paramPtrs = &UserRepositoryMockGetBalanceParamPtrs{}
|
|
}
|
|
mmGetBalance.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmGetBalance.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmGetBalance
|
|
}
|
|
|
|
// ExpectUserIDParam2 sets up expected param userID for UserRepository.GetBalance
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) ExpectUserIDParam2(userID int) *mUserRepositoryMockGetBalance {
|
|
if mmGetBalance.mock.funcGetBalance != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation == nil {
|
|
mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{}
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation.params != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Expect")
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation.paramPtrs == nil {
|
|
mmGetBalance.defaultExpectation.paramPtrs = &UserRepositoryMockGetBalanceParamPtrs{}
|
|
}
|
|
mmGetBalance.defaultExpectation.paramPtrs.userID = &userID
|
|
mmGetBalance.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmGetBalance
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.GetBalance
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockGetBalance {
|
|
if mmGetBalance.mock.inspectFuncGetBalance != nil {
|
|
mmGetBalance.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.GetBalance")
|
|
}
|
|
|
|
mmGetBalance.mock.inspectFuncGetBalance = f
|
|
|
|
return mmGetBalance
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.GetBalance
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) Return(f1 float64, err error) *UserRepositoryMock {
|
|
if mmGetBalance.mock.funcGetBalance != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmGetBalance.defaultExpectation == nil {
|
|
mmGetBalance.defaultExpectation = &UserRepositoryMockGetBalanceExpectation{mock: mmGetBalance.mock}
|
|
}
|
|
mmGetBalance.defaultExpectation.results = &UserRepositoryMockGetBalanceResults{f1, err}
|
|
mmGetBalance.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmGetBalance.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.GetBalance method
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) Set(f func(ctx context.Context, userID int) (f1 float64, err error)) *UserRepositoryMock {
|
|
if mmGetBalance.defaultExpectation != nil {
|
|
mmGetBalance.mock.t.Fatalf("Default expectation is already set for the UserRepository.GetBalance method")
|
|
}
|
|
|
|
if len(mmGetBalance.expectations) > 0 {
|
|
mmGetBalance.mock.t.Fatalf("Some expectations are already set for the UserRepository.GetBalance method")
|
|
}
|
|
|
|
mmGetBalance.mock.funcGetBalance = f
|
|
mmGetBalance.mock.funcGetBalanceOrigin = minimock.CallerInfo(1)
|
|
return mmGetBalance.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.GetBalance which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) When(ctx context.Context, userID int) *UserRepositoryMockGetBalanceExpectation {
|
|
if mmGetBalance.mock.funcGetBalance != nil {
|
|
mmGetBalance.mock.t.Fatalf("UserRepositoryMock.GetBalance mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockGetBalanceExpectation{
|
|
mock: mmGetBalance.mock,
|
|
params: &UserRepositoryMockGetBalanceParams{ctx, userID},
|
|
expectationOrigins: UserRepositoryMockGetBalanceExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmGetBalance.expectations = append(mmGetBalance.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.GetBalance return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockGetBalanceExpectation) Then(f1 float64, err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockGetBalanceResults{f1, err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.GetBalance should be invoked
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) Times(n uint64) *mUserRepositoryMockGetBalance {
|
|
if n == 0 {
|
|
mmGetBalance.mock.t.Fatalf("Times of UserRepositoryMock.GetBalance mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmGetBalance.expectedInvocations, n)
|
|
mmGetBalance.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmGetBalance
|
|
}
|
|
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) invocationsDone() bool {
|
|
if len(mmGetBalance.expectations) == 0 && mmGetBalance.defaultExpectation == nil && mmGetBalance.mock.funcGetBalance == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmGetBalance.mock.afterGetBalanceCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmGetBalance.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// GetBalance implements mm_repository.UserRepository
|
|
func (mmGetBalance *UserRepositoryMock) GetBalance(ctx context.Context, userID int) (f1 float64, err error) {
|
|
mm_atomic.AddUint64(&mmGetBalance.beforeGetBalanceCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmGetBalance.afterGetBalanceCounter, 1)
|
|
|
|
mmGetBalance.t.Helper()
|
|
|
|
if mmGetBalance.inspectFuncGetBalance != nil {
|
|
mmGetBalance.inspectFuncGetBalance(ctx, userID)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockGetBalanceParams{ctx, userID}
|
|
|
|
// Record call args
|
|
mmGetBalance.GetBalanceMock.mutex.Lock()
|
|
mmGetBalance.GetBalanceMock.callArgs = append(mmGetBalance.GetBalanceMock.callArgs, &mm_params)
|
|
mmGetBalance.GetBalanceMock.mutex.Unlock()
|
|
|
|
for _, e := range mmGetBalance.GetBalanceMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.f1, e.results.err
|
|
}
|
|
}
|
|
|
|
if mmGetBalance.GetBalanceMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmGetBalance.GetBalanceMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmGetBalance.GetBalanceMock.defaultExpectation.params
|
|
mm_want_ptrs := mmGetBalance.GetBalanceMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockGetBalanceParams{ctx, userID}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmGetBalance.t.Errorf("UserRepositoryMock.GetBalance got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmGetBalance.GetBalanceMock.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) {
|
|
mmGetBalance.t.Errorf("UserRepositoryMock.GetBalance got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmGetBalance.GetBalanceMock.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) {
|
|
mmGetBalance.t.Errorf("UserRepositoryMock.GetBalance got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmGetBalance.GetBalanceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmGetBalance.GetBalanceMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmGetBalance.t.Fatal("No results are set for the UserRepositoryMock.GetBalance")
|
|
}
|
|
return (*mm_results).f1, (*mm_results).err
|
|
}
|
|
if mmGetBalance.funcGetBalance != nil {
|
|
return mmGetBalance.funcGetBalance(ctx, userID)
|
|
}
|
|
mmGetBalance.t.Fatalf("Unexpected call to UserRepositoryMock.GetBalance. %v %v", ctx, userID)
|
|
return
|
|
}
|
|
|
|
// GetBalanceAfterCounter returns a count of finished UserRepositoryMock.GetBalance invocations
|
|
func (mmGetBalance *UserRepositoryMock) GetBalanceAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmGetBalance.afterGetBalanceCounter)
|
|
}
|
|
|
|
// GetBalanceBeforeCounter returns a count of UserRepositoryMock.GetBalance invocations
|
|
func (mmGetBalance *UserRepositoryMock) GetBalanceBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmGetBalance.beforeGetBalanceCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.GetBalance.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmGetBalance *mUserRepositoryMockGetBalance) Calls() []*UserRepositoryMockGetBalanceParams {
|
|
mmGetBalance.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockGetBalanceParams, len(mmGetBalance.callArgs))
|
|
copy(argCopy, mmGetBalance.callArgs)
|
|
|
|
mmGetBalance.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockGetBalanceDone returns true if the count of the GetBalance invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockGetBalanceDone() bool {
|
|
if m.GetBalanceMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.GetBalanceMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.GetBalanceMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockGetBalanceInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockGetBalanceInspect() {
|
|
for _, e := range m.GetBalanceMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterGetBalanceCounter := mm_atomic.LoadUint64(&m.afterGetBalanceCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.GetBalanceMock.defaultExpectation != nil && afterGetBalanceCounter < 1 {
|
|
if m.GetBalanceMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s", m.GetBalanceMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s with params: %#v", m.GetBalanceMock.defaultExpectation.expectationOrigins.origin, *m.GetBalanceMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcGetBalance != nil && afterGetBalanceCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.GetBalance at\n%s", m.funcGetBalanceOrigin)
|
|
}
|
|
|
|
if !m.GetBalanceMock.invocationsDone() && afterGetBalanceCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.GetBalance at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.GetBalanceMock.expectedInvocations), m.GetBalanceMock.expectedInvocationsOrigin, afterGetBalanceCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockIncrementInvitesIssued struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockIncrementInvitesIssuedExpectation
|
|
expectations []*UserRepositoryMockIncrementInvitesIssuedExpectation
|
|
|
|
callArgs []*UserRepositoryMockIncrementInvitesIssuedParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedExpectation specifies expectation struct of the UserRepository.IncrementInvitesIssued
|
|
type UserRepositoryMockIncrementInvitesIssuedExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockIncrementInvitesIssuedParams
|
|
paramPtrs *UserRepositoryMockIncrementInvitesIssuedParamPtrs
|
|
expectationOrigins UserRepositoryMockIncrementInvitesIssuedExpectationOrigins
|
|
results *UserRepositoryMockIncrementInvitesIssuedResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedParams contains parameters of the UserRepository.IncrementInvitesIssued
|
|
type UserRepositoryMockIncrementInvitesIssuedParams struct {
|
|
ctx context.Context
|
|
userID int
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedParamPtrs contains pointers to parameters of the UserRepository.IncrementInvitesIssued
|
|
type UserRepositoryMockIncrementInvitesIssuedParamPtrs struct {
|
|
ctx *context.Context
|
|
userID *int
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedResults contains results of the UserRepository.IncrementInvitesIssued
|
|
type UserRepositoryMockIncrementInvitesIssuedResults struct {
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedOrigins contains origins of expectations of the UserRepository.IncrementInvitesIssued
|
|
type UserRepositoryMockIncrementInvitesIssuedExpectationOrigins 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 (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Optional() *mUserRepositoryMockIncrementInvitesIssued {
|
|
mmIncrementInvitesIssued.optional = true
|
|
return mmIncrementInvitesIssued
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.IncrementInvitesIssued
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Expect(ctx context.Context, userID int) *mUserRepositoryMockIncrementInvitesIssued {
|
|
if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation == nil {
|
|
mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation.paramPtrs != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmIncrementInvitesIssued.defaultExpectation.params = &UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID}
|
|
mmIncrementInvitesIssued.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmIncrementInvitesIssued.expectations {
|
|
if minimock.Equal(e.params, mmIncrementInvitesIssued.defaultExpectation.params) {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmIncrementInvitesIssued.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmIncrementInvitesIssued
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.IncrementInvitesIssued
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockIncrementInvitesIssued {
|
|
if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation == nil {
|
|
mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation.params != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Expect")
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation.paramPtrs == nil {
|
|
mmIncrementInvitesIssued.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedParamPtrs{}
|
|
}
|
|
mmIncrementInvitesIssued.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmIncrementInvitesIssued.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmIncrementInvitesIssued
|
|
}
|
|
|
|
// ExpectUserIDParam2 sets up expected param userID for UserRepository.IncrementInvitesIssued
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) ExpectUserIDParam2(userID int) *mUserRepositoryMockIncrementInvitesIssued {
|
|
if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation == nil {
|
|
mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation.params != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Expect")
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation.paramPtrs == nil {
|
|
mmIncrementInvitesIssued.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedParamPtrs{}
|
|
}
|
|
mmIncrementInvitesIssued.defaultExpectation.paramPtrs.userID = &userID
|
|
mmIncrementInvitesIssued.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmIncrementInvitesIssued
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.IncrementInvitesIssued
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Inspect(f func(ctx context.Context, userID int)) *mUserRepositoryMockIncrementInvitesIssued {
|
|
if mmIncrementInvitesIssued.mock.inspectFuncIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.IncrementInvitesIssued")
|
|
}
|
|
|
|
mmIncrementInvitesIssued.mock.inspectFuncIncrementInvitesIssued = f
|
|
|
|
return mmIncrementInvitesIssued
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.IncrementInvitesIssued
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Return(err error) *UserRepositoryMock {
|
|
if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.defaultExpectation == nil {
|
|
mmIncrementInvitesIssued.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedExpectation{mock: mmIncrementInvitesIssued.mock}
|
|
}
|
|
mmIncrementInvitesIssued.defaultExpectation.results = &UserRepositoryMockIncrementInvitesIssuedResults{err}
|
|
mmIncrementInvitesIssued.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmIncrementInvitesIssued.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.IncrementInvitesIssued method
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Set(f func(ctx context.Context, userID int) (err error)) *UserRepositoryMock {
|
|
if mmIncrementInvitesIssued.defaultExpectation != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("Default expectation is already set for the UserRepository.IncrementInvitesIssued method")
|
|
}
|
|
|
|
if len(mmIncrementInvitesIssued.expectations) > 0 {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("Some expectations are already set for the UserRepository.IncrementInvitesIssued method")
|
|
}
|
|
|
|
mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued = f
|
|
mmIncrementInvitesIssued.mock.funcIncrementInvitesIssuedOrigin = minimock.CallerInfo(1)
|
|
return mmIncrementInvitesIssued.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.IncrementInvitesIssued which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) When(ctx context.Context, userID int) *UserRepositoryMockIncrementInvitesIssuedExpectation {
|
|
if mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssued mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockIncrementInvitesIssuedExpectation{
|
|
mock: mmIncrementInvitesIssued.mock,
|
|
params: &UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID},
|
|
expectationOrigins: UserRepositoryMockIncrementInvitesIssuedExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmIncrementInvitesIssued.expectations = append(mmIncrementInvitesIssued.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.IncrementInvitesIssued return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockIncrementInvitesIssuedExpectation) Then(err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockIncrementInvitesIssuedResults{err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.IncrementInvitesIssued should be invoked
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Times(n uint64) *mUserRepositoryMockIncrementInvitesIssued {
|
|
if n == 0 {
|
|
mmIncrementInvitesIssued.mock.t.Fatalf("Times of UserRepositoryMock.IncrementInvitesIssued mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmIncrementInvitesIssued.expectedInvocations, n)
|
|
mmIncrementInvitesIssued.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmIncrementInvitesIssued
|
|
}
|
|
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) invocationsDone() bool {
|
|
if len(mmIncrementInvitesIssued.expectations) == 0 && mmIncrementInvitesIssued.defaultExpectation == nil && mmIncrementInvitesIssued.mock.funcIncrementInvitesIssued == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssued.mock.afterIncrementInvitesIssuedCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssued.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// IncrementInvitesIssued implements mm_repository.UserRepository
|
|
func (mmIncrementInvitesIssued *UserRepositoryMock) IncrementInvitesIssued(ctx context.Context, userID int) (err error) {
|
|
mm_atomic.AddUint64(&mmIncrementInvitesIssued.beforeIncrementInvitesIssuedCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmIncrementInvitesIssued.afterIncrementInvitesIssuedCounter, 1)
|
|
|
|
mmIncrementInvitesIssued.t.Helper()
|
|
|
|
if mmIncrementInvitesIssued.inspectFuncIncrementInvitesIssued != nil {
|
|
mmIncrementInvitesIssued.inspectFuncIncrementInvitesIssued(ctx, userID)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID}
|
|
|
|
// Record call args
|
|
mmIncrementInvitesIssued.IncrementInvitesIssuedMock.mutex.Lock()
|
|
mmIncrementInvitesIssued.IncrementInvitesIssuedMock.callArgs = append(mmIncrementInvitesIssued.IncrementInvitesIssuedMock.callArgs, &mm_params)
|
|
mmIncrementInvitesIssued.IncrementInvitesIssuedMock.mutex.Unlock()
|
|
|
|
for _, e := range mmIncrementInvitesIssued.IncrementInvitesIssuedMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.err
|
|
}
|
|
}
|
|
|
|
if mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.params
|
|
mm_want_ptrs := mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockIncrementInvitesIssuedParams{ctx, userID}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmIncrementInvitesIssued.t.Errorf("UserRepositoryMock.IncrementInvitesIssued got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssued.IncrementInvitesIssuedMock.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) {
|
|
mmIncrementInvitesIssued.t.Errorf("UserRepositoryMock.IncrementInvitesIssued got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssued.IncrementInvitesIssuedMock.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) {
|
|
mmIncrementInvitesIssued.t.Errorf("UserRepositoryMock.IncrementInvitesIssued got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmIncrementInvitesIssued.IncrementInvitesIssuedMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmIncrementInvitesIssued.t.Fatal("No results are set for the UserRepositoryMock.IncrementInvitesIssued")
|
|
}
|
|
return (*mm_results).err
|
|
}
|
|
if mmIncrementInvitesIssued.funcIncrementInvitesIssued != nil {
|
|
return mmIncrementInvitesIssued.funcIncrementInvitesIssued(ctx, userID)
|
|
}
|
|
mmIncrementInvitesIssued.t.Fatalf("Unexpected call to UserRepositoryMock.IncrementInvitesIssued. %v %v", ctx, userID)
|
|
return
|
|
}
|
|
|
|
// IncrementInvitesIssuedAfterCounter returns a count of finished UserRepositoryMock.IncrementInvitesIssued invocations
|
|
func (mmIncrementInvitesIssued *UserRepositoryMock) IncrementInvitesIssuedAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmIncrementInvitesIssued.afterIncrementInvitesIssuedCounter)
|
|
}
|
|
|
|
// IncrementInvitesIssuedBeforeCounter returns a count of UserRepositoryMock.IncrementInvitesIssued invocations
|
|
func (mmIncrementInvitesIssued *UserRepositoryMock) IncrementInvitesIssuedBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmIncrementInvitesIssued.beforeIncrementInvitesIssuedCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.IncrementInvitesIssued.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmIncrementInvitesIssued *mUserRepositoryMockIncrementInvitesIssued) Calls() []*UserRepositoryMockIncrementInvitesIssuedParams {
|
|
mmIncrementInvitesIssued.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockIncrementInvitesIssuedParams, len(mmIncrementInvitesIssued.callArgs))
|
|
copy(argCopy, mmIncrementInvitesIssued.callArgs)
|
|
|
|
mmIncrementInvitesIssued.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockIncrementInvitesIssuedDone returns true if the count of the IncrementInvitesIssued invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedDone() bool {
|
|
if m.IncrementInvitesIssuedMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.IncrementInvitesIssuedMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.IncrementInvitesIssuedMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockIncrementInvitesIssuedInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedInspect() {
|
|
for _, e := range m.IncrementInvitesIssuedMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterIncrementInvitesIssuedCounter := mm_atomic.LoadUint64(&m.afterIncrementInvitesIssuedCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.IncrementInvitesIssuedMock.defaultExpectation != nil && afterIncrementInvitesIssuedCounter < 1 {
|
|
if m.IncrementInvitesIssuedMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s", m.IncrementInvitesIssuedMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s with params: %#v", m.IncrementInvitesIssuedMock.defaultExpectation.expectationOrigins.origin, *m.IncrementInvitesIssuedMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcIncrementInvitesIssued != nil && afterIncrementInvitesIssuedCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssued at\n%s", m.funcIncrementInvitesIssuedOrigin)
|
|
}
|
|
|
|
if !m.IncrementInvitesIssuedMock.invocationsDone() && afterIncrementInvitesIssuedCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.IncrementInvitesIssued at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.IncrementInvitesIssuedMock.expectedInvocations), m.IncrementInvitesIssuedMock.expectedInvocationsOrigin, afterIncrementInvitesIssuedCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockIncrementInvitesIssuedTx struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockIncrementInvitesIssuedTxExpectation
|
|
expectations []*UserRepositoryMockIncrementInvitesIssuedTxExpectation
|
|
|
|
callArgs []*UserRepositoryMockIncrementInvitesIssuedTxParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedTxExpectation specifies expectation struct of the UserRepository.IncrementInvitesIssuedTx
|
|
type UserRepositoryMockIncrementInvitesIssuedTxExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockIncrementInvitesIssuedTxParams
|
|
paramPtrs *UserRepositoryMockIncrementInvitesIssuedTxParamPtrs
|
|
expectationOrigins UserRepositoryMockIncrementInvitesIssuedTxExpectationOrigins
|
|
results *UserRepositoryMockIncrementInvitesIssuedTxResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedTxParams contains parameters of the UserRepository.IncrementInvitesIssuedTx
|
|
type UserRepositoryMockIncrementInvitesIssuedTxParams struct {
|
|
ctx context.Context
|
|
tx pgx.Tx
|
|
userID int
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedTxParamPtrs contains pointers to parameters of the UserRepository.IncrementInvitesIssuedTx
|
|
type UserRepositoryMockIncrementInvitesIssuedTxParamPtrs struct {
|
|
ctx *context.Context
|
|
tx *pgx.Tx
|
|
userID *int
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedTxResults contains results of the UserRepository.IncrementInvitesIssuedTx
|
|
type UserRepositoryMockIncrementInvitesIssuedTxResults struct {
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockIncrementInvitesIssuedTxOrigins contains origins of expectations of the UserRepository.IncrementInvitesIssuedTx
|
|
type UserRepositoryMockIncrementInvitesIssuedTxExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originTx 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 (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Optional() *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
mmIncrementInvitesIssuedTx.optional = true
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.IncrementInvitesIssuedTx
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Expect(ctx context.Context, tx pgx.Tx, userID int) *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.params = &UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID}
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmIncrementInvitesIssuedTx.expectations {
|
|
if minimock.Equal(e.params, mmIncrementInvitesIssuedTx.defaultExpectation.params) {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmIncrementInvitesIssuedTx.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.IncrementInvitesIssuedTx
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.params != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedTxParamPtrs{}
|
|
}
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
// ExpectTxParam2 sets up expected param tx for UserRepository.IncrementInvitesIssuedTx
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.params != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedTxParamPtrs{}
|
|
}
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs.tx = &tx
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)
|
|
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
// ExpectUserIDParam3 sets up expected param userID for UserRepository.IncrementInvitesIssuedTx
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) ExpectUserIDParam3(userID int) *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{}
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.params != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs = &UserRepositoryMockIncrementInvitesIssuedTxParamPtrs{}
|
|
}
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.paramPtrs.userID = &userID
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.IncrementInvitesIssuedTx
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Inspect(f func(ctx context.Context, tx pgx.Tx, userID int)) *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
if mmIncrementInvitesIssuedTx.mock.inspectFuncIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.IncrementInvitesIssuedTx")
|
|
}
|
|
|
|
mmIncrementInvitesIssuedTx.mock.inspectFuncIncrementInvitesIssuedTx = f
|
|
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.IncrementInvitesIssuedTx
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Return(err error) *UserRepositoryMock {
|
|
if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation == nil {
|
|
mmIncrementInvitesIssuedTx.defaultExpectation = &UserRepositoryMockIncrementInvitesIssuedTxExpectation{mock: mmIncrementInvitesIssuedTx.mock}
|
|
}
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.results = &UserRepositoryMockIncrementInvitesIssuedTxResults{err}
|
|
mmIncrementInvitesIssuedTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmIncrementInvitesIssuedTx.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.IncrementInvitesIssuedTx method
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Set(f func(ctx context.Context, tx pgx.Tx, userID int) (err error)) *UserRepositoryMock {
|
|
if mmIncrementInvitesIssuedTx.defaultExpectation != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.IncrementInvitesIssuedTx method")
|
|
}
|
|
|
|
if len(mmIncrementInvitesIssuedTx.expectations) > 0 {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.IncrementInvitesIssuedTx method")
|
|
}
|
|
|
|
mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx = f
|
|
mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTxOrigin = minimock.CallerInfo(1)
|
|
return mmIncrementInvitesIssuedTx.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.IncrementInvitesIssuedTx which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) When(ctx context.Context, tx pgx.Tx, userID int) *UserRepositoryMockIncrementInvitesIssuedTxExpectation {
|
|
if mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("UserRepositoryMock.IncrementInvitesIssuedTx mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockIncrementInvitesIssuedTxExpectation{
|
|
mock: mmIncrementInvitesIssuedTx.mock,
|
|
params: &UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID},
|
|
expectationOrigins: UserRepositoryMockIncrementInvitesIssuedTxExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmIncrementInvitesIssuedTx.expectations = append(mmIncrementInvitesIssuedTx.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.IncrementInvitesIssuedTx return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockIncrementInvitesIssuedTxExpectation) Then(err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockIncrementInvitesIssuedTxResults{err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.IncrementInvitesIssuedTx should be invoked
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Times(n uint64) *mUserRepositoryMockIncrementInvitesIssuedTx {
|
|
if n == 0 {
|
|
mmIncrementInvitesIssuedTx.mock.t.Fatalf("Times of UserRepositoryMock.IncrementInvitesIssuedTx mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmIncrementInvitesIssuedTx.expectedInvocations, n)
|
|
mmIncrementInvitesIssuedTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmIncrementInvitesIssuedTx
|
|
}
|
|
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) invocationsDone() bool {
|
|
if len(mmIncrementInvitesIssuedTx.expectations) == 0 && mmIncrementInvitesIssuedTx.defaultExpectation == nil && mmIncrementInvitesIssuedTx.mock.funcIncrementInvitesIssuedTx == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.mock.afterIncrementInvitesIssuedTxCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// IncrementInvitesIssuedTx implements mm_repository.UserRepository
|
|
func (mmIncrementInvitesIssuedTx *UserRepositoryMock) IncrementInvitesIssuedTx(ctx context.Context, tx pgx.Tx, userID int) (err error) {
|
|
mm_atomic.AddUint64(&mmIncrementInvitesIssuedTx.beforeIncrementInvitesIssuedTxCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmIncrementInvitesIssuedTx.afterIncrementInvitesIssuedTxCounter, 1)
|
|
|
|
mmIncrementInvitesIssuedTx.t.Helper()
|
|
|
|
if mmIncrementInvitesIssuedTx.inspectFuncIncrementInvitesIssuedTx != nil {
|
|
mmIncrementInvitesIssuedTx.inspectFuncIncrementInvitesIssuedTx(ctx, tx, userID)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID}
|
|
|
|
// Record call args
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.mutex.Lock()
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.callArgs = append(mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.callArgs, &mm_params)
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.mutex.Unlock()
|
|
|
|
for _, e := range mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.err
|
|
}
|
|
}
|
|
|
|
if mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.params
|
|
mm_want_ptrs := mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockIncrementInvitesIssuedTxParams{ctx, tx, userID}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
|
|
}
|
|
|
|
if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
|
|
mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
|
|
}
|
|
|
|
if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
|
|
mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.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) {
|
|
mmIncrementInvitesIssuedTx.t.Errorf("UserRepositoryMock.IncrementInvitesIssuedTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmIncrementInvitesIssuedTx.IncrementInvitesIssuedTxMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmIncrementInvitesIssuedTx.t.Fatal("No results are set for the UserRepositoryMock.IncrementInvitesIssuedTx")
|
|
}
|
|
return (*mm_results).err
|
|
}
|
|
if mmIncrementInvitesIssuedTx.funcIncrementInvitesIssuedTx != nil {
|
|
return mmIncrementInvitesIssuedTx.funcIncrementInvitesIssuedTx(ctx, tx, userID)
|
|
}
|
|
mmIncrementInvitesIssuedTx.t.Fatalf("Unexpected call to UserRepositoryMock.IncrementInvitesIssuedTx. %v %v %v", ctx, tx, userID)
|
|
return
|
|
}
|
|
|
|
// IncrementInvitesIssuedTxAfterCounter returns a count of finished UserRepositoryMock.IncrementInvitesIssuedTx invocations
|
|
func (mmIncrementInvitesIssuedTx *UserRepositoryMock) IncrementInvitesIssuedTxAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.afterIncrementInvitesIssuedTxCounter)
|
|
}
|
|
|
|
// IncrementInvitesIssuedTxBeforeCounter returns a count of UserRepositoryMock.IncrementInvitesIssuedTx invocations
|
|
func (mmIncrementInvitesIssuedTx *UserRepositoryMock) IncrementInvitesIssuedTxBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmIncrementInvitesIssuedTx.beforeIncrementInvitesIssuedTxCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.IncrementInvitesIssuedTx.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmIncrementInvitesIssuedTx *mUserRepositoryMockIncrementInvitesIssuedTx) Calls() []*UserRepositoryMockIncrementInvitesIssuedTxParams {
|
|
mmIncrementInvitesIssuedTx.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockIncrementInvitesIssuedTxParams, len(mmIncrementInvitesIssuedTx.callArgs))
|
|
copy(argCopy, mmIncrementInvitesIssuedTx.callArgs)
|
|
|
|
mmIncrementInvitesIssuedTx.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockIncrementInvitesIssuedTxDone returns true if the count of the IncrementInvitesIssuedTx invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedTxDone() bool {
|
|
if m.IncrementInvitesIssuedTxMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.IncrementInvitesIssuedTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.IncrementInvitesIssuedTxMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockIncrementInvitesIssuedTxInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockIncrementInvitesIssuedTxInspect() {
|
|
for _, e := range m.IncrementInvitesIssuedTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterIncrementInvitesIssuedTxCounter := mm_atomic.LoadUint64(&m.afterIncrementInvitesIssuedTxCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.IncrementInvitesIssuedTxMock.defaultExpectation != nil && afterIncrementInvitesIssuedTxCounter < 1 {
|
|
if m.IncrementInvitesIssuedTxMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s", m.IncrementInvitesIssuedTxMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s with params: %#v", m.IncrementInvitesIssuedTxMock.defaultExpectation.expectationOrigins.origin, *m.IncrementInvitesIssuedTxMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcIncrementInvitesIssuedTx != nil && afterIncrementInvitesIssuedTxCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s", m.funcIncrementInvitesIssuedTxOrigin)
|
|
}
|
|
|
|
if !m.IncrementInvitesIssuedTxMock.invocationsDone() && afterIncrementInvitesIssuedTxCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.IncrementInvitesIssuedTx at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.IncrementInvitesIssuedTxMock.expectedInvocations), m.IncrementInvitesIssuedTxMock.expectedInvocationsOrigin, afterIncrementInvitesIssuedTxCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockUpdateBalance struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockUpdateBalanceExpectation
|
|
expectations []*UserRepositoryMockUpdateBalanceExpectation
|
|
|
|
callArgs []*UserRepositoryMockUpdateBalanceParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceExpectation specifies expectation struct of the UserRepository.UpdateBalance
|
|
type UserRepositoryMockUpdateBalanceExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockUpdateBalanceParams
|
|
paramPtrs *UserRepositoryMockUpdateBalanceParamPtrs
|
|
expectationOrigins UserRepositoryMockUpdateBalanceExpectationOrigins
|
|
results *UserRepositoryMockUpdateBalanceResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceParams contains parameters of the UserRepository.UpdateBalance
|
|
type UserRepositoryMockUpdateBalanceParams struct {
|
|
ctx context.Context
|
|
userID int
|
|
delta float64
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceParamPtrs contains pointers to parameters of the UserRepository.UpdateBalance
|
|
type UserRepositoryMockUpdateBalanceParamPtrs struct {
|
|
ctx *context.Context
|
|
userID *int
|
|
delta *float64
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceResults contains results of the UserRepository.UpdateBalance
|
|
type UserRepositoryMockUpdateBalanceResults struct {
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceOrigins contains origins of expectations of the UserRepository.UpdateBalance
|
|
type UserRepositoryMockUpdateBalanceExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originUserID string
|
|
originDelta 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 (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Optional() *mUserRepositoryMockUpdateBalance {
|
|
mmUpdateBalance.optional = true
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.UpdateBalance
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Expect(ctx context.Context, userID int, delta float64) *mUserRepositoryMockUpdateBalance {
|
|
if mmUpdateBalance.mock.funcUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation == nil {
|
|
mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.paramPtrs != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmUpdateBalance.defaultExpectation.params = &UserRepositoryMockUpdateBalanceParams{ctx, userID, delta}
|
|
mmUpdateBalance.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmUpdateBalance.expectations {
|
|
if minimock.Equal(e.params, mmUpdateBalance.defaultExpectation.params) {
|
|
mmUpdateBalance.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateBalance.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.UpdateBalance
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockUpdateBalance {
|
|
if mmUpdateBalance.mock.funcUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation == nil {
|
|
mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.params != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalance.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceParamPtrs{}
|
|
}
|
|
mmUpdateBalance.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmUpdateBalance.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
// ExpectUserIDParam2 sets up expected param userID for UserRepository.UpdateBalance
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) ExpectUserIDParam2(userID int) *mUserRepositoryMockUpdateBalance {
|
|
if mmUpdateBalance.mock.funcUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation == nil {
|
|
mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.params != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalance.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceParamPtrs{}
|
|
}
|
|
mmUpdateBalance.defaultExpectation.paramPtrs.userID = &userID
|
|
mmUpdateBalance.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
// ExpectDeltaParam3 sets up expected param delta for UserRepository.UpdateBalance
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) ExpectDeltaParam3(delta float64) *mUserRepositoryMockUpdateBalance {
|
|
if mmUpdateBalance.mock.funcUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation == nil {
|
|
mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.params != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalance.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceParamPtrs{}
|
|
}
|
|
mmUpdateBalance.defaultExpectation.paramPtrs.delta = &delta
|
|
mmUpdateBalance.defaultExpectation.expectationOrigins.originDelta = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.UpdateBalance
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Inspect(f func(ctx context.Context, userID int, delta float64)) *mUserRepositoryMockUpdateBalance {
|
|
if mmUpdateBalance.mock.inspectFuncUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.UpdateBalance")
|
|
}
|
|
|
|
mmUpdateBalance.mock.inspectFuncUpdateBalance = f
|
|
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.UpdateBalance
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Return(err error) *UserRepositoryMock {
|
|
if mmUpdateBalance.mock.funcUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalance.defaultExpectation == nil {
|
|
mmUpdateBalance.defaultExpectation = &UserRepositoryMockUpdateBalanceExpectation{mock: mmUpdateBalance.mock}
|
|
}
|
|
mmUpdateBalance.defaultExpectation.results = &UserRepositoryMockUpdateBalanceResults{err}
|
|
mmUpdateBalance.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmUpdateBalance.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.UpdateBalance method
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Set(f func(ctx context.Context, userID int, delta float64) (err error)) *UserRepositoryMock {
|
|
if mmUpdateBalance.defaultExpectation != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("Default expectation is already set for the UserRepository.UpdateBalance method")
|
|
}
|
|
|
|
if len(mmUpdateBalance.expectations) > 0 {
|
|
mmUpdateBalance.mock.t.Fatalf("Some expectations are already set for the UserRepository.UpdateBalance method")
|
|
}
|
|
|
|
mmUpdateBalance.mock.funcUpdateBalance = f
|
|
mmUpdateBalance.mock.funcUpdateBalanceOrigin = minimock.CallerInfo(1)
|
|
return mmUpdateBalance.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.UpdateBalance which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) When(ctx context.Context, userID int, delta float64) *UserRepositoryMockUpdateBalanceExpectation {
|
|
if mmUpdateBalance.mock.funcUpdateBalance != nil {
|
|
mmUpdateBalance.mock.t.Fatalf("UserRepositoryMock.UpdateBalance mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockUpdateBalanceExpectation{
|
|
mock: mmUpdateBalance.mock,
|
|
params: &UserRepositoryMockUpdateBalanceParams{ctx, userID, delta},
|
|
expectationOrigins: UserRepositoryMockUpdateBalanceExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmUpdateBalance.expectations = append(mmUpdateBalance.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.UpdateBalance return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockUpdateBalanceExpectation) Then(err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockUpdateBalanceResults{err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.UpdateBalance should be invoked
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Times(n uint64) *mUserRepositoryMockUpdateBalance {
|
|
if n == 0 {
|
|
mmUpdateBalance.mock.t.Fatalf("Times of UserRepositoryMock.UpdateBalance mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmUpdateBalance.expectedInvocations, n)
|
|
mmUpdateBalance.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmUpdateBalance
|
|
}
|
|
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) invocationsDone() bool {
|
|
if len(mmUpdateBalance.expectations) == 0 && mmUpdateBalance.defaultExpectation == nil && mmUpdateBalance.mock.funcUpdateBalance == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmUpdateBalance.mock.afterUpdateBalanceCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmUpdateBalance.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// UpdateBalance implements mm_repository.UserRepository
|
|
func (mmUpdateBalance *UserRepositoryMock) UpdateBalance(ctx context.Context, userID int, delta float64) (err error) {
|
|
mm_atomic.AddUint64(&mmUpdateBalance.beforeUpdateBalanceCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmUpdateBalance.afterUpdateBalanceCounter, 1)
|
|
|
|
mmUpdateBalance.t.Helper()
|
|
|
|
if mmUpdateBalance.inspectFuncUpdateBalance != nil {
|
|
mmUpdateBalance.inspectFuncUpdateBalance(ctx, userID, delta)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockUpdateBalanceParams{ctx, userID, delta}
|
|
|
|
// Record call args
|
|
mmUpdateBalance.UpdateBalanceMock.mutex.Lock()
|
|
mmUpdateBalance.UpdateBalanceMock.callArgs = append(mmUpdateBalance.UpdateBalanceMock.callArgs, &mm_params)
|
|
mmUpdateBalance.UpdateBalanceMock.mutex.Unlock()
|
|
|
|
for _, e := range mmUpdateBalance.UpdateBalanceMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.err
|
|
}
|
|
}
|
|
|
|
if mmUpdateBalance.UpdateBalanceMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmUpdateBalance.UpdateBalanceMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmUpdateBalance.UpdateBalanceMock.defaultExpectation.params
|
|
mm_want_ptrs := mmUpdateBalance.UpdateBalanceMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockUpdateBalanceParams{ctx, userID, delta}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalance.UpdateBalanceMock.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) {
|
|
mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
|
|
}
|
|
|
|
if mm_want_ptrs.delta != nil && !minimock.Equal(*mm_want_ptrs.delta, mm_got.delta) {
|
|
mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameter delta, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.originDelta, *mm_want_ptrs.delta, mm_got.delta, minimock.Diff(*mm_want_ptrs.delta, mm_got.delta))
|
|
}
|
|
|
|
} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
|
|
mmUpdateBalance.t.Errorf("UserRepositoryMock.UpdateBalance got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalance.UpdateBalanceMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmUpdateBalance.UpdateBalanceMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmUpdateBalance.t.Fatal("No results are set for the UserRepositoryMock.UpdateBalance")
|
|
}
|
|
return (*mm_results).err
|
|
}
|
|
if mmUpdateBalance.funcUpdateBalance != nil {
|
|
return mmUpdateBalance.funcUpdateBalance(ctx, userID, delta)
|
|
}
|
|
mmUpdateBalance.t.Fatalf("Unexpected call to UserRepositoryMock.UpdateBalance. %v %v %v", ctx, userID, delta)
|
|
return
|
|
}
|
|
|
|
// UpdateBalanceAfterCounter returns a count of finished UserRepositoryMock.UpdateBalance invocations
|
|
func (mmUpdateBalance *UserRepositoryMock) UpdateBalanceAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmUpdateBalance.afterUpdateBalanceCounter)
|
|
}
|
|
|
|
// UpdateBalanceBeforeCounter returns a count of UserRepositoryMock.UpdateBalance invocations
|
|
func (mmUpdateBalance *UserRepositoryMock) UpdateBalanceBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmUpdateBalance.beforeUpdateBalanceCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.UpdateBalance.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmUpdateBalance *mUserRepositoryMockUpdateBalance) Calls() []*UserRepositoryMockUpdateBalanceParams {
|
|
mmUpdateBalance.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockUpdateBalanceParams, len(mmUpdateBalance.callArgs))
|
|
copy(argCopy, mmUpdateBalance.callArgs)
|
|
|
|
mmUpdateBalance.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockUpdateBalanceDone returns true if the count of the UpdateBalance invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockUpdateBalanceDone() bool {
|
|
if m.UpdateBalanceMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.UpdateBalanceMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.UpdateBalanceMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockUpdateBalanceInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockUpdateBalanceInspect() {
|
|
for _, e := range m.UpdateBalanceMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterUpdateBalanceCounter := mm_atomic.LoadUint64(&m.afterUpdateBalanceCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.UpdateBalanceMock.defaultExpectation != nil && afterUpdateBalanceCounter < 1 {
|
|
if m.UpdateBalanceMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s", m.UpdateBalanceMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s with params: %#v", m.UpdateBalanceMock.defaultExpectation.expectationOrigins.origin, *m.UpdateBalanceMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcUpdateBalance != nil && afterUpdateBalanceCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalance at\n%s", m.funcUpdateBalanceOrigin)
|
|
}
|
|
|
|
if !m.UpdateBalanceMock.invocationsDone() && afterUpdateBalanceCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.UpdateBalance at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.UpdateBalanceMock.expectedInvocations), m.UpdateBalanceMock.expectedInvocationsOrigin, afterUpdateBalanceCounter)
|
|
}
|
|
}
|
|
|
|
type mUserRepositoryMockUpdateBalanceTx struct {
|
|
optional bool
|
|
mock *UserRepositoryMock
|
|
defaultExpectation *UserRepositoryMockUpdateBalanceTxExpectation
|
|
expectations []*UserRepositoryMockUpdateBalanceTxExpectation
|
|
|
|
callArgs []*UserRepositoryMockUpdateBalanceTxParams
|
|
mutex sync.RWMutex
|
|
|
|
expectedInvocations uint64
|
|
expectedInvocationsOrigin string
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceTxExpectation specifies expectation struct of the UserRepository.UpdateBalanceTx
|
|
type UserRepositoryMockUpdateBalanceTxExpectation struct {
|
|
mock *UserRepositoryMock
|
|
params *UserRepositoryMockUpdateBalanceTxParams
|
|
paramPtrs *UserRepositoryMockUpdateBalanceTxParamPtrs
|
|
expectationOrigins UserRepositoryMockUpdateBalanceTxExpectationOrigins
|
|
results *UserRepositoryMockUpdateBalanceTxResults
|
|
returnOrigin string
|
|
Counter uint64
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceTxParams contains parameters of the UserRepository.UpdateBalanceTx
|
|
type UserRepositoryMockUpdateBalanceTxParams struct {
|
|
ctx context.Context
|
|
tx pgx.Tx
|
|
userID int
|
|
delta float64
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceTxParamPtrs contains pointers to parameters of the UserRepository.UpdateBalanceTx
|
|
type UserRepositoryMockUpdateBalanceTxParamPtrs struct {
|
|
ctx *context.Context
|
|
tx *pgx.Tx
|
|
userID *int
|
|
delta *float64
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceTxResults contains results of the UserRepository.UpdateBalanceTx
|
|
type UserRepositoryMockUpdateBalanceTxResults struct {
|
|
err error
|
|
}
|
|
|
|
// UserRepositoryMockUpdateBalanceTxOrigins contains origins of expectations of the UserRepository.UpdateBalanceTx
|
|
type UserRepositoryMockUpdateBalanceTxExpectationOrigins struct {
|
|
origin string
|
|
originCtx string
|
|
originTx string
|
|
originUserID string
|
|
originDelta 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 (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Optional() *mUserRepositoryMockUpdateBalanceTx {
|
|
mmUpdateBalanceTx.optional = true
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// Expect sets up expected params for UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Expect(ctx context.Context, tx pgx.Tx, userID int, delta float64) *mUserRepositoryMockUpdateBalanceTx {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation == nil {
|
|
mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.paramPtrs != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by ExpectParams functions")
|
|
}
|
|
|
|
mmUpdateBalanceTx.defaultExpectation.params = &UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta}
|
|
mmUpdateBalanceTx.defaultExpectation.expectationOrigins.origin = minimock.CallerInfo(1)
|
|
for _, e := range mmUpdateBalanceTx.expectations {
|
|
if minimock.Equal(e.params, mmUpdateBalanceTx.defaultExpectation.params) {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdateBalanceTx.defaultExpectation.params)
|
|
}
|
|
}
|
|
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// ExpectCtxParam1 sets up expected param ctx for UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectCtxParam1(ctx context.Context) *mUserRepositoryMockUpdateBalanceTx {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation == nil {
|
|
mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.params != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
|
|
}
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs.ctx = &ctx
|
|
mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originCtx = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// ExpectTxParam2 sets up expected param tx for UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectTxParam2(tx pgx.Tx) *mUserRepositoryMockUpdateBalanceTx {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation == nil {
|
|
mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.params != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
|
|
}
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs.tx = &tx
|
|
mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originTx = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// ExpectUserIDParam3 sets up expected param userID for UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectUserIDParam3(userID int) *mUserRepositoryMockUpdateBalanceTx {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation == nil {
|
|
mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.params != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
|
|
}
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs.userID = &userID
|
|
mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originUserID = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// ExpectDeltaParam4 sets up expected param delta for UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) ExpectDeltaParam4(delta float64) *mUserRepositoryMockUpdateBalanceTx {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation == nil {
|
|
mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{}
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.params != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Expect")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation.paramPtrs == nil {
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs = &UserRepositoryMockUpdateBalanceTxParamPtrs{}
|
|
}
|
|
mmUpdateBalanceTx.defaultExpectation.paramPtrs.delta = &delta
|
|
mmUpdateBalanceTx.defaultExpectation.expectationOrigins.originDelta = minimock.CallerInfo(1)
|
|
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// Inspect accepts an inspector function that has same arguments as the UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Inspect(f func(ctx context.Context, tx pgx.Tx, userID int, delta float64)) *mUserRepositoryMockUpdateBalanceTx {
|
|
if mmUpdateBalanceTx.mock.inspectFuncUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("Inspect function is already set for UserRepositoryMock.UpdateBalanceTx")
|
|
}
|
|
|
|
mmUpdateBalanceTx.mock.inspectFuncUpdateBalanceTx = f
|
|
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
// Return sets up results that will be returned by UserRepository.UpdateBalanceTx
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Return(err error) *UserRepositoryMock {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
if mmUpdateBalanceTx.defaultExpectation == nil {
|
|
mmUpdateBalanceTx.defaultExpectation = &UserRepositoryMockUpdateBalanceTxExpectation{mock: mmUpdateBalanceTx.mock}
|
|
}
|
|
mmUpdateBalanceTx.defaultExpectation.results = &UserRepositoryMockUpdateBalanceTxResults{err}
|
|
mmUpdateBalanceTx.defaultExpectation.returnOrigin = minimock.CallerInfo(1)
|
|
return mmUpdateBalanceTx.mock
|
|
}
|
|
|
|
// Set uses given function f to mock the UserRepository.UpdateBalanceTx method
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Set(f func(ctx context.Context, tx pgx.Tx, userID int, delta float64) (err error)) *UserRepositoryMock {
|
|
if mmUpdateBalanceTx.defaultExpectation != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("Default expectation is already set for the UserRepository.UpdateBalanceTx method")
|
|
}
|
|
|
|
if len(mmUpdateBalanceTx.expectations) > 0 {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("Some expectations are already set for the UserRepository.UpdateBalanceTx method")
|
|
}
|
|
|
|
mmUpdateBalanceTx.mock.funcUpdateBalanceTx = f
|
|
mmUpdateBalanceTx.mock.funcUpdateBalanceTxOrigin = minimock.CallerInfo(1)
|
|
return mmUpdateBalanceTx.mock
|
|
}
|
|
|
|
// When sets expectation for the UserRepository.UpdateBalanceTx which will trigger the result defined by the following
|
|
// Then helper
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) When(ctx context.Context, tx pgx.Tx, userID int, delta float64) *UserRepositoryMockUpdateBalanceTxExpectation {
|
|
if mmUpdateBalanceTx.mock.funcUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("UserRepositoryMock.UpdateBalanceTx mock is already set by Set")
|
|
}
|
|
|
|
expectation := &UserRepositoryMockUpdateBalanceTxExpectation{
|
|
mock: mmUpdateBalanceTx.mock,
|
|
params: &UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta},
|
|
expectationOrigins: UserRepositoryMockUpdateBalanceTxExpectationOrigins{origin: minimock.CallerInfo(1)},
|
|
}
|
|
mmUpdateBalanceTx.expectations = append(mmUpdateBalanceTx.expectations, expectation)
|
|
return expectation
|
|
}
|
|
|
|
// Then sets up UserRepository.UpdateBalanceTx return parameters for the expectation previously defined by the When method
|
|
func (e *UserRepositoryMockUpdateBalanceTxExpectation) Then(err error) *UserRepositoryMock {
|
|
e.results = &UserRepositoryMockUpdateBalanceTxResults{err}
|
|
return e.mock
|
|
}
|
|
|
|
// Times sets number of times UserRepository.UpdateBalanceTx should be invoked
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Times(n uint64) *mUserRepositoryMockUpdateBalanceTx {
|
|
if n == 0 {
|
|
mmUpdateBalanceTx.mock.t.Fatalf("Times of UserRepositoryMock.UpdateBalanceTx mock can not be zero")
|
|
}
|
|
mm_atomic.StoreUint64(&mmUpdateBalanceTx.expectedInvocations, n)
|
|
mmUpdateBalanceTx.expectedInvocationsOrigin = minimock.CallerInfo(1)
|
|
return mmUpdateBalanceTx
|
|
}
|
|
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) invocationsDone() bool {
|
|
if len(mmUpdateBalanceTx.expectations) == 0 && mmUpdateBalanceTx.defaultExpectation == nil && mmUpdateBalanceTx.mock.funcUpdateBalanceTx == nil {
|
|
return true
|
|
}
|
|
|
|
totalInvocations := mm_atomic.LoadUint64(&mmUpdateBalanceTx.mock.afterUpdateBalanceTxCounter)
|
|
expectedInvocations := mm_atomic.LoadUint64(&mmUpdateBalanceTx.expectedInvocations)
|
|
|
|
return totalInvocations > 0 && (expectedInvocations == 0 || expectedInvocations == totalInvocations)
|
|
}
|
|
|
|
// UpdateBalanceTx implements mm_repository.UserRepository
|
|
func (mmUpdateBalanceTx *UserRepositoryMock) UpdateBalanceTx(ctx context.Context, tx pgx.Tx, userID int, delta float64) (err error) {
|
|
mm_atomic.AddUint64(&mmUpdateBalanceTx.beforeUpdateBalanceTxCounter, 1)
|
|
defer mm_atomic.AddUint64(&mmUpdateBalanceTx.afterUpdateBalanceTxCounter, 1)
|
|
|
|
mmUpdateBalanceTx.t.Helper()
|
|
|
|
if mmUpdateBalanceTx.inspectFuncUpdateBalanceTx != nil {
|
|
mmUpdateBalanceTx.inspectFuncUpdateBalanceTx(ctx, tx, userID, delta)
|
|
}
|
|
|
|
mm_params := UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta}
|
|
|
|
// Record call args
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.mutex.Lock()
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.callArgs = append(mmUpdateBalanceTx.UpdateBalanceTxMock.callArgs, &mm_params)
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.mutex.Unlock()
|
|
|
|
for _, e := range mmUpdateBalanceTx.UpdateBalanceTxMock.expectations {
|
|
if minimock.Equal(*e.params, mm_params) {
|
|
mm_atomic.AddUint64(&e.Counter, 1)
|
|
return e.results.err
|
|
}
|
|
}
|
|
|
|
if mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation != nil {
|
|
mm_atomic.AddUint64(&mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.Counter, 1)
|
|
mm_want := mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.params
|
|
mm_want_ptrs := mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.paramPtrs
|
|
|
|
mm_got := UserRepositoryMockUpdateBalanceTxParams{ctx, tx, userID, delta}
|
|
|
|
if mm_want_ptrs != nil {
|
|
|
|
if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) {
|
|
mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter ctx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originCtx, *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx))
|
|
}
|
|
|
|
if mm_want_ptrs.tx != nil && !minimock.Equal(*mm_want_ptrs.tx, mm_got.tx) {
|
|
mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter tx, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originTx, *mm_want_ptrs.tx, mm_got.tx, minimock.Diff(*mm_want_ptrs.tx, mm_got.tx))
|
|
}
|
|
|
|
if mm_want_ptrs.userID != nil && !minimock.Equal(*mm_want_ptrs.userID, mm_got.userID) {
|
|
mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter userID, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originUserID, *mm_want_ptrs.userID, mm_got.userID, minimock.Diff(*mm_want_ptrs.userID, mm_got.userID))
|
|
}
|
|
|
|
if mm_want_ptrs.delta != nil && !minimock.Equal(*mm_want_ptrs.delta, mm_got.delta) {
|
|
mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameter delta, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.originDelta, *mm_want_ptrs.delta, mm_got.delta, minimock.Diff(*mm_want_ptrs.delta, mm_got.delta))
|
|
}
|
|
|
|
} else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
|
|
mmUpdateBalanceTx.t.Errorf("UserRepositoryMock.UpdateBalanceTx got unexpected parameters, expected at\n%s:\nwant: %#v\n got: %#v%s\n",
|
|
mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.origin, *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
|
|
}
|
|
|
|
mm_results := mmUpdateBalanceTx.UpdateBalanceTxMock.defaultExpectation.results
|
|
if mm_results == nil {
|
|
mmUpdateBalanceTx.t.Fatal("No results are set for the UserRepositoryMock.UpdateBalanceTx")
|
|
}
|
|
return (*mm_results).err
|
|
}
|
|
if mmUpdateBalanceTx.funcUpdateBalanceTx != nil {
|
|
return mmUpdateBalanceTx.funcUpdateBalanceTx(ctx, tx, userID, delta)
|
|
}
|
|
mmUpdateBalanceTx.t.Fatalf("Unexpected call to UserRepositoryMock.UpdateBalanceTx. %v %v %v %v", ctx, tx, userID, delta)
|
|
return
|
|
}
|
|
|
|
// UpdateBalanceTxAfterCounter returns a count of finished UserRepositoryMock.UpdateBalanceTx invocations
|
|
func (mmUpdateBalanceTx *UserRepositoryMock) UpdateBalanceTxAfterCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmUpdateBalanceTx.afterUpdateBalanceTxCounter)
|
|
}
|
|
|
|
// UpdateBalanceTxBeforeCounter returns a count of UserRepositoryMock.UpdateBalanceTx invocations
|
|
func (mmUpdateBalanceTx *UserRepositoryMock) UpdateBalanceTxBeforeCounter() uint64 {
|
|
return mm_atomic.LoadUint64(&mmUpdateBalanceTx.beforeUpdateBalanceTxCounter)
|
|
}
|
|
|
|
// Calls returns a list of arguments used in each call to UserRepositoryMock.UpdateBalanceTx.
|
|
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
|
|
func (mmUpdateBalanceTx *mUserRepositoryMockUpdateBalanceTx) Calls() []*UserRepositoryMockUpdateBalanceTxParams {
|
|
mmUpdateBalanceTx.mutex.RLock()
|
|
|
|
argCopy := make([]*UserRepositoryMockUpdateBalanceTxParams, len(mmUpdateBalanceTx.callArgs))
|
|
copy(argCopy, mmUpdateBalanceTx.callArgs)
|
|
|
|
mmUpdateBalanceTx.mutex.RUnlock()
|
|
|
|
return argCopy
|
|
}
|
|
|
|
// MinimockUpdateBalanceTxDone returns true if the count of the UpdateBalanceTx invocations corresponds
|
|
// the number of defined expectations
|
|
func (m *UserRepositoryMock) MinimockUpdateBalanceTxDone() bool {
|
|
if m.UpdateBalanceTxMock.optional {
|
|
// Optional methods provide '0 or more' call count restriction.
|
|
return true
|
|
}
|
|
|
|
for _, e := range m.UpdateBalanceTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return m.UpdateBalanceTxMock.invocationsDone()
|
|
}
|
|
|
|
// MinimockUpdateBalanceTxInspect logs each unmet expectation
|
|
func (m *UserRepositoryMock) MinimockUpdateBalanceTxInspect() {
|
|
for _, e := range m.UpdateBalanceTxMock.expectations {
|
|
if mm_atomic.LoadUint64(&e.Counter) < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s with params: %#v", e.expectationOrigins.origin, *e.params)
|
|
}
|
|
}
|
|
|
|
afterUpdateBalanceTxCounter := mm_atomic.LoadUint64(&m.afterUpdateBalanceTxCounter)
|
|
// if default expectation was set then invocations count should be greater than zero
|
|
if m.UpdateBalanceTxMock.defaultExpectation != nil && afterUpdateBalanceTxCounter < 1 {
|
|
if m.UpdateBalanceTxMock.defaultExpectation.params == nil {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s", m.UpdateBalanceTxMock.defaultExpectation.returnOrigin)
|
|
} else {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s with params: %#v", m.UpdateBalanceTxMock.defaultExpectation.expectationOrigins.origin, *m.UpdateBalanceTxMock.defaultExpectation.params)
|
|
}
|
|
}
|
|
// if func was set then invocations count should be greater than zero
|
|
if m.funcUpdateBalanceTx != nil && afterUpdateBalanceTxCounter < 1 {
|
|
m.t.Errorf("Expected call to UserRepositoryMock.UpdateBalanceTx at\n%s", m.funcUpdateBalanceTxOrigin)
|
|
}
|
|
|
|
if !m.UpdateBalanceTxMock.invocationsDone() && afterUpdateBalanceTxCounter > 0 {
|
|
m.t.Errorf("Expected %d calls to UserRepositoryMock.UpdateBalanceTx at\n%s but found %d calls",
|
|
mm_atomic.LoadUint64(&m.UpdateBalanceTxMock.expectedInvocations), m.UpdateBalanceTxMock.expectedInvocationsOrigin, afterUpdateBalanceTxCounter)
|
|
}
|
|
}
|
|
|
|
// MinimockFinish checks that all mocked methods have been called the expected number of times
|
|
func (m *UserRepositoryMock) MinimockFinish() {
|
|
m.finishOnce.Do(func() {
|
|
if !m.minimockDone() {
|
|
m.MinimockCheckInviteLimitInspect()
|
|
|
|
m.MinimockCheckInviteLimitTxInspect()
|
|
|
|
m.MinimockCreateInspect()
|
|
|
|
m.MinimockCreateTxInspect()
|
|
|
|
m.MinimockFindByEmailHashInspect()
|
|
|
|
m.MinimockFindByIDInspect()
|
|
|
|
m.MinimockGetBalanceInspect()
|
|
|
|
m.MinimockIncrementInvitesIssuedInspect()
|
|
|
|
m.MinimockIncrementInvitesIssuedTxInspect()
|
|
|
|
m.MinimockUpdateBalanceInspect()
|
|
|
|
m.MinimockUpdateBalanceTxInspect()
|
|
}
|
|
})
|
|
}
|
|
|
|
// MinimockWait waits for all mocked methods to be called the expected number of times
|
|
func (m *UserRepositoryMock) 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 *UserRepositoryMock) minimockDone() bool {
|
|
done := true
|
|
return done &&
|
|
m.MinimockCheckInviteLimitDone() &&
|
|
m.MinimockCheckInviteLimitTxDone() &&
|
|
m.MinimockCreateDone() &&
|
|
m.MinimockCreateTxDone() &&
|
|
m.MinimockFindByEmailHashDone() &&
|
|
m.MinimockFindByIDDone() &&
|
|
m.MinimockGetBalanceDone() &&
|
|
m.MinimockIncrementInvitesIssuedDone() &&
|
|
m.MinimockIncrementInvitesIssuedTxDone() &&
|
|
m.MinimockUpdateBalanceDone() &&
|
|
m.MinimockUpdateBalanceTxDone()
|
|
}
|