649 lines
18 KiB
Go
649 lines
18 KiB
Go
// Code generated by counterfeiter. DO NOT EDIT.
|
|
package mocks
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
|
|
mspa "github.com/hyperledger/fabric-protos-go/msp"
|
|
"github.com/hyperledger/fabric/msp"
|
|
)
|
|
|
|
type Identity struct {
|
|
AnonymousStub func() bool
|
|
anonymousMutex sync.RWMutex
|
|
anonymousArgsForCall []struct {
|
|
}
|
|
anonymousReturns struct {
|
|
result1 bool
|
|
}
|
|
anonymousReturnsOnCall map[int]struct {
|
|
result1 bool
|
|
}
|
|
ExpiresAtStub func() time.Time
|
|
expiresAtMutex sync.RWMutex
|
|
expiresAtArgsForCall []struct {
|
|
}
|
|
expiresAtReturns struct {
|
|
result1 time.Time
|
|
}
|
|
expiresAtReturnsOnCall map[int]struct {
|
|
result1 time.Time
|
|
}
|
|
GetIdentifierStub func() *msp.IdentityIdentifier
|
|
getIdentifierMutex sync.RWMutex
|
|
getIdentifierArgsForCall []struct {
|
|
}
|
|
getIdentifierReturns struct {
|
|
result1 *msp.IdentityIdentifier
|
|
}
|
|
getIdentifierReturnsOnCall map[int]struct {
|
|
result1 *msp.IdentityIdentifier
|
|
}
|
|
GetMSPIdentifierStub func() string
|
|
getMSPIdentifierMutex sync.RWMutex
|
|
getMSPIdentifierArgsForCall []struct {
|
|
}
|
|
getMSPIdentifierReturns struct {
|
|
result1 string
|
|
}
|
|
getMSPIdentifierReturnsOnCall map[int]struct {
|
|
result1 string
|
|
}
|
|
GetOrganizationalUnitsStub func() []*msp.OUIdentifier
|
|
getOrganizationalUnitsMutex sync.RWMutex
|
|
getOrganizationalUnitsArgsForCall []struct {
|
|
}
|
|
getOrganizationalUnitsReturns struct {
|
|
result1 []*msp.OUIdentifier
|
|
}
|
|
getOrganizationalUnitsReturnsOnCall map[int]struct {
|
|
result1 []*msp.OUIdentifier
|
|
}
|
|
SatisfiesPrincipalStub func(*mspa.MSPPrincipal) error
|
|
satisfiesPrincipalMutex sync.RWMutex
|
|
satisfiesPrincipalArgsForCall []struct {
|
|
arg1 *mspa.MSPPrincipal
|
|
}
|
|
satisfiesPrincipalReturns struct {
|
|
result1 error
|
|
}
|
|
satisfiesPrincipalReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
SerializeStub func() ([]byte, error)
|
|
serializeMutex sync.RWMutex
|
|
serializeArgsForCall []struct {
|
|
}
|
|
serializeReturns struct {
|
|
result1 []byte
|
|
result2 error
|
|
}
|
|
serializeReturnsOnCall map[int]struct {
|
|
result1 []byte
|
|
result2 error
|
|
}
|
|
ValidateStub func() error
|
|
validateMutex sync.RWMutex
|
|
validateArgsForCall []struct {
|
|
}
|
|
validateReturns struct {
|
|
result1 error
|
|
}
|
|
validateReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
VerifyStub func([]byte, []byte) error
|
|
verifyMutex sync.RWMutex
|
|
verifyArgsForCall []struct {
|
|
arg1 []byte
|
|
arg2 []byte
|
|
}
|
|
verifyReturns struct {
|
|
result1 error
|
|
}
|
|
verifyReturnsOnCall map[int]struct {
|
|
result1 error
|
|
}
|
|
invocations map[string][][]interface{}
|
|
invocationsMutex sync.RWMutex
|
|
}
|
|
|
|
func (fake *Identity) Anonymous() bool {
|
|
fake.anonymousMutex.Lock()
|
|
ret, specificReturn := fake.anonymousReturnsOnCall[len(fake.anonymousArgsForCall)]
|
|
fake.anonymousArgsForCall = append(fake.anonymousArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("Anonymous", []interface{}{})
|
|
fake.anonymousMutex.Unlock()
|
|
if fake.AnonymousStub != nil {
|
|
return fake.AnonymousStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.anonymousReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) AnonymousCallCount() int {
|
|
fake.anonymousMutex.RLock()
|
|
defer fake.anonymousMutex.RUnlock()
|
|
return len(fake.anonymousArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) AnonymousCalls(stub func() bool) {
|
|
fake.anonymousMutex.Lock()
|
|
defer fake.anonymousMutex.Unlock()
|
|
fake.AnonymousStub = stub
|
|
}
|
|
|
|
func (fake *Identity) AnonymousReturns(result1 bool) {
|
|
fake.anonymousMutex.Lock()
|
|
defer fake.anonymousMutex.Unlock()
|
|
fake.AnonymousStub = nil
|
|
fake.anonymousReturns = struct {
|
|
result1 bool
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) AnonymousReturnsOnCall(i int, result1 bool) {
|
|
fake.anonymousMutex.Lock()
|
|
defer fake.anonymousMutex.Unlock()
|
|
fake.AnonymousStub = nil
|
|
if fake.anonymousReturnsOnCall == nil {
|
|
fake.anonymousReturnsOnCall = make(map[int]struct {
|
|
result1 bool
|
|
})
|
|
}
|
|
fake.anonymousReturnsOnCall[i] = struct {
|
|
result1 bool
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) ExpiresAt() time.Time {
|
|
fake.expiresAtMutex.Lock()
|
|
ret, specificReturn := fake.expiresAtReturnsOnCall[len(fake.expiresAtArgsForCall)]
|
|
fake.expiresAtArgsForCall = append(fake.expiresAtArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("ExpiresAt", []interface{}{})
|
|
fake.expiresAtMutex.Unlock()
|
|
if fake.ExpiresAtStub != nil {
|
|
return fake.ExpiresAtStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.expiresAtReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) ExpiresAtCallCount() int {
|
|
fake.expiresAtMutex.RLock()
|
|
defer fake.expiresAtMutex.RUnlock()
|
|
return len(fake.expiresAtArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) ExpiresAtCalls(stub func() time.Time) {
|
|
fake.expiresAtMutex.Lock()
|
|
defer fake.expiresAtMutex.Unlock()
|
|
fake.ExpiresAtStub = stub
|
|
}
|
|
|
|
func (fake *Identity) ExpiresAtReturns(result1 time.Time) {
|
|
fake.expiresAtMutex.Lock()
|
|
defer fake.expiresAtMutex.Unlock()
|
|
fake.ExpiresAtStub = nil
|
|
fake.expiresAtReturns = struct {
|
|
result1 time.Time
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) ExpiresAtReturnsOnCall(i int, result1 time.Time) {
|
|
fake.expiresAtMutex.Lock()
|
|
defer fake.expiresAtMutex.Unlock()
|
|
fake.ExpiresAtStub = nil
|
|
if fake.expiresAtReturnsOnCall == nil {
|
|
fake.expiresAtReturnsOnCall = make(map[int]struct {
|
|
result1 time.Time
|
|
})
|
|
}
|
|
fake.expiresAtReturnsOnCall[i] = struct {
|
|
result1 time.Time
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) GetIdentifier() *msp.IdentityIdentifier {
|
|
fake.getIdentifierMutex.Lock()
|
|
ret, specificReturn := fake.getIdentifierReturnsOnCall[len(fake.getIdentifierArgsForCall)]
|
|
fake.getIdentifierArgsForCall = append(fake.getIdentifierArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("GetIdentifier", []interface{}{})
|
|
fake.getIdentifierMutex.Unlock()
|
|
if fake.GetIdentifierStub != nil {
|
|
return fake.GetIdentifierStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.getIdentifierReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) GetIdentifierCallCount() int {
|
|
fake.getIdentifierMutex.RLock()
|
|
defer fake.getIdentifierMutex.RUnlock()
|
|
return len(fake.getIdentifierArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) GetIdentifierCalls(stub func() *msp.IdentityIdentifier) {
|
|
fake.getIdentifierMutex.Lock()
|
|
defer fake.getIdentifierMutex.Unlock()
|
|
fake.GetIdentifierStub = stub
|
|
}
|
|
|
|
func (fake *Identity) GetIdentifierReturns(result1 *msp.IdentityIdentifier) {
|
|
fake.getIdentifierMutex.Lock()
|
|
defer fake.getIdentifierMutex.Unlock()
|
|
fake.GetIdentifierStub = nil
|
|
fake.getIdentifierReturns = struct {
|
|
result1 *msp.IdentityIdentifier
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) GetIdentifierReturnsOnCall(i int, result1 *msp.IdentityIdentifier) {
|
|
fake.getIdentifierMutex.Lock()
|
|
defer fake.getIdentifierMutex.Unlock()
|
|
fake.GetIdentifierStub = nil
|
|
if fake.getIdentifierReturnsOnCall == nil {
|
|
fake.getIdentifierReturnsOnCall = make(map[int]struct {
|
|
result1 *msp.IdentityIdentifier
|
|
})
|
|
}
|
|
fake.getIdentifierReturnsOnCall[i] = struct {
|
|
result1 *msp.IdentityIdentifier
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) GetMSPIdentifier() string {
|
|
fake.getMSPIdentifierMutex.Lock()
|
|
ret, specificReturn := fake.getMSPIdentifierReturnsOnCall[len(fake.getMSPIdentifierArgsForCall)]
|
|
fake.getMSPIdentifierArgsForCall = append(fake.getMSPIdentifierArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("GetMSPIdentifier", []interface{}{})
|
|
fake.getMSPIdentifierMutex.Unlock()
|
|
if fake.GetMSPIdentifierStub != nil {
|
|
return fake.GetMSPIdentifierStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.getMSPIdentifierReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) GetMSPIdentifierCallCount() int {
|
|
fake.getMSPIdentifierMutex.RLock()
|
|
defer fake.getMSPIdentifierMutex.RUnlock()
|
|
return len(fake.getMSPIdentifierArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) GetMSPIdentifierCalls(stub func() string) {
|
|
fake.getMSPIdentifierMutex.Lock()
|
|
defer fake.getMSPIdentifierMutex.Unlock()
|
|
fake.GetMSPIdentifierStub = stub
|
|
}
|
|
|
|
func (fake *Identity) GetMSPIdentifierReturns(result1 string) {
|
|
fake.getMSPIdentifierMutex.Lock()
|
|
defer fake.getMSPIdentifierMutex.Unlock()
|
|
fake.GetMSPIdentifierStub = nil
|
|
fake.getMSPIdentifierReturns = struct {
|
|
result1 string
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) GetMSPIdentifierReturnsOnCall(i int, result1 string) {
|
|
fake.getMSPIdentifierMutex.Lock()
|
|
defer fake.getMSPIdentifierMutex.Unlock()
|
|
fake.GetMSPIdentifierStub = nil
|
|
if fake.getMSPIdentifierReturnsOnCall == nil {
|
|
fake.getMSPIdentifierReturnsOnCall = make(map[int]struct {
|
|
result1 string
|
|
})
|
|
}
|
|
fake.getMSPIdentifierReturnsOnCall[i] = struct {
|
|
result1 string
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) GetOrganizationalUnits() []*msp.OUIdentifier {
|
|
fake.getOrganizationalUnitsMutex.Lock()
|
|
ret, specificReturn := fake.getOrganizationalUnitsReturnsOnCall[len(fake.getOrganizationalUnitsArgsForCall)]
|
|
fake.getOrganizationalUnitsArgsForCall = append(fake.getOrganizationalUnitsArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("GetOrganizationalUnits", []interface{}{})
|
|
fake.getOrganizationalUnitsMutex.Unlock()
|
|
if fake.GetOrganizationalUnitsStub != nil {
|
|
return fake.GetOrganizationalUnitsStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.getOrganizationalUnitsReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) GetOrganizationalUnitsCallCount() int {
|
|
fake.getOrganizationalUnitsMutex.RLock()
|
|
defer fake.getOrganizationalUnitsMutex.RUnlock()
|
|
return len(fake.getOrganizationalUnitsArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) GetOrganizationalUnitsCalls(stub func() []*msp.OUIdentifier) {
|
|
fake.getOrganizationalUnitsMutex.Lock()
|
|
defer fake.getOrganizationalUnitsMutex.Unlock()
|
|
fake.GetOrganizationalUnitsStub = stub
|
|
}
|
|
|
|
func (fake *Identity) GetOrganizationalUnitsReturns(result1 []*msp.OUIdentifier) {
|
|
fake.getOrganizationalUnitsMutex.Lock()
|
|
defer fake.getOrganizationalUnitsMutex.Unlock()
|
|
fake.GetOrganizationalUnitsStub = nil
|
|
fake.getOrganizationalUnitsReturns = struct {
|
|
result1 []*msp.OUIdentifier
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) GetOrganizationalUnitsReturnsOnCall(i int, result1 []*msp.OUIdentifier) {
|
|
fake.getOrganizationalUnitsMutex.Lock()
|
|
defer fake.getOrganizationalUnitsMutex.Unlock()
|
|
fake.GetOrganizationalUnitsStub = nil
|
|
if fake.getOrganizationalUnitsReturnsOnCall == nil {
|
|
fake.getOrganizationalUnitsReturnsOnCall = make(map[int]struct {
|
|
result1 []*msp.OUIdentifier
|
|
})
|
|
}
|
|
fake.getOrganizationalUnitsReturnsOnCall[i] = struct {
|
|
result1 []*msp.OUIdentifier
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) SatisfiesPrincipal(arg1 *mspa.MSPPrincipal) error {
|
|
fake.satisfiesPrincipalMutex.Lock()
|
|
ret, specificReturn := fake.satisfiesPrincipalReturnsOnCall[len(fake.satisfiesPrincipalArgsForCall)]
|
|
fake.satisfiesPrincipalArgsForCall = append(fake.satisfiesPrincipalArgsForCall, struct {
|
|
arg1 *mspa.MSPPrincipal
|
|
}{arg1})
|
|
fake.recordInvocation("SatisfiesPrincipal", []interface{}{arg1})
|
|
fake.satisfiesPrincipalMutex.Unlock()
|
|
if fake.SatisfiesPrincipalStub != nil {
|
|
return fake.SatisfiesPrincipalStub(arg1)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.satisfiesPrincipalReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) SatisfiesPrincipalCallCount() int {
|
|
fake.satisfiesPrincipalMutex.RLock()
|
|
defer fake.satisfiesPrincipalMutex.RUnlock()
|
|
return len(fake.satisfiesPrincipalArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) SatisfiesPrincipalCalls(stub func(*mspa.MSPPrincipal) error) {
|
|
fake.satisfiesPrincipalMutex.Lock()
|
|
defer fake.satisfiesPrincipalMutex.Unlock()
|
|
fake.SatisfiesPrincipalStub = stub
|
|
}
|
|
|
|
func (fake *Identity) SatisfiesPrincipalArgsForCall(i int) *mspa.MSPPrincipal {
|
|
fake.satisfiesPrincipalMutex.RLock()
|
|
defer fake.satisfiesPrincipalMutex.RUnlock()
|
|
argsForCall := fake.satisfiesPrincipalArgsForCall[i]
|
|
return argsForCall.arg1
|
|
}
|
|
|
|
func (fake *Identity) SatisfiesPrincipalReturns(result1 error) {
|
|
fake.satisfiesPrincipalMutex.Lock()
|
|
defer fake.satisfiesPrincipalMutex.Unlock()
|
|
fake.SatisfiesPrincipalStub = nil
|
|
fake.satisfiesPrincipalReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) SatisfiesPrincipalReturnsOnCall(i int, result1 error) {
|
|
fake.satisfiesPrincipalMutex.Lock()
|
|
defer fake.satisfiesPrincipalMutex.Unlock()
|
|
fake.SatisfiesPrincipalStub = nil
|
|
if fake.satisfiesPrincipalReturnsOnCall == nil {
|
|
fake.satisfiesPrincipalReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.satisfiesPrincipalReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) Serialize() ([]byte, error) {
|
|
fake.serializeMutex.Lock()
|
|
ret, specificReturn := fake.serializeReturnsOnCall[len(fake.serializeArgsForCall)]
|
|
fake.serializeArgsForCall = append(fake.serializeArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("Serialize", []interface{}{})
|
|
fake.serializeMutex.Unlock()
|
|
if fake.SerializeStub != nil {
|
|
return fake.SerializeStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
fakeReturns := fake.serializeReturns
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *Identity) SerializeCallCount() int {
|
|
fake.serializeMutex.RLock()
|
|
defer fake.serializeMutex.RUnlock()
|
|
return len(fake.serializeArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) SerializeCalls(stub func() ([]byte, error)) {
|
|
fake.serializeMutex.Lock()
|
|
defer fake.serializeMutex.Unlock()
|
|
fake.SerializeStub = stub
|
|
}
|
|
|
|
func (fake *Identity) SerializeReturns(result1 []byte, result2 error) {
|
|
fake.serializeMutex.Lock()
|
|
defer fake.serializeMutex.Unlock()
|
|
fake.SerializeStub = nil
|
|
fake.serializeReturns = struct {
|
|
result1 []byte
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *Identity) SerializeReturnsOnCall(i int, result1 []byte, result2 error) {
|
|
fake.serializeMutex.Lock()
|
|
defer fake.serializeMutex.Unlock()
|
|
fake.SerializeStub = nil
|
|
if fake.serializeReturnsOnCall == nil {
|
|
fake.serializeReturnsOnCall = make(map[int]struct {
|
|
result1 []byte
|
|
result2 error
|
|
})
|
|
}
|
|
fake.serializeReturnsOnCall[i] = struct {
|
|
result1 []byte
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *Identity) Validate() error {
|
|
fake.validateMutex.Lock()
|
|
ret, specificReturn := fake.validateReturnsOnCall[len(fake.validateArgsForCall)]
|
|
fake.validateArgsForCall = append(fake.validateArgsForCall, struct {
|
|
}{})
|
|
fake.recordInvocation("Validate", []interface{}{})
|
|
fake.validateMutex.Unlock()
|
|
if fake.ValidateStub != nil {
|
|
return fake.ValidateStub()
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.validateReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) ValidateCallCount() int {
|
|
fake.validateMutex.RLock()
|
|
defer fake.validateMutex.RUnlock()
|
|
return len(fake.validateArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) ValidateCalls(stub func() error) {
|
|
fake.validateMutex.Lock()
|
|
defer fake.validateMutex.Unlock()
|
|
fake.ValidateStub = stub
|
|
}
|
|
|
|
func (fake *Identity) ValidateReturns(result1 error) {
|
|
fake.validateMutex.Lock()
|
|
defer fake.validateMutex.Unlock()
|
|
fake.ValidateStub = nil
|
|
fake.validateReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) ValidateReturnsOnCall(i int, result1 error) {
|
|
fake.validateMutex.Lock()
|
|
defer fake.validateMutex.Unlock()
|
|
fake.ValidateStub = nil
|
|
if fake.validateReturnsOnCall == nil {
|
|
fake.validateReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.validateReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) Verify(arg1 []byte, arg2 []byte) error {
|
|
var arg1Copy []byte
|
|
if arg1 != nil {
|
|
arg1Copy = make([]byte, len(arg1))
|
|
copy(arg1Copy, arg1)
|
|
}
|
|
var arg2Copy []byte
|
|
if arg2 != nil {
|
|
arg2Copy = make([]byte, len(arg2))
|
|
copy(arg2Copy, arg2)
|
|
}
|
|
fake.verifyMutex.Lock()
|
|
ret, specificReturn := fake.verifyReturnsOnCall[len(fake.verifyArgsForCall)]
|
|
fake.verifyArgsForCall = append(fake.verifyArgsForCall, struct {
|
|
arg1 []byte
|
|
arg2 []byte
|
|
}{arg1Copy, arg2Copy})
|
|
fake.recordInvocation("Verify", []interface{}{arg1Copy, arg2Copy})
|
|
fake.verifyMutex.Unlock()
|
|
if fake.VerifyStub != nil {
|
|
return fake.VerifyStub(arg1, arg2)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1
|
|
}
|
|
fakeReturns := fake.verifyReturns
|
|
return fakeReturns.result1
|
|
}
|
|
|
|
func (fake *Identity) VerifyCallCount() int {
|
|
fake.verifyMutex.RLock()
|
|
defer fake.verifyMutex.RUnlock()
|
|
return len(fake.verifyArgsForCall)
|
|
}
|
|
|
|
func (fake *Identity) VerifyCalls(stub func([]byte, []byte) error) {
|
|
fake.verifyMutex.Lock()
|
|
defer fake.verifyMutex.Unlock()
|
|
fake.VerifyStub = stub
|
|
}
|
|
|
|
func (fake *Identity) VerifyArgsForCall(i int) ([]byte, []byte) {
|
|
fake.verifyMutex.RLock()
|
|
defer fake.verifyMutex.RUnlock()
|
|
argsForCall := fake.verifyArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2
|
|
}
|
|
|
|
func (fake *Identity) VerifyReturns(result1 error) {
|
|
fake.verifyMutex.Lock()
|
|
defer fake.verifyMutex.Unlock()
|
|
fake.VerifyStub = nil
|
|
fake.verifyReturns = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) VerifyReturnsOnCall(i int, result1 error) {
|
|
fake.verifyMutex.Lock()
|
|
defer fake.verifyMutex.Unlock()
|
|
fake.VerifyStub = nil
|
|
if fake.verifyReturnsOnCall == nil {
|
|
fake.verifyReturnsOnCall = make(map[int]struct {
|
|
result1 error
|
|
})
|
|
}
|
|
fake.verifyReturnsOnCall[i] = struct {
|
|
result1 error
|
|
}{result1}
|
|
}
|
|
|
|
func (fake *Identity) Invocations() map[string][][]interface{} {
|
|
fake.invocationsMutex.RLock()
|
|
defer fake.invocationsMutex.RUnlock()
|
|
fake.anonymousMutex.RLock()
|
|
defer fake.anonymousMutex.RUnlock()
|
|
fake.expiresAtMutex.RLock()
|
|
defer fake.expiresAtMutex.RUnlock()
|
|
fake.getIdentifierMutex.RLock()
|
|
defer fake.getIdentifierMutex.RUnlock()
|
|
fake.getMSPIdentifierMutex.RLock()
|
|
defer fake.getMSPIdentifierMutex.RUnlock()
|
|
fake.getOrganizationalUnitsMutex.RLock()
|
|
defer fake.getOrganizationalUnitsMutex.RUnlock()
|
|
fake.satisfiesPrincipalMutex.RLock()
|
|
defer fake.satisfiesPrincipalMutex.RUnlock()
|
|
fake.serializeMutex.RLock()
|
|
defer fake.serializeMutex.RUnlock()
|
|
fake.validateMutex.RLock()
|
|
defer fake.validateMutex.RUnlock()
|
|
fake.verifyMutex.RLock()
|
|
defer fake.verifyMutex.RUnlock()
|
|
copiedInvocations := map[string][][]interface{}{}
|
|
for key, value := range fake.invocations {
|
|
copiedInvocations[key] = value
|
|
}
|
|
return copiedInvocations
|
|
}
|
|
|
|
func (fake *Identity) 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)
|
|
}
|