-
-
Save ianaz/6438a2fd06b2aef7ca317ae3f5e50da0 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Code generated by counterfeiter. DO NOT EDIT. | |
package repositoryfakes | |
import ( | |
"context" | |
"sync" | |
"time" | |
"github.com/certifaction/api/model" | |
"github.com/certifaction/api/signature_requests/repository" | |
) | |
type FakeRepository struct { | |
CreateStub func(context.Context, *model.SignatureRequest) error | |
createMutex sync.RWMutex | |
createArgsForCall []struct { | |
arg1 context.Context | |
arg2 *model.SignatureRequest | |
} | |
createReturns struct { | |
result1 error | |
} | |
createReturnsOnCall map[int]struct { | |
result1 error | |
} | |
CreateTokenStub func(context.Context, string, *model.SignatureRequestsToken) error | |
createTokenMutex sync.RWMutex | |
createTokenArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 *model.SignatureRequestsToken | |
} | |
createTokenReturns struct { | |
result1 error | |
} | |
createTokenReturnsOnCall map[int]struct { | |
result1 error | |
} | |
DeleteAccessByFileIDStub func(context.Context, string) error | |
deleteAccessByFileIDMutex sync.RWMutex | |
deleteAccessByFileIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
deleteAccessByFileIDReturns struct { | |
result1 error | |
} | |
deleteAccessByFileIDReturnsOnCall map[int]struct { | |
result1 error | |
} | |
DeleteByFileIDAndSignerUIDStub func(context.Context, string, string, string) error | |
deleteByFileIDAndSignerUIDMutex sync.RWMutex | |
deleteByFileIDAndSignerUIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
arg4 string | |
} | |
deleteByFileIDAndSignerUIDReturns struct { | |
result1 error | |
} | |
deleteByFileIDAndSignerUIDReturnsOnCall map[int]struct { | |
result1 error | |
} | |
DeleteByIDStub func(context.Context, string) error | |
deleteByIDMutex sync.RWMutex | |
deleteByIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
deleteByIDReturns struct { | |
result1 error | |
} | |
deleteByIDReturnsOnCall map[int]struct { | |
result1 error | |
} | |
DeleteTokensStub func(context.Context, string) error | |
deleteTokensMutex sync.RWMutex | |
deleteTokensArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
deleteTokensReturns struct { | |
result1 error | |
} | |
deleteTokensReturnsOnCall map[int]struct { | |
result1 error | |
} | |
FindActiveForOrganizationStub func(context.Context, string) ([]model.SignatureRequest, error) | |
findActiveForOrganizationMutex sync.RWMutex | |
findActiveForOrganizationArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findActiveForOrganizationReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findActiveForOrganizationReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindAllForOrganizationStub func(context.Context, string) ([]model.SignatureRequest, error) | |
findAllForOrganizationMutex sync.RWMutex | |
findAllForOrganizationArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findAllForOrganizationReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findAllForOrganizationReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindAllForSignerStub func(context.Context, string) ([]model.SignatureRequest, error) | |
findAllForSignerMutex sync.RWMutex | |
findAllForSignerArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findAllForSignerReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findAllForSignerReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindByDocumentIDAndSignerUIDStub func(context.Context, string, string) (*model.SignatureRequest, error) | |
findByDocumentIDAndSignerUIDMutex sync.RWMutex | |
findByDocumentIDAndSignerUIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
} | |
findByDocumentIDAndSignerUIDReturns struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
findByDocumentIDAndSignerUIDReturnsOnCall map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
FindByFileIDStub func(context.Context, []string, bool) ([]model.SignatureRequest, error) | |
findByFileIDMutex sync.RWMutex | |
findByFileIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 []string | |
arg3 bool | |
} | |
findByFileIDReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findByFileIDReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindByFileIDAndSignerUIDStub func(context.Context, string, string) (*model.SignatureRequest, error) | |
findByFileIDAndSignerUIDMutex sync.RWMutex | |
findByFileIDAndSignerUIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
} | |
findByFileIDAndSignerUIDReturns struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
findByFileIDAndSignerUIDReturnsOnCall map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
FindByFileIDsAndSignerStub func(context.Context, []string, *model.User, bool, bool) ([]model.SignatureRequest, error) | |
findByFileIDsAndSignerMutex sync.RWMutex | |
findByFileIDsAndSignerArgsForCall []struct { | |
arg1 context.Context | |
arg2 []string | |
arg3 *model.User | |
arg4 bool | |
arg5 bool | |
} | |
findByFileIDsAndSignerReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findByFileIDsAndSignerReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindByHashedSignerTokenStub func(context.Context, string) (*model.SignatureRequest, error) | |
findByHashedSignerTokenMutex sync.RWMutex | |
findByHashedSignerTokenArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findByHashedSignerTokenReturns struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
findByHashedSignerTokenReturnsOnCall map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
FindByIDStub func(context.Context, string) (*model.SignatureRequest, error) | |
findByIDMutex sync.RWMutex | |
findByIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findByIDReturns struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
findByIDReturnsOnCall map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
FindByIDForSignerUIDStub func(context.Context, string, string) (*model.SignatureRequest, error) | |
findByIDForSignerUIDMutex sync.RWMutex | |
findByIDForSignerUIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
} | |
findByIDForSignerUIDReturns struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
findByIDForSignerUIDReturnsOnCall map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
FindByProcessIDStub func(context.Context, string) ([]model.SignatureRequest, error) | |
findByProcessIDMutex sync.RWMutex | |
findByProcessIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findByProcessIDReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findByProcessIDReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub func(context.Context, string, time.Time, int) ([]model.SignatureRequest, error) | |
findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex sync.RWMutex | |
findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 time.Time | |
arg4 int | |
} | |
findByRequestorCreatedBeforeNotAnonymizedForUpdateReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindBySignerUIDStub func(context.Context, string) (*model.SignatureRequest, error) | |
findBySignerUIDMutex sync.RWMutex | |
findBySignerUIDArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findBySignerUIDReturns struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
findBySignerUIDReturnsOnCall map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
} | |
FindBySignerWithNameOrEmailLikeStub func(context.Context, string, string) ([]model.SignatureRequest, error) | |
findBySignerWithNameOrEmailLikeMutex sync.RWMutex | |
findBySignerWithNameOrEmailLikeArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
} | |
findBySignerWithNameOrEmailLikeReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findBySignerWithNameOrEmailLikeReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindCompletedForOrganizationStub func(context.Context, string) ([]model.SignatureRequest, error) | |
findCompletedForOrganizationMutex sync.RWMutex | |
findCompletedForOrganizationArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findCompletedForOrganizationReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findCompletedForOrganizationReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindExpiredBeforeStub func(context.Context, time.Time) ([]model.SignatureRequest, error) | |
findExpiredBeforeMutex sync.RWMutex | |
findExpiredBeforeArgsForCall []struct { | |
arg1 context.Context | |
arg2 time.Time | |
} | |
findExpiredBeforeReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findExpiredBeforeReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindExpiredByFileIdStub func(context.Context, string) ([]model.SignatureRequest, error) | |
findExpiredByFileIdMutex sync.RWMutex | |
findExpiredByFileIdArgsForCall []struct { | |
arg1 context.Context | |
arg2 string | |
} | |
findExpiredByFileIdReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findExpiredByFileIdReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub func(context.Context, time.Time, int) ([]model.SignatureRequest, error) | |
findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex sync.RWMutex | |
findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall []struct { | |
arg1 context.Context | |
arg2 time.Time | |
arg3 int | |
} | |
findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
} | |
UpdateStub func(context.Context, *model.SignatureRequest) error | |
updateMutex sync.RWMutex | |
updateArgsForCall []struct { | |
arg1 context.Context | |
arg2 *model.SignatureRequest | |
} | |
updateReturns struct { | |
result1 error | |
} | |
updateReturnsOnCall map[int]struct { | |
result1 error | |
} | |
invocations map[string][][]interface{} | |
invocationsMutex sync.RWMutex | |
} | |
func (fake *FakeRepository) Create(arg1 context.Context, arg2 *model.SignatureRequest) error { | |
fake.createMutex.Lock() | |
ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] | |
fake.createArgsForCall = append(fake.createArgsForCall, struct { | |
arg1 context.Context | |
arg2 *model.SignatureRequest | |
}{arg1, arg2}) | |
stub := fake.CreateStub | |
fakeReturns := fake.createReturns | |
fake.recordInvocation("Create", []interface{}{arg1, arg2}) | |
fake.createMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) CreateCallCount() int { | |
fake.createMutex.RLock() | |
defer fake.createMutex.RUnlock() | |
return len(fake.createArgsForCall) | |
} | |
func (fake *FakeRepository) CreateCalls(stub func(context.Context, *model.SignatureRequest) error) { | |
fake.createMutex.Lock() | |
defer fake.createMutex.Unlock() | |
fake.CreateStub = stub | |
} | |
func (fake *FakeRepository) CreateArgsForCall(i int) (context.Context, *model.SignatureRequest) { | |
fake.createMutex.RLock() | |
defer fake.createMutex.RUnlock() | |
argsForCall := fake.createArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) CreateReturns(result1 error) { | |
fake.createMutex.Lock() | |
defer fake.createMutex.Unlock() | |
fake.CreateStub = nil | |
fake.createReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) CreateReturnsOnCall(i int, result1 error) { | |
fake.createMutex.Lock() | |
defer fake.createMutex.Unlock() | |
fake.CreateStub = nil | |
if fake.createReturnsOnCall == nil { | |
fake.createReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.createReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) CreateToken(arg1 context.Context, arg2 string, arg3 *model.SignatureRequestsToken) error { | |
fake.createTokenMutex.Lock() | |
ret, specificReturn := fake.createTokenReturnsOnCall[len(fake.createTokenArgsForCall)] | |
fake.createTokenArgsForCall = append(fake.createTokenArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 *model.SignatureRequestsToken | |
}{arg1, arg2, arg3}) | |
stub := fake.CreateTokenStub | |
fakeReturns := fake.createTokenReturns | |
fake.recordInvocation("CreateToken", []interface{}{arg1, arg2, arg3}) | |
fake.createTokenMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) CreateTokenCallCount() int { | |
fake.createTokenMutex.RLock() | |
defer fake.createTokenMutex.RUnlock() | |
return len(fake.createTokenArgsForCall) | |
} | |
func (fake *FakeRepository) CreateTokenCalls(stub func(context.Context, string, *model.SignatureRequestsToken) error) { | |
fake.createTokenMutex.Lock() | |
defer fake.createTokenMutex.Unlock() | |
fake.CreateTokenStub = stub | |
} | |
func (fake *FakeRepository) CreateTokenArgsForCall(i int) (context.Context, string, *model.SignatureRequestsToken) { | |
fake.createTokenMutex.RLock() | |
defer fake.createTokenMutex.RUnlock() | |
argsForCall := fake.createTokenArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) CreateTokenReturns(result1 error) { | |
fake.createTokenMutex.Lock() | |
defer fake.createTokenMutex.Unlock() | |
fake.CreateTokenStub = nil | |
fake.createTokenReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) CreateTokenReturnsOnCall(i int, result1 error) { | |
fake.createTokenMutex.Lock() | |
defer fake.createTokenMutex.Unlock() | |
fake.CreateTokenStub = nil | |
if fake.createTokenReturnsOnCall == nil { | |
fake.createTokenReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.createTokenReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteAccessByFileID(arg1 context.Context, arg2 string) error { | |
fake.deleteAccessByFileIDMutex.Lock() | |
ret, specificReturn := fake.deleteAccessByFileIDReturnsOnCall[len(fake.deleteAccessByFileIDArgsForCall)] | |
fake.deleteAccessByFileIDArgsForCall = append(fake.deleteAccessByFileIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.DeleteAccessByFileIDStub | |
fakeReturns := fake.deleteAccessByFileIDReturns | |
fake.recordInvocation("DeleteAccessByFileID", []interface{}{arg1, arg2}) | |
fake.deleteAccessByFileIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) DeleteAccessByFileIDCallCount() int { | |
fake.deleteAccessByFileIDMutex.RLock() | |
defer fake.deleteAccessByFileIDMutex.RUnlock() | |
return len(fake.deleteAccessByFileIDArgsForCall) | |
} | |
func (fake *FakeRepository) DeleteAccessByFileIDCalls(stub func(context.Context, string) error) { | |
fake.deleteAccessByFileIDMutex.Lock() | |
defer fake.deleteAccessByFileIDMutex.Unlock() | |
fake.DeleteAccessByFileIDStub = stub | |
} | |
func (fake *FakeRepository) DeleteAccessByFileIDArgsForCall(i int) (context.Context, string) { | |
fake.deleteAccessByFileIDMutex.RLock() | |
defer fake.deleteAccessByFileIDMutex.RUnlock() | |
argsForCall := fake.deleteAccessByFileIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) DeleteAccessByFileIDReturns(result1 error) { | |
fake.deleteAccessByFileIDMutex.Lock() | |
defer fake.deleteAccessByFileIDMutex.Unlock() | |
fake.DeleteAccessByFileIDStub = nil | |
fake.deleteAccessByFileIDReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteAccessByFileIDReturnsOnCall(i int, result1 error) { | |
fake.deleteAccessByFileIDMutex.Lock() | |
defer fake.deleteAccessByFileIDMutex.Unlock() | |
fake.DeleteAccessByFileIDStub = nil | |
if fake.deleteAccessByFileIDReturnsOnCall == nil { | |
fake.deleteAccessByFileIDReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.deleteAccessByFileIDReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteByFileIDAndSignerUID(arg1 context.Context, arg2 string, arg3 string, arg4 string) error { | |
fake.deleteByFileIDAndSignerUIDMutex.Lock() | |
ret, specificReturn := fake.deleteByFileIDAndSignerUIDReturnsOnCall[len(fake.deleteByFileIDAndSignerUIDArgsForCall)] | |
fake.deleteByFileIDAndSignerUIDArgsForCall = append(fake.deleteByFileIDAndSignerUIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
arg4 string | |
}{arg1, arg2, arg3, arg4}) | |
stub := fake.DeleteByFileIDAndSignerUIDStub | |
fakeReturns := fake.deleteByFileIDAndSignerUIDReturns | |
fake.recordInvocation("DeleteByFileIDAndSignerUID", []interface{}{arg1, arg2, arg3, arg4}) | |
fake.deleteByFileIDAndSignerUIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3, arg4) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) DeleteByFileIDAndSignerUIDCallCount() int { | |
fake.deleteByFileIDAndSignerUIDMutex.RLock() | |
defer fake.deleteByFileIDAndSignerUIDMutex.RUnlock() | |
return len(fake.deleteByFileIDAndSignerUIDArgsForCall) | |
} | |
func (fake *FakeRepository) DeleteByFileIDAndSignerUIDCalls(stub func(context.Context, string, string, string) error) { | |
fake.deleteByFileIDAndSignerUIDMutex.Lock() | |
defer fake.deleteByFileIDAndSignerUIDMutex.Unlock() | |
fake.DeleteByFileIDAndSignerUIDStub = stub | |
} | |
func (fake *FakeRepository) DeleteByFileIDAndSignerUIDArgsForCall(i int) (context.Context, string, string, string) { | |
fake.deleteByFileIDAndSignerUIDMutex.RLock() | |
defer fake.deleteByFileIDAndSignerUIDMutex.RUnlock() | |
argsForCall := fake.deleteByFileIDAndSignerUIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 | |
} | |
func (fake *FakeRepository) DeleteByFileIDAndSignerUIDReturns(result1 error) { | |
fake.deleteByFileIDAndSignerUIDMutex.Lock() | |
defer fake.deleteByFileIDAndSignerUIDMutex.Unlock() | |
fake.DeleteByFileIDAndSignerUIDStub = nil | |
fake.deleteByFileIDAndSignerUIDReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteByFileIDAndSignerUIDReturnsOnCall(i int, result1 error) { | |
fake.deleteByFileIDAndSignerUIDMutex.Lock() | |
defer fake.deleteByFileIDAndSignerUIDMutex.Unlock() | |
fake.DeleteByFileIDAndSignerUIDStub = nil | |
if fake.deleteByFileIDAndSignerUIDReturnsOnCall == nil { | |
fake.deleteByFileIDAndSignerUIDReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.deleteByFileIDAndSignerUIDReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteByID(arg1 context.Context, arg2 string) error { | |
fake.deleteByIDMutex.Lock() | |
ret, specificReturn := fake.deleteByIDReturnsOnCall[len(fake.deleteByIDArgsForCall)] | |
fake.deleteByIDArgsForCall = append(fake.deleteByIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.DeleteByIDStub | |
fakeReturns := fake.deleteByIDReturns | |
fake.recordInvocation("DeleteByID", []interface{}{arg1, arg2}) | |
fake.deleteByIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) DeleteByIDCallCount() int { | |
fake.deleteByIDMutex.RLock() | |
defer fake.deleteByIDMutex.RUnlock() | |
return len(fake.deleteByIDArgsForCall) | |
} | |
func (fake *FakeRepository) DeleteByIDCalls(stub func(context.Context, string) error) { | |
fake.deleteByIDMutex.Lock() | |
defer fake.deleteByIDMutex.Unlock() | |
fake.DeleteByIDStub = stub | |
} | |
func (fake *FakeRepository) DeleteByIDArgsForCall(i int) (context.Context, string) { | |
fake.deleteByIDMutex.RLock() | |
defer fake.deleteByIDMutex.RUnlock() | |
argsForCall := fake.deleteByIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) DeleteByIDReturns(result1 error) { | |
fake.deleteByIDMutex.Lock() | |
defer fake.deleteByIDMutex.Unlock() | |
fake.DeleteByIDStub = nil | |
fake.deleteByIDReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteByIDReturnsOnCall(i int, result1 error) { | |
fake.deleteByIDMutex.Lock() | |
defer fake.deleteByIDMutex.Unlock() | |
fake.DeleteByIDStub = nil | |
if fake.deleteByIDReturnsOnCall == nil { | |
fake.deleteByIDReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.deleteByIDReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteTokens(arg1 context.Context, arg2 string) error { | |
fake.deleteTokensMutex.Lock() | |
ret, specificReturn := fake.deleteTokensReturnsOnCall[len(fake.deleteTokensArgsForCall)] | |
fake.deleteTokensArgsForCall = append(fake.deleteTokensArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.DeleteTokensStub | |
fakeReturns := fake.deleteTokensReturns | |
fake.recordInvocation("DeleteTokens", []interface{}{arg1, arg2}) | |
fake.deleteTokensMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) DeleteTokensCallCount() int { | |
fake.deleteTokensMutex.RLock() | |
defer fake.deleteTokensMutex.RUnlock() | |
return len(fake.deleteTokensArgsForCall) | |
} | |
func (fake *FakeRepository) DeleteTokensCalls(stub func(context.Context, string) error) { | |
fake.deleteTokensMutex.Lock() | |
defer fake.deleteTokensMutex.Unlock() | |
fake.DeleteTokensStub = stub | |
} | |
func (fake *FakeRepository) DeleteTokensArgsForCall(i int) (context.Context, string) { | |
fake.deleteTokensMutex.RLock() | |
defer fake.deleteTokensMutex.RUnlock() | |
argsForCall := fake.deleteTokensArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) DeleteTokensReturns(result1 error) { | |
fake.deleteTokensMutex.Lock() | |
defer fake.deleteTokensMutex.Unlock() | |
fake.DeleteTokensStub = nil | |
fake.deleteTokensReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) DeleteTokensReturnsOnCall(i int, result1 error) { | |
fake.deleteTokensMutex.Lock() | |
defer fake.deleteTokensMutex.Unlock() | |
fake.DeleteTokensStub = nil | |
if fake.deleteTokensReturnsOnCall == nil { | |
fake.deleteTokensReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.deleteTokensReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) FindActiveForOrganization(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) { | |
fake.findActiveForOrganizationMutex.Lock() | |
ret, specificReturn := fake.findActiveForOrganizationReturnsOnCall[len(fake.findActiveForOrganizationArgsForCall)] | |
fake.findActiveForOrganizationArgsForCall = append(fake.findActiveForOrganizationArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindActiveForOrganizationStub | |
fakeReturns := fake.findActiveForOrganizationReturns | |
fake.recordInvocation("FindActiveForOrganization", []interface{}{arg1, arg2}) | |
fake.findActiveForOrganizationMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindActiveForOrganizationCallCount() int { | |
fake.findActiveForOrganizationMutex.RLock() | |
defer fake.findActiveForOrganizationMutex.RUnlock() | |
return len(fake.findActiveForOrganizationArgsForCall) | |
} | |
func (fake *FakeRepository) FindActiveForOrganizationCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) { | |
fake.findActiveForOrganizationMutex.Lock() | |
defer fake.findActiveForOrganizationMutex.Unlock() | |
fake.FindActiveForOrganizationStub = stub | |
} | |
func (fake *FakeRepository) FindActiveForOrganizationArgsForCall(i int) (context.Context, string) { | |
fake.findActiveForOrganizationMutex.RLock() | |
defer fake.findActiveForOrganizationMutex.RUnlock() | |
argsForCall := fake.findActiveForOrganizationArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindActiveForOrganizationReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findActiveForOrganizationMutex.Lock() | |
defer fake.findActiveForOrganizationMutex.Unlock() | |
fake.FindActiveForOrganizationStub = nil | |
fake.findActiveForOrganizationReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindActiveForOrganizationReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findActiveForOrganizationMutex.Lock() | |
defer fake.findActiveForOrganizationMutex.Unlock() | |
fake.FindActiveForOrganizationStub = nil | |
if fake.findActiveForOrganizationReturnsOnCall == nil { | |
fake.findActiveForOrganizationReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findActiveForOrganizationReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindAllForOrganization(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) { | |
fake.findAllForOrganizationMutex.Lock() | |
ret, specificReturn := fake.findAllForOrganizationReturnsOnCall[len(fake.findAllForOrganizationArgsForCall)] | |
fake.findAllForOrganizationArgsForCall = append(fake.findAllForOrganizationArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindAllForOrganizationStub | |
fakeReturns := fake.findAllForOrganizationReturns | |
fake.recordInvocation("FindAllForOrganization", []interface{}{arg1, arg2}) | |
fake.findAllForOrganizationMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindAllForOrganizationCallCount() int { | |
fake.findAllForOrganizationMutex.RLock() | |
defer fake.findAllForOrganizationMutex.RUnlock() | |
return len(fake.findAllForOrganizationArgsForCall) | |
} | |
func (fake *FakeRepository) FindAllForOrganizationCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) { | |
fake.findAllForOrganizationMutex.Lock() | |
defer fake.findAllForOrganizationMutex.Unlock() | |
fake.FindAllForOrganizationStub = stub | |
} | |
func (fake *FakeRepository) FindAllForOrganizationArgsForCall(i int) (context.Context, string) { | |
fake.findAllForOrganizationMutex.RLock() | |
defer fake.findAllForOrganizationMutex.RUnlock() | |
argsForCall := fake.findAllForOrganizationArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindAllForOrganizationReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findAllForOrganizationMutex.Lock() | |
defer fake.findAllForOrganizationMutex.Unlock() | |
fake.FindAllForOrganizationStub = nil | |
fake.findAllForOrganizationReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindAllForOrganizationReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findAllForOrganizationMutex.Lock() | |
defer fake.findAllForOrganizationMutex.Unlock() | |
fake.FindAllForOrganizationStub = nil | |
if fake.findAllForOrganizationReturnsOnCall == nil { | |
fake.findAllForOrganizationReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findAllForOrganizationReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindAllForSigner(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) { | |
fake.findAllForSignerMutex.Lock() | |
ret, specificReturn := fake.findAllForSignerReturnsOnCall[len(fake.findAllForSignerArgsForCall)] | |
fake.findAllForSignerArgsForCall = append(fake.findAllForSignerArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindAllForSignerStub | |
fakeReturns := fake.findAllForSignerReturns | |
fake.recordInvocation("FindAllForSigner", []interface{}{arg1, arg2}) | |
fake.findAllForSignerMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindAllForSignerCallCount() int { | |
fake.findAllForSignerMutex.RLock() | |
defer fake.findAllForSignerMutex.RUnlock() | |
return len(fake.findAllForSignerArgsForCall) | |
} | |
func (fake *FakeRepository) FindAllForSignerCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) { | |
fake.findAllForSignerMutex.Lock() | |
defer fake.findAllForSignerMutex.Unlock() | |
fake.FindAllForSignerStub = stub | |
} | |
func (fake *FakeRepository) FindAllForSignerArgsForCall(i int) (context.Context, string) { | |
fake.findAllForSignerMutex.RLock() | |
defer fake.findAllForSignerMutex.RUnlock() | |
argsForCall := fake.findAllForSignerArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindAllForSignerReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findAllForSignerMutex.Lock() | |
defer fake.findAllForSignerMutex.Unlock() | |
fake.FindAllForSignerStub = nil | |
fake.findAllForSignerReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindAllForSignerReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findAllForSignerMutex.Lock() | |
defer fake.findAllForSignerMutex.Unlock() | |
fake.FindAllForSignerStub = nil | |
if fake.findAllForSignerReturnsOnCall == nil { | |
fake.findAllForSignerReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findAllForSignerReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByDocumentIDAndSignerUID(arg1 context.Context, arg2 string, arg3 string) (*model.SignatureRequest, error) { | |
fake.findByDocumentIDAndSignerUIDMutex.Lock() | |
ret, specificReturn := fake.findByDocumentIDAndSignerUIDReturnsOnCall[len(fake.findByDocumentIDAndSignerUIDArgsForCall)] | |
fake.findByDocumentIDAndSignerUIDArgsForCall = append(fake.findByDocumentIDAndSignerUIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
}{arg1, arg2, arg3}) | |
stub := fake.FindByDocumentIDAndSignerUIDStub | |
fakeReturns := fake.findByDocumentIDAndSignerUIDReturns | |
fake.recordInvocation("FindByDocumentIDAndSignerUID", []interface{}{arg1, arg2, arg3}) | |
fake.findByDocumentIDAndSignerUIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByDocumentIDAndSignerUIDCallCount() int { | |
fake.findByDocumentIDAndSignerUIDMutex.RLock() | |
defer fake.findByDocumentIDAndSignerUIDMutex.RUnlock() | |
return len(fake.findByDocumentIDAndSignerUIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindByDocumentIDAndSignerUIDCalls(stub func(context.Context, string, string) (*model.SignatureRequest, error)) { | |
fake.findByDocumentIDAndSignerUIDMutex.Lock() | |
defer fake.findByDocumentIDAndSignerUIDMutex.Unlock() | |
fake.FindByDocumentIDAndSignerUIDStub = stub | |
} | |
func (fake *FakeRepository) FindByDocumentIDAndSignerUIDArgsForCall(i int) (context.Context, string, string) { | |
fake.findByDocumentIDAndSignerUIDMutex.RLock() | |
defer fake.findByDocumentIDAndSignerUIDMutex.RUnlock() | |
argsForCall := fake.findByDocumentIDAndSignerUIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) FindByDocumentIDAndSignerUIDReturns(result1 *model.SignatureRequest, result2 error) { | |
fake.findByDocumentIDAndSignerUIDMutex.Lock() | |
defer fake.findByDocumentIDAndSignerUIDMutex.Unlock() | |
fake.FindByDocumentIDAndSignerUIDStub = nil | |
fake.findByDocumentIDAndSignerUIDReturns = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByDocumentIDAndSignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) { | |
fake.findByDocumentIDAndSignerUIDMutex.Lock() | |
defer fake.findByDocumentIDAndSignerUIDMutex.Unlock() | |
fake.FindByDocumentIDAndSignerUIDStub = nil | |
if fake.findByDocumentIDAndSignerUIDReturnsOnCall == nil { | |
fake.findByDocumentIDAndSignerUIDReturnsOnCall = make(map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByDocumentIDAndSignerUIDReturnsOnCall[i] = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByFileID(arg1 context.Context, arg2 []string, arg3 bool) ([]model.SignatureRequest, error) { | |
var arg2Copy []string | |
if arg2 != nil { | |
arg2Copy = make([]string, len(arg2)) | |
copy(arg2Copy, arg2) | |
} | |
fake.findByFileIDMutex.Lock() | |
ret, specificReturn := fake.findByFileIDReturnsOnCall[len(fake.findByFileIDArgsForCall)] | |
fake.findByFileIDArgsForCall = append(fake.findByFileIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 []string | |
arg3 bool | |
}{arg1, arg2Copy, arg3}) | |
stub := fake.FindByFileIDStub | |
fakeReturns := fake.findByFileIDReturns | |
fake.recordInvocation("FindByFileID", []interface{}{arg1, arg2Copy, arg3}) | |
fake.findByFileIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByFileIDCallCount() int { | |
fake.findByFileIDMutex.RLock() | |
defer fake.findByFileIDMutex.RUnlock() | |
return len(fake.findByFileIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindByFileIDCalls(stub func(context.Context, []string, bool) ([]model.SignatureRequest, error)) { | |
fake.findByFileIDMutex.Lock() | |
defer fake.findByFileIDMutex.Unlock() | |
fake.FindByFileIDStub = stub | |
} | |
func (fake *FakeRepository) FindByFileIDArgsForCall(i int) (context.Context, []string, bool) { | |
fake.findByFileIDMutex.RLock() | |
defer fake.findByFileIDMutex.RUnlock() | |
argsForCall := fake.findByFileIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) FindByFileIDReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findByFileIDMutex.Lock() | |
defer fake.findByFileIDMutex.Unlock() | |
fake.FindByFileIDStub = nil | |
fake.findByFileIDReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByFileIDReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findByFileIDMutex.Lock() | |
defer fake.findByFileIDMutex.Unlock() | |
fake.FindByFileIDStub = nil | |
if fake.findByFileIDReturnsOnCall == nil { | |
fake.findByFileIDReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByFileIDReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByFileIDAndSignerUID(arg1 context.Context, arg2 string, arg3 string) (*model.SignatureRequest, error) { | |
fake.findByFileIDAndSignerUIDMutex.Lock() | |
ret, specificReturn := fake.findByFileIDAndSignerUIDReturnsOnCall[len(fake.findByFileIDAndSignerUIDArgsForCall)] | |
fake.findByFileIDAndSignerUIDArgsForCall = append(fake.findByFileIDAndSignerUIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
}{arg1, arg2, arg3}) | |
stub := fake.FindByFileIDAndSignerUIDStub | |
fakeReturns := fake.findByFileIDAndSignerUIDReturns | |
fake.recordInvocation("FindByFileIDAndSignerUID", []interface{}{arg1, arg2, arg3}) | |
fake.findByFileIDAndSignerUIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByFileIDAndSignerUIDCallCount() int { | |
fake.findByFileIDAndSignerUIDMutex.RLock() | |
defer fake.findByFileIDAndSignerUIDMutex.RUnlock() | |
return len(fake.findByFileIDAndSignerUIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindByFileIDAndSignerUIDCalls(stub func(context.Context, string, string) (*model.SignatureRequest, error)) { | |
fake.findByFileIDAndSignerUIDMutex.Lock() | |
defer fake.findByFileIDAndSignerUIDMutex.Unlock() | |
fake.FindByFileIDAndSignerUIDStub = stub | |
} | |
func (fake *FakeRepository) FindByFileIDAndSignerUIDArgsForCall(i int) (context.Context, string, string) { | |
fake.findByFileIDAndSignerUIDMutex.RLock() | |
defer fake.findByFileIDAndSignerUIDMutex.RUnlock() | |
argsForCall := fake.findByFileIDAndSignerUIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) FindByFileIDAndSignerUIDReturns(result1 *model.SignatureRequest, result2 error) { | |
fake.findByFileIDAndSignerUIDMutex.Lock() | |
defer fake.findByFileIDAndSignerUIDMutex.Unlock() | |
fake.FindByFileIDAndSignerUIDStub = nil | |
fake.findByFileIDAndSignerUIDReturns = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByFileIDAndSignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) { | |
fake.findByFileIDAndSignerUIDMutex.Lock() | |
defer fake.findByFileIDAndSignerUIDMutex.Unlock() | |
fake.FindByFileIDAndSignerUIDStub = nil | |
if fake.findByFileIDAndSignerUIDReturnsOnCall == nil { | |
fake.findByFileIDAndSignerUIDReturnsOnCall = make(map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByFileIDAndSignerUIDReturnsOnCall[i] = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByFileIDsAndSigner(arg1 context.Context, arg2 []string, arg3 *model.User, arg4 bool, arg5 bool) ([]model.SignatureRequest, error) { | |
var arg2Copy []string | |
if arg2 != nil { | |
arg2Copy = make([]string, len(arg2)) | |
copy(arg2Copy, arg2) | |
} | |
fake.findByFileIDsAndSignerMutex.Lock() | |
ret, specificReturn := fake.findByFileIDsAndSignerReturnsOnCall[len(fake.findByFileIDsAndSignerArgsForCall)] | |
fake.findByFileIDsAndSignerArgsForCall = append(fake.findByFileIDsAndSignerArgsForCall, struct { | |
arg1 context.Context | |
arg2 []string | |
arg3 *model.User | |
arg4 bool | |
arg5 bool | |
}{arg1, arg2Copy, arg3, arg4, arg5}) | |
stub := fake.FindByFileIDsAndSignerStub | |
fakeReturns := fake.findByFileIDsAndSignerReturns | |
fake.recordInvocation("FindByFileIDsAndSigner", []interface{}{arg1, arg2Copy, arg3, arg4, arg5}) | |
fake.findByFileIDsAndSignerMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3, arg4, arg5) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByFileIDsAndSignerCallCount() int { | |
fake.findByFileIDsAndSignerMutex.RLock() | |
defer fake.findByFileIDsAndSignerMutex.RUnlock() | |
return len(fake.findByFileIDsAndSignerArgsForCall) | |
} | |
func (fake *FakeRepository) FindByFileIDsAndSignerCalls(stub func(context.Context, []string, *model.User, bool, bool) ([]model.SignatureRequest, error)) { | |
fake.findByFileIDsAndSignerMutex.Lock() | |
defer fake.findByFileIDsAndSignerMutex.Unlock() | |
fake.FindByFileIDsAndSignerStub = stub | |
} | |
func (fake *FakeRepository) FindByFileIDsAndSignerArgsForCall(i int) (context.Context, []string, *model.User, bool, bool) { | |
fake.findByFileIDsAndSignerMutex.RLock() | |
defer fake.findByFileIDsAndSignerMutex.RUnlock() | |
argsForCall := fake.findByFileIDsAndSignerArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 | |
} | |
func (fake *FakeRepository) FindByFileIDsAndSignerReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findByFileIDsAndSignerMutex.Lock() | |
defer fake.findByFileIDsAndSignerMutex.Unlock() | |
fake.FindByFileIDsAndSignerStub = nil | |
fake.findByFileIDsAndSignerReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByFileIDsAndSignerReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findByFileIDsAndSignerMutex.Lock() | |
defer fake.findByFileIDsAndSignerMutex.Unlock() | |
fake.FindByFileIDsAndSignerStub = nil | |
if fake.findByFileIDsAndSignerReturnsOnCall == nil { | |
fake.findByFileIDsAndSignerReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByFileIDsAndSignerReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByHashedSignerToken(arg1 context.Context, arg2 string) (*model.SignatureRequest, error) { | |
fake.findByHashedSignerTokenMutex.Lock() | |
ret, specificReturn := fake.findByHashedSignerTokenReturnsOnCall[len(fake.findByHashedSignerTokenArgsForCall)] | |
fake.findByHashedSignerTokenArgsForCall = append(fake.findByHashedSignerTokenArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindByHashedSignerTokenStub | |
fakeReturns := fake.findByHashedSignerTokenReturns | |
fake.recordInvocation("FindByHashedSignerToken", []interface{}{arg1, arg2}) | |
fake.findByHashedSignerTokenMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByHashedSignerTokenCallCount() int { | |
fake.findByHashedSignerTokenMutex.RLock() | |
defer fake.findByHashedSignerTokenMutex.RUnlock() | |
return len(fake.findByHashedSignerTokenArgsForCall) | |
} | |
func (fake *FakeRepository) FindByHashedSignerTokenCalls(stub func(context.Context, string) (*model.SignatureRequest, error)) { | |
fake.findByHashedSignerTokenMutex.Lock() | |
defer fake.findByHashedSignerTokenMutex.Unlock() | |
fake.FindByHashedSignerTokenStub = stub | |
} | |
func (fake *FakeRepository) FindByHashedSignerTokenArgsForCall(i int) (context.Context, string) { | |
fake.findByHashedSignerTokenMutex.RLock() | |
defer fake.findByHashedSignerTokenMutex.RUnlock() | |
argsForCall := fake.findByHashedSignerTokenArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindByHashedSignerTokenReturns(result1 *model.SignatureRequest, result2 error) { | |
fake.findByHashedSignerTokenMutex.Lock() | |
defer fake.findByHashedSignerTokenMutex.Unlock() | |
fake.FindByHashedSignerTokenStub = nil | |
fake.findByHashedSignerTokenReturns = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByHashedSignerTokenReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) { | |
fake.findByHashedSignerTokenMutex.Lock() | |
defer fake.findByHashedSignerTokenMutex.Unlock() | |
fake.FindByHashedSignerTokenStub = nil | |
if fake.findByHashedSignerTokenReturnsOnCall == nil { | |
fake.findByHashedSignerTokenReturnsOnCall = make(map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByHashedSignerTokenReturnsOnCall[i] = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByID(arg1 context.Context, arg2 string) (*model.SignatureRequest, error) { | |
fake.findByIDMutex.Lock() | |
ret, specificReturn := fake.findByIDReturnsOnCall[len(fake.findByIDArgsForCall)] | |
fake.findByIDArgsForCall = append(fake.findByIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindByIDStub | |
fakeReturns := fake.findByIDReturns | |
fake.recordInvocation("FindByID", []interface{}{arg1, arg2}) | |
fake.findByIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByIDCallCount() int { | |
fake.findByIDMutex.RLock() | |
defer fake.findByIDMutex.RUnlock() | |
return len(fake.findByIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindByIDCalls(stub func(context.Context, string) (*model.SignatureRequest, error)) { | |
fake.findByIDMutex.Lock() | |
defer fake.findByIDMutex.Unlock() | |
fake.FindByIDStub = stub | |
} | |
func (fake *FakeRepository) FindByIDArgsForCall(i int) (context.Context, string) { | |
fake.findByIDMutex.RLock() | |
defer fake.findByIDMutex.RUnlock() | |
argsForCall := fake.findByIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindByIDReturns(result1 *model.SignatureRequest, result2 error) { | |
fake.findByIDMutex.Lock() | |
defer fake.findByIDMutex.Unlock() | |
fake.FindByIDStub = nil | |
fake.findByIDReturns = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) { | |
fake.findByIDMutex.Lock() | |
defer fake.findByIDMutex.Unlock() | |
fake.FindByIDStub = nil | |
if fake.findByIDReturnsOnCall == nil { | |
fake.findByIDReturnsOnCall = make(map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByIDReturnsOnCall[i] = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByIDForSignerUID(arg1 context.Context, arg2 string, arg3 string) (*model.SignatureRequest, error) { | |
fake.findByIDForSignerUIDMutex.Lock() | |
ret, specificReturn := fake.findByIDForSignerUIDReturnsOnCall[len(fake.findByIDForSignerUIDArgsForCall)] | |
fake.findByIDForSignerUIDArgsForCall = append(fake.findByIDForSignerUIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
}{arg1, arg2, arg3}) | |
stub := fake.FindByIDForSignerUIDStub | |
fakeReturns := fake.findByIDForSignerUIDReturns | |
fake.recordInvocation("FindByIDForSignerUID", []interface{}{arg1, arg2, arg3}) | |
fake.findByIDForSignerUIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByIDForSignerUIDCallCount() int { | |
fake.findByIDForSignerUIDMutex.RLock() | |
defer fake.findByIDForSignerUIDMutex.RUnlock() | |
return len(fake.findByIDForSignerUIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindByIDForSignerUIDCalls(stub func(context.Context, string, string) (*model.SignatureRequest, error)) { | |
fake.findByIDForSignerUIDMutex.Lock() | |
defer fake.findByIDForSignerUIDMutex.Unlock() | |
fake.FindByIDForSignerUIDStub = stub | |
} | |
func (fake *FakeRepository) FindByIDForSignerUIDArgsForCall(i int) (context.Context, string, string) { | |
fake.findByIDForSignerUIDMutex.RLock() | |
defer fake.findByIDForSignerUIDMutex.RUnlock() | |
argsForCall := fake.findByIDForSignerUIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) FindByIDForSignerUIDReturns(result1 *model.SignatureRequest, result2 error) { | |
fake.findByIDForSignerUIDMutex.Lock() | |
defer fake.findByIDForSignerUIDMutex.Unlock() | |
fake.FindByIDForSignerUIDStub = nil | |
fake.findByIDForSignerUIDReturns = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByIDForSignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) { | |
fake.findByIDForSignerUIDMutex.Lock() | |
defer fake.findByIDForSignerUIDMutex.Unlock() | |
fake.FindByIDForSignerUIDStub = nil | |
if fake.findByIDForSignerUIDReturnsOnCall == nil { | |
fake.findByIDForSignerUIDReturnsOnCall = make(map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByIDForSignerUIDReturnsOnCall[i] = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByProcessID(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) { | |
fake.findByProcessIDMutex.Lock() | |
ret, specificReturn := fake.findByProcessIDReturnsOnCall[len(fake.findByProcessIDArgsForCall)] | |
fake.findByProcessIDArgsForCall = append(fake.findByProcessIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindByProcessIDStub | |
fakeReturns := fake.findByProcessIDReturns | |
fake.recordInvocation("FindByProcessID", []interface{}{arg1, arg2}) | |
fake.findByProcessIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByProcessIDCallCount() int { | |
fake.findByProcessIDMutex.RLock() | |
defer fake.findByProcessIDMutex.RUnlock() | |
return len(fake.findByProcessIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindByProcessIDCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) { | |
fake.findByProcessIDMutex.Lock() | |
defer fake.findByProcessIDMutex.Unlock() | |
fake.FindByProcessIDStub = stub | |
} | |
func (fake *FakeRepository) FindByProcessIDArgsForCall(i int) (context.Context, string) { | |
fake.findByProcessIDMutex.RLock() | |
defer fake.findByProcessIDMutex.RUnlock() | |
argsForCall := fake.findByProcessIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindByProcessIDReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findByProcessIDMutex.Lock() | |
defer fake.findByProcessIDMutex.Unlock() | |
fake.FindByProcessIDStub = nil | |
fake.findByProcessIDReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByProcessIDReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findByProcessIDMutex.Lock() | |
defer fake.findByProcessIDMutex.Unlock() | |
fake.FindByProcessIDStub = nil | |
if fake.findByProcessIDReturnsOnCall == nil { | |
fake.findByProcessIDReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByProcessIDReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdate(arg1 context.Context, arg2 string, arg3 time.Time, arg4 int) ([]model.SignatureRequest, error) { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock() | |
ret, specificReturn := fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall[len(fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall)] | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall = append(fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 time.Time | |
arg4 int | |
}{arg1, arg2, arg3, arg4}) | |
stub := fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub | |
fakeReturns := fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturns | |
fake.recordInvocation("FindByRequestorCreatedBeforeNotAnonymizedForUpdate", []interface{}{arg1, arg2, arg3, arg4}) | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3, arg4) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateCallCount() int { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RLock() | |
defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RUnlock() | |
return len(fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall) | |
} | |
func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateCalls(stub func(context.Context, string, time.Time, int) ([]model.SignatureRequest, error)) { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock() | |
defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock() | |
fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub = stub | |
} | |
func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall(i int) (context.Context, string, time.Time, int) { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RLock() | |
defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RUnlock() | |
argsForCall := fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 | |
} | |
func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock() | |
defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock() | |
fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub = nil | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock() | |
defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock() | |
fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub = nil | |
if fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall == nil { | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindBySignerUID(arg1 context.Context, arg2 string) (*model.SignatureRequest, error) { | |
fake.findBySignerUIDMutex.Lock() | |
ret, specificReturn := fake.findBySignerUIDReturnsOnCall[len(fake.findBySignerUIDArgsForCall)] | |
fake.findBySignerUIDArgsForCall = append(fake.findBySignerUIDArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindBySignerUIDStub | |
fakeReturns := fake.findBySignerUIDReturns | |
fake.recordInvocation("FindBySignerUID", []interface{}{arg1, arg2}) | |
fake.findBySignerUIDMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindBySignerUIDCallCount() int { | |
fake.findBySignerUIDMutex.RLock() | |
defer fake.findBySignerUIDMutex.RUnlock() | |
return len(fake.findBySignerUIDArgsForCall) | |
} | |
func (fake *FakeRepository) FindBySignerUIDCalls(stub func(context.Context, string) (*model.SignatureRequest, error)) { | |
fake.findBySignerUIDMutex.Lock() | |
defer fake.findBySignerUIDMutex.Unlock() | |
fake.FindBySignerUIDStub = stub | |
} | |
func (fake *FakeRepository) FindBySignerUIDArgsForCall(i int) (context.Context, string) { | |
fake.findBySignerUIDMutex.RLock() | |
defer fake.findBySignerUIDMutex.RUnlock() | |
argsForCall := fake.findBySignerUIDArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindBySignerUIDReturns(result1 *model.SignatureRequest, result2 error) { | |
fake.findBySignerUIDMutex.Lock() | |
defer fake.findBySignerUIDMutex.Unlock() | |
fake.FindBySignerUIDStub = nil | |
fake.findBySignerUIDReturns = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindBySignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) { | |
fake.findBySignerUIDMutex.Lock() | |
defer fake.findBySignerUIDMutex.Unlock() | |
fake.FindBySignerUIDStub = nil | |
if fake.findBySignerUIDReturnsOnCall == nil { | |
fake.findBySignerUIDReturnsOnCall = make(map[int]struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findBySignerUIDReturnsOnCall[i] = struct { | |
result1 *model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindBySignerWithNameOrEmailLike(arg1 context.Context, arg2 string, arg3 string) ([]model.SignatureRequest, error) { | |
fake.findBySignerWithNameOrEmailLikeMutex.Lock() | |
ret, specificReturn := fake.findBySignerWithNameOrEmailLikeReturnsOnCall[len(fake.findBySignerWithNameOrEmailLikeArgsForCall)] | |
fake.findBySignerWithNameOrEmailLikeArgsForCall = append(fake.findBySignerWithNameOrEmailLikeArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
arg3 string | |
}{arg1, arg2, arg3}) | |
stub := fake.FindBySignerWithNameOrEmailLikeStub | |
fakeReturns := fake.findBySignerWithNameOrEmailLikeReturns | |
fake.recordInvocation("FindBySignerWithNameOrEmailLike", []interface{}{arg1, arg2, arg3}) | |
fake.findBySignerWithNameOrEmailLikeMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeCallCount() int { | |
fake.findBySignerWithNameOrEmailLikeMutex.RLock() | |
defer fake.findBySignerWithNameOrEmailLikeMutex.RUnlock() | |
return len(fake.findBySignerWithNameOrEmailLikeArgsForCall) | |
} | |
func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeCalls(stub func(context.Context, string, string) ([]model.SignatureRequest, error)) { | |
fake.findBySignerWithNameOrEmailLikeMutex.Lock() | |
defer fake.findBySignerWithNameOrEmailLikeMutex.Unlock() | |
fake.FindBySignerWithNameOrEmailLikeStub = stub | |
} | |
func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeArgsForCall(i int) (context.Context, string, string) { | |
fake.findBySignerWithNameOrEmailLikeMutex.RLock() | |
defer fake.findBySignerWithNameOrEmailLikeMutex.RUnlock() | |
argsForCall := fake.findBySignerWithNameOrEmailLikeArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findBySignerWithNameOrEmailLikeMutex.Lock() | |
defer fake.findBySignerWithNameOrEmailLikeMutex.Unlock() | |
fake.FindBySignerWithNameOrEmailLikeStub = nil | |
fake.findBySignerWithNameOrEmailLikeReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findBySignerWithNameOrEmailLikeMutex.Lock() | |
defer fake.findBySignerWithNameOrEmailLikeMutex.Unlock() | |
fake.FindBySignerWithNameOrEmailLikeStub = nil | |
if fake.findBySignerWithNameOrEmailLikeReturnsOnCall == nil { | |
fake.findBySignerWithNameOrEmailLikeReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findBySignerWithNameOrEmailLikeReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindCompletedForOrganization(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) { | |
fake.findCompletedForOrganizationMutex.Lock() | |
ret, specificReturn := fake.findCompletedForOrganizationReturnsOnCall[len(fake.findCompletedForOrganizationArgsForCall)] | |
fake.findCompletedForOrganizationArgsForCall = append(fake.findCompletedForOrganizationArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindCompletedForOrganizationStub | |
fakeReturns := fake.findCompletedForOrganizationReturns | |
fake.recordInvocation("FindCompletedForOrganization", []interface{}{arg1, arg2}) | |
fake.findCompletedForOrganizationMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindCompletedForOrganizationCallCount() int { | |
fake.findCompletedForOrganizationMutex.RLock() | |
defer fake.findCompletedForOrganizationMutex.RUnlock() | |
return len(fake.findCompletedForOrganizationArgsForCall) | |
} | |
func (fake *FakeRepository) FindCompletedForOrganizationCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) { | |
fake.findCompletedForOrganizationMutex.Lock() | |
defer fake.findCompletedForOrganizationMutex.Unlock() | |
fake.FindCompletedForOrganizationStub = stub | |
} | |
func (fake *FakeRepository) FindCompletedForOrganizationArgsForCall(i int) (context.Context, string) { | |
fake.findCompletedForOrganizationMutex.RLock() | |
defer fake.findCompletedForOrganizationMutex.RUnlock() | |
argsForCall := fake.findCompletedForOrganizationArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindCompletedForOrganizationReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findCompletedForOrganizationMutex.Lock() | |
defer fake.findCompletedForOrganizationMutex.Unlock() | |
fake.FindCompletedForOrganizationStub = nil | |
fake.findCompletedForOrganizationReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindCompletedForOrganizationReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findCompletedForOrganizationMutex.Lock() | |
defer fake.findCompletedForOrganizationMutex.Unlock() | |
fake.FindCompletedForOrganizationStub = nil | |
if fake.findCompletedForOrganizationReturnsOnCall == nil { | |
fake.findCompletedForOrganizationReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findCompletedForOrganizationReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindExpiredBefore(arg1 context.Context, arg2 time.Time) ([]model.SignatureRequest, error) { | |
fake.findExpiredBeforeMutex.Lock() | |
ret, specificReturn := fake.findExpiredBeforeReturnsOnCall[len(fake.findExpiredBeforeArgsForCall)] | |
fake.findExpiredBeforeArgsForCall = append(fake.findExpiredBeforeArgsForCall, struct { | |
arg1 context.Context | |
arg2 time.Time | |
}{arg1, arg2}) | |
stub := fake.FindExpiredBeforeStub | |
fakeReturns := fake.findExpiredBeforeReturns | |
fake.recordInvocation("FindExpiredBefore", []interface{}{arg1, arg2}) | |
fake.findExpiredBeforeMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindExpiredBeforeCallCount() int { | |
fake.findExpiredBeforeMutex.RLock() | |
defer fake.findExpiredBeforeMutex.RUnlock() | |
return len(fake.findExpiredBeforeArgsForCall) | |
} | |
func (fake *FakeRepository) FindExpiredBeforeCalls(stub func(context.Context, time.Time) ([]model.SignatureRequest, error)) { | |
fake.findExpiredBeforeMutex.Lock() | |
defer fake.findExpiredBeforeMutex.Unlock() | |
fake.FindExpiredBeforeStub = stub | |
} | |
func (fake *FakeRepository) FindExpiredBeforeArgsForCall(i int) (context.Context, time.Time) { | |
fake.findExpiredBeforeMutex.RLock() | |
defer fake.findExpiredBeforeMutex.RUnlock() | |
argsForCall := fake.findExpiredBeforeArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindExpiredBeforeReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findExpiredBeforeMutex.Lock() | |
defer fake.findExpiredBeforeMutex.Unlock() | |
fake.FindExpiredBeforeStub = nil | |
fake.findExpiredBeforeReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindExpiredBeforeReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findExpiredBeforeMutex.Lock() | |
defer fake.findExpiredBeforeMutex.Unlock() | |
fake.FindExpiredBeforeStub = nil | |
if fake.findExpiredBeforeReturnsOnCall == nil { | |
fake.findExpiredBeforeReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findExpiredBeforeReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindExpiredByFileId(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) { | |
fake.findExpiredByFileIdMutex.Lock() | |
ret, specificReturn := fake.findExpiredByFileIdReturnsOnCall[len(fake.findExpiredByFileIdArgsForCall)] | |
fake.findExpiredByFileIdArgsForCall = append(fake.findExpiredByFileIdArgsForCall, struct { | |
arg1 context.Context | |
arg2 string | |
}{arg1, arg2}) | |
stub := fake.FindExpiredByFileIdStub | |
fakeReturns := fake.findExpiredByFileIdReturns | |
fake.recordInvocation("FindExpiredByFileId", []interface{}{arg1, arg2}) | |
fake.findExpiredByFileIdMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindExpiredByFileIdCallCount() int { | |
fake.findExpiredByFileIdMutex.RLock() | |
defer fake.findExpiredByFileIdMutex.RUnlock() | |
return len(fake.findExpiredByFileIdArgsForCall) | |
} | |
func (fake *FakeRepository) FindExpiredByFileIdCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) { | |
fake.findExpiredByFileIdMutex.Lock() | |
defer fake.findExpiredByFileIdMutex.Unlock() | |
fake.FindExpiredByFileIdStub = stub | |
} | |
func (fake *FakeRepository) FindExpiredByFileIdArgsForCall(i int) (context.Context, string) { | |
fake.findExpiredByFileIdMutex.RLock() | |
defer fake.findExpiredByFileIdMutex.RUnlock() | |
argsForCall := fake.findExpiredByFileIdArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) FindExpiredByFileIdReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findExpiredByFileIdMutex.Lock() | |
defer fake.findExpiredByFileIdMutex.Unlock() | |
fake.FindExpiredByFileIdStub = nil | |
fake.findExpiredByFileIdReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindExpiredByFileIdReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findExpiredByFileIdMutex.Lock() | |
defer fake.findExpiredByFileIdMutex.Unlock() | |
fake.FindExpiredByFileIdStub = nil | |
if fake.findExpiredByFileIdReturnsOnCall == nil { | |
fake.findExpiredByFileIdReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findExpiredByFileIdReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelled(arg1 context.Context, arg2 time.Time, arg3 int) ([]model.SignatureRequest, error) { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock() | |
ret, specificReturn := fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall[len(fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall)] | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall = append(fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall, struct { | |
arg1 context.Context | |
arg2 time.Time | |
arg3 int | |
}{arg1, arg2, arg3}) | |
stub := fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub | |
fakeReturns := fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns | |
fake.recordInvocation("FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelled", []interface{}{arg1, arg2, arg3}) | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2, arg3) | |
} | |
if specificReturn { | |
return ret.result1, ret.result2 | |
} | |
return fakeReturns.result1, fakeReturns.result2 | |
} | |
func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledCallCount() int { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RLock() | |
defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RUnlock() | |
return len(fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall) | |
} | |
func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledCalls(stub func(context.Context, time.Time, int) ([]model.SignatureRequest, error)) { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock() | |
defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock() | |
fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub = stub | |
} | |
func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall(i int) (context.Context, time.Time, int) { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RLock() | |
defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RUnlock() | |
argsForCall := fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 | |
} | |
func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns(result1 []model.SignatureRequest, result2 error) { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock() | |
defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock() | |
fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub = nil | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock() | |
defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock() | |
fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub = nil | |
if fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall == nil { | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall = make(map[int]struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}) | |
} | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall[i] = struct { | |
result1 []model.SignatureRequest | |
result2 error | |
}{result1, result2} | |
} | |
func (fake *FakeRepository) Update(arg1 context.Context, arg2 *model.SignatureRequest) error { | |
fake.updateMutex.Lock() | |
ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] | |
fake.updateArgsForCall = append(fake.updateArgsForCall, struct { | |
arg1 context.Context | |
arg2 *model.SignatureRequest | |
}{arg1, arg2}) | |
stub := fake.UpdateStub | |
fakeReturns := fake.updateReturns | |
fake.recordInvocation("Update", []interface{}{arg1, arg2}) | |
fake.updateMutex.Unlock() | |
if stub != nil { | |
return stub(arg1, arg2) | |
} | |
if specificReturn { | |
return ret.result1 | |
} | |
return fakeReturns.result1 | |
} | |
func (fake *FakeRepository) UpdateCallCount() int { | |
fake.updateMutex.RLock() | |
defer fake.updateMutex.RUnlock() | |
return len(fake.updateArgsForCall) | |
} | |
func (fake *FakeRepository) UpdateCalls(stub func(context.Context, *model.SignatureRequest) error) { | |
fake.updateMutex.Lock() | |
defer fake.updateMutex.Unlock() | |
fake.UpdateStub = stub | |
} | |
func (fake *FakeRepository) UpdateArgsForCall(i int) (context.Context, *model.SignatureRequest) { | |
fake.updateMutex.RLock() | |
defer fake.updateMutex.RUnlock() | |
argsForCall := fake.updateArgsForCall[i] | |
return argsForCall.arg1, argsForCall.arg2 | |
} | |
func (fake *FakeRepository) UpdateReturns(result1 error) { | |
fake.updateMutex.Lock() | |
defer fake.updateMutex.Unlock() | |
fake.UpdateStub = nil | |
fake.updateReturns = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) UpdateReturnsOnCall(i int, result1 error) { | |
fake.updateMutex.Lock() | |
defer fake.updateMutex.Unlock() | |
fake.UpdateStub = nil | |
if fake.updateReturnsOnCall == nil { | |
fake.updateReturnsOnCall = make(map[int]struct { | |
result1 error | |
}) | |
} | |
fake.updateReturnsOnCall[i] = struct { | |
result1 error | |
}{result1} | |
} | |
func (fake *FakeRepository) Invocations() map[string][][]interface{} { | |
fake.invocationsMutex.RLock() | |
defer fake.invocationsMutex.RUnlock() | |
fake.createMutex.RLock() | |
defer fake.createMutex.RUnlock() | |
fake.createTokenMutex.RLock() | |
defer fake.createTokenMutex.RUnlock() | |
fake.deleteAccessByFileIDMutex.RLock() | |
defer fake.deleteAccessByFileIDMutex.RUnlock() | |
fake.deleteByFileIDAndSignerUIDMutex.RLock() | |
defer fake.deleteByFileIDAndSignerUIDMutex.RUnlock() | |
fake.deleteByIDMutex.RLock() | |
defer fake.deleteByIDMutex.RUnlock() | |
fake.deleteTokensMutex.RLock() | |
defer fake.deleteTokensMutex.RUnlock() | |
fake.findActiveForOrganizationMutex.RLock() | |
defer fake.findActiveForOrganizationMutex.RUnlock() | |
fake.findAllForOrganizationMutex.RLock() | |
defer fake.findAllForOrganizationMutex.RUnlock() | |
fake.findAllForSignerMutex.RLock() | |
defer fake.findAllForSignerMutex.RUnlock() | |
fake.findByDocumentIDAndSignerUIDMutex.RLock() | |
defer fake.findByDocumentIDAndSignerUIDMutex.RUnlock() | |
fake.findByFileIDMutex.RLock() | |
defer fake.findByFileIDMutex.RUnlock() | |
fake.findByFileIDAndSignerUIDMutex.RLock() | |
defer fake.findByFileIDAndSignerUIDMutex.RUnlock() | |
fake.findByFileIDsAndSignerMutex.RLock() | |
defer fake.findByFileIDsAndSignerMutex.RUnlock() | |
fake.findByHashedSignerTokenMutex.RLock() | |
defer fake.findByHashedSignerTokenMutex.RUnlock() | |
fake.findByIDMutex.RLock() | |
defer fake.findByIDMutex.RUnlock() | |
fake.findByIDForSignerUIDMutex.RLock() | |
defer fake.findByIDForSignerUIDMutex.RUnlock() | |
fake.findByProcessIDMutex.RLock() | |
defer fake.findByProcessIDMutex.RUnlock() | |
fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RLock() | |
defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RUnlock() | |
fake.findBySignerUIDMutex.RLock() | |
defer fake.findBySignerUIDMutex.RUnlock() | |
fake.findBySignerWithNameOrEmailLikeMutex.RLock() | |
defer fake.findBySignerWithNameOrEmailLikeMutex.RUnlock() | |
fake.findCompletedForOrganizationMutex.RLock() | |
defer fake.findCompletedForOrganizationMutex.RUnlock() | |
fake.findExpiredBeforeMutex.RLock() | |
defer fake.findExpiredBeforeMutex.RUnlock() | |
fake.findExpiredByFileIdMutex.RLock() | |
defer fake.findExpiredByFileIdMutex.RUnlock() | |
fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RLock() | |
defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RUnlock() | |
fake.updateMutex.RLock() | |
defer fake.updateMutex.RUnlock() | |
copiedInvocations := map[string][][]interface{}{} | |
for key, value := range fake.invocations { | |
copiedInvocations[key] = value | |
} | |
return copiedInvocations | |
} | |
func (fake *FakeRepository) recordInvocation(key string, args []interface{}) { | |
fake.invocationsMutex.Lock() | |
defer fake.invocationsMutex.Unlock() | |
if fake.invocations == nil { | |
fake.invocations = map[string][][]interface{}{} | |
} | |
if fake.invocations[key] == nil { | |
fake.invocations[key] = [][]interface{}{} | |
} | |
fake.invocations[key] = append(fake.invocations[key], args) | |
} | |
var _ repository.Repository = new(FakeRepository) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment