From 23dc4e698a6fca57535605a33663d1460f2fb4e6 Mon Sep 17 00:00:00 2001 From: Brett Logan Date: Mon, 6 Jul 2020 14:54:17 -0400 Subject: [PATCH] Add Tests to FabCar Go Chaincode Many users raise questions on how to test chaincode. It used to be much easier with the old shim, as they could directly use the old mock stub in the shim. Now that it no longer exists the fabcar example can provide an example of how to test chaincode. Also worth noting is our current directory structure of our Go chaincodes prevents the creation of mocks due to import cycles. This change also pushes the chaincode logic down into a `contract` package. Signed-off-by: Brett Logan --- .../fabcar/go/contract/mocks/chaincodestub.go | 2881 +++++++++++++++++ .../go/contract/mocks/statequeryiterator.go | 235 ++ .../fabcar/go/contract/mocks/transaction.go | 167 + chaincode/fabcar/go/contract/shim.go | 21 + chaincode/fabcar/go/contract/smartcontract.go | 127 + .../fabcar/go/contract/smartcontract_test.go | 133 + chaincode/fabcar/go/fabcar.go | 125 +- chaincode/fabcar/go/go.mod | 9 +- 8 files changed, 3574 insertions(+), 124 deletions(-) create mode 100644 chaincode/fabcar/go/contract/mocks/chaincodestub.go create mode 100644 chaincode/fabcar/go/contract/mocks/statequeryiterator.go create mode 100644 chaincode/fabcar/go/contract/mocks/transaction.go create mode 100644 chaincode/fabcar/go/contract/shim.go create mode 100644 chaincode/fabcar/go/contract/smartcontract.go create mode 100644 chaincode/fabcar/go/contract/smartcontract_test.go diff --git a/chaincode/fabcar/go/contract/mocks/chaincodestub.go b/chaincode/fabcar/go/contract/mocks/chaincodestub.go new file mode 100644 index 00000000..225b9a12 --- /dev/null +++ b/chaincode/fabcar/go/contract/mocks/chaincodestub.go @@ -0,0 +1,2881 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + "github.com/golang/protobuf/ptypes/timestamp" + "github.com/hyperledger/fabric-chaincode-go/shim" + "github.com/hyperledger/fabric-protos-go/peer" + "github.com/hyperledger/fabric-samples/chaincode/fabcar/go/contract" +) + +type ChaincodeStub struct { + CreateCompositeKeyStub func(string, []string) (string, error) + createCompositeKeyMutex sync.RWMutex + createCompositeKeyArgsForCall []struct { + arg1 string + arg2 []string + } + createCompositeKeyReturns struct { + result1 string + result2 error + } + createCompositeKeyReturnsOnCall map[int]struct { + result1 string + result2 error + } + DelPrivateDataStub func(string, string) error + delPrivateDataMutex sync.RWMutex + delPrivateDataArgsForCall []struct { + arg1 string + arg2 string + } + delPrivateDataReturns struct { + result1 error + } + delPrivateDataReturnsOnCall map[int]struct { + result1 error + } + DelStateStub func(string) error + delStateMutex sync.RWMutex + delStateArgsForCall []struct { + arg1 string + } + delStateReturns struct { + result1 error + } + delStateReturnsOnCall map[int]struct { + result1 error + } + GetArgsStub func() [][]byte + getArgsMutex sync.RWMutex + getArgsArgsForCall []struct { + } + getArgsReturns struct { + result1 [][]byte + } + getArgsReturnsOnCall map[int]struct { + result1 [][]byte + } + GetArgsSliceStub func() ([]byte, error) + getArgsSliceMutex sync.RWMutex + getArgsSliceArgsForCall []struct { + } + getArgsSliceReturns struct { + result1 []byte + result2 error + } + getArgsSliceReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetBindingStub func() ([]byte, error) + getBindingMutex sync.RWMutex + getBindingArgsForCall []struct { + } + getBindingReturns struct { + result1 []byte + result2 error + } + getBindingReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetChannelIDStub func() string + getChannelIDMutex sync.RWMutex + getChannelIDArgsForCall []struct { + } + getChannelIDReturns struct { + result1 string + } + getChannelIDReturnsOnCall map[int]struct { + result1 string + } + GetCreatorStub func() ([]byte, error) + getCreatorMutex sync.RWMutex + getCreatorArgsForCall []struct { + } + getCreatorReturns struct { + result1 []byte + result2 error + } + getCreatorReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetDecorationsStub func() map[string][]byte + getDecorationsMutex sync.RWMutex + getDecorationsArgsForCall []struct { + } + getDecorationsReturns struct { + result1 map[string][]byte + } + getDecorationsReturnsOnCall map[int]struct { + result1 map[string][]byte + } + GetFunctionAndParametersStub func() (string, []string) + getFunctionAndParametersMutex sync.RWMutex + getFunctionAndParametersArgsForCall []struct { + } + getFunctionAndParametersReturns struct { + result1 string + result2 []string + } + getFunctionAndParametersReturnsOnCall map[int]struct { + result1 string + result2 []string + } + GetHistoryForKeyStub func(string) (shim.HistoryQueryIteratorInterface, error) + getHistoryForKeyMutex sync.RWMutex + getHistoryForKeyArgsForCall []struct { + arg1 string + } + getHistoryForKeyReturns struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + } + getHistoryForKeyReturnsOnCall map[int]struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + } + GetPrivateDataStub func(string, string) ([]byte, error) + getPrivateDataMutex sync.RWMutex + getPrivateDataArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataReturns struct { + result1 []byte + result2 error + } + getPrivateDataReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetPrivateDataByPartialCompositeKeyStub func(string, string, []string) (shim.StateQueryIteratorInterface, error) + getPrivateDataByPartialCompositeKeyMutex sync.RWMutex + getPrivateDataByPartialCompositeKeyArgsForCall []struct { + arg1 string + arg2 string + arg3 []string + } + getPrivateDataByPartialCompositeKeyReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getPrivateDataByPartialCompositeKeyReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetPrivateDataByRangeStub func(string, string, string) (shim.StateQueryIteratorInterface, error) + getPrivateDataByRangeMutex sync.RWMutex + getPrivateDataByRangeArgsForCall []struct { + arg1 string + arg2 string + arg3 string + } + getPrivateDataByRangeReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getPrivateDataByRangeReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetPrivateDataHashStub func(string, string) ([]byte, error) + getPrivateDataHashMutex sync.RWMutex + getPrivateDataHashArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataHashReturns struct { + result1 []byte + result2 error + } + getPrivateDataHashReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetPrivateDataQueryResultStub func(string, string) (shim.StateQueryIteratorInterface, error) + getPrivateDataQueryResultMutex sync.RWMutex + getPrivateDataQueryResultArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataQueryResultReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getPrivateDataQueryResultReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetPrivateDataValidationParameterStub func(string, string) ([]byte, error) + getPrivateDataValidationParameterMutex sync.RWMutex + getPrivateDataValidationParameterArgsForCall []struct { + arg1 string + arg2 string + } + getPrivateDataValidationParameterReturns struct { + result1 []byte + result2 error + } + getPrivateDataValidationParameterReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetQueryResultStub func(string) (shim.StateQueryIteratorInterface, error) + getQueryResultMutex sync.RWMutex + getQueryResultArgsForCall []struct { + arg1 string + } + getQueryResultReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getQueryResultReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetQueryResultWithPaginationStub func(string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) + getQueryResultWithPaginationMutex sync.RWMutex + getQueryResultWithPaginationArgsForCall []struct { + arg1 string + arg2 int32 + arg3 string + } + getQueryResultWithPaginationReturns struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + getQueryResultWithPaginationReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + GetSignedProposalStub func() (*peer.SignedProposal, error) + getSignedProposalMutex sync.RWMutex + getSignedProposalArgsForCall []struct { + } + getSignedProposalReturns struct { + result1 *peer.SignedProposal + result2 error + } + getSignedProposalReturnsOnCall map[int]struct { + result1 *peer.SignedProposal + result2 error + } + GetStateStub func(string) ([]byte, error) + getStateMutex sync.RWMutex + getStateArgsForCall []struct { + arg1 string + } + getStateReturns struct { + result1 []byte + result2 error + } + getStateReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetStateByPartialCompositeKeyStub func(string, []string) (shim.StateQueryIteratorInterface, error) + getStateByPartialCompositeKeyMutex sync.RWMutex + getStateByPartialCompositeKeyArgsForCall []struct { + arg1 string + arg2 []string + } + getStateByPartialCompositeKeyReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getStateByPartialCompositeKeyReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetStateByPartialCompositeKeyWithPaginationStub func(string, []string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) + getStateByPartialCompositeKeyWithPaginationMutex sync.RWMutex + getStateByPartialCompositeKeyWithPaginationArgsForCall []struct { + arg1 string + arg2 []string + arg3 int32 + arg4 string + } + getStateByPartialCompositeKeyWithPaginationReturns struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + getStateByPartialCompositeKeyWithPaginationReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + GetStateByRangeStub func(string, string) (shim.StateQueryIteratorInterface, error) + getStateByRangeMutex sync.RWMutex + getStateByRangeArgsForCall []struct { + arg1 string + arg2 string + } + getStateByRangeReturns struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + getStateByRangeReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + } + GetStateByRangeWithPaginationStub func(string, string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) + getStateByRangeWithPaginationMutex sync.RWMutex + getStateByRangeWithPaginationArgsForCall []struct { + arg1 string + arg2 string + arg3 int32 + arg4 string + } + getStateByRangeWithPaginationReturns struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + getStateByRangeWithPaginationReturnsOnCall map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + } + GetStateValidationParameterStub func(string) ([]byte, error) + getStateValidationParameterMutex sync.RWMutex + getStateValidationParameterArgsForCall []struct { + arg1 string + } + getStateValidationParameterReturns struct { + result1 []byte + result2 error + } + getStateValidationParameterReturnsOnCall map[int]struct { + result1 []byte + result2 error + } + GetStringArgsStub func() []string + getStringArgsMutex sync.RWMutex + getStringArgsArgsForCall []struct { + } + getStringArgsReturns struct { + result1 []string + } + getStringArgsReturnsOnCall map[int]struct { + result1 []string + } + GetTransientStub func() (map[string][]byte, error) + getTransientMutex sync.RWMutex + getTransientArgsForCall []struct { + } + getTransientReturns struct { + result1 map[string][]byte + result2 error + } + getTransientReturnsOnCall map[int]struct { + result1 map[string][]byte + result2 error + } + GetTxIDStub func() string + getTxIDMutex sync.RWMutex + getTxIDArgsForCall []struct { + } + getTxIDReturns struct { + result1 string + } + getTxIDReturnsOnCall map[int]struct { + result1 string + } + GetTxTimestampStub func() (*timestamp.Timestamp, error) + getTxTimestampMutex sync.RWMutex + getTxTimestampArgsForCall []struct { + } + getTxTimestampReturns struct { + result1 *timestamp.Timestamp + result2 error + } + getTxTimestampReturnsOnCall map[int]struct { + result1 *timestamp.Timestamp + result2 error + } + InvokeChaincodeStub func(string, [][]byte, string) peer.Response + invokeChaincodeMutex sync.RWMutex + invokeChaincodeArgsForCall []struct { + arg1 string + arg2 [][]byte + arg3 string + } + invokeChaincodeReturns struct { + result1 peer.Response + } + invokeChaincodeReturnsOnCall map[int]struct { + result1 peer.Response + } + PutPrivateDataStub func(string, string, []byte) error + putPrivateDataMutex sync.RWMutex + putPrivateDataArgsForCall []struct { + arg1 string + arg2 string + arg3 []byte + } + putPrivateDataReturns struct { + result1 error + } + putPrivateDataReturnsOnCall map[int]struct { + result1 error + } + PutStateStub func(string, []byte) error + putStateMutex sync.RWMutex + putStateArgsForCall []struct { + arg1 string + arg2 []byte + } + putStateReturns struct { + result1 error + } + putStateReturnsOnCall map[int]struct { + result1 error + } + SetEventStub func(string, []byte) error + setEventMutex sync.RWMutex + setEventArgsForCall []struct { + arg1 string + arg2 []byte + } + setEventReturns struct { + result1 error + } + setEventReturnsOnCall map[int]struct { + result1 error + } + SetPrivateDataValidationParameterStub func(string, string, []byte) error + setPrivateDataValidationParameterMutex sync.RWMutex + setPrivateDataValidationParameterArgsForCall []struct { + arg1 string + arg2 string + arg3 []byte + } + setPrivateDataValidationParameterReturns struct { + result1 error + } + setPrivateDataValidationParameterReturnsOnCall map[int]struct { + result1 error + } + SetStateValidationParameterStub func(string, []byte) error + setStateValidationParameterMutex sync.RWMutex + setStateValidationParameterArgsForCall []struct { + arg1 string + arg2 []byte + } + setStateValidationParameterReturns struct { + result1 error + } + setStateValidationParameterReturnsOnCall map[int]struct { + result1 error + } + SplitCompositeKeyStub func(string) (string, []string, error) + splitCompositeKeyMutex sync.RWMutex + splitCompositeKeyArgsForCall []struct { + arg1 string + } + splitCompositeKeyReturns struct { + result1 string + result2 []string + result3 error + } + splitCompositeKeyReturnsOnCall map[int]struct { + result1 string + result2 []string + result3 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *ChaincodeStub) CreateCompositeKey(arg1 string, arg2 []string) (string, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.createCompositeKeyMutex.Lock() + ret, specificReturn := fake.createCompositeKeyReturnsOnCall[len(fake.createCompositeKeyArgsForCall)] + fake.createCompositeKeyArgsForCall = append(fake.createCompositeKeyArgsForCall, struct { + arg1 string + arg2 []string + }{arg1, arg2Copy}) + fake.recordInvocation("CreateCompositeKey", []interface{}{arg1, arg2Copy}) + fake.createCompositeKeyMutex.Unlock() + if fake.CreateCompositeKeyStub != nil { + return fake.CreateCompositeKeyStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.createCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) CreateCompositeKeyCallCount() int { + fake.createCompositeKeyMutex.RLock() + defer fake.createCompositeKeyMutex.RUnlock() + return len(fake.createCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) CreateCompositeKeyCalls(stub func(string, []string) (string, error)) { + fake.createCompositeKeyMutex.Lock() + defer fake.createCompositeKeyMutex.Unlock() + fake.CreateCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) CreateCompositeKeyArgsForCall(i int) (string, []string) { + fake.createCompositeKeyMutex.RLock() + defer fake.createCompositeKeyMutex.RUnlock() + argsForCall := fake.createCompositeKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) CreateCompositeKeyReturns(result1 string, result2 error) { + fake.createCompositeKeyMutex.Lock() + defer fake.createCompositeKeyMutex.Unlock() + fake.CreateCompositeKeyStub = nil + fake.createCompositeKeyReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) CreateCompositeKeyReturnsOnCall(i int, result1 string, result2 error) { + fake.createCompositeKeyMutex.Lock() + defer fake.createCompositeKeyMutex.Unlock() + fake.CreateCompositeKeyStub = nil + if fake.createCompositeKeyReturnsOnCall == nil { + fake.createCompositeKeyReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.createCompositeKeyReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) DelPrivateData(arg1 string, arg2 string) error { + fake.delPrivateDataMutex.Lock() + ret, specificReturn := fake.delPrivateDataReturnsOnCall[len(fake.delPrivateDataArgsForCall)] + fake.delPrivateDataArgsForCall = append(fake.delPrivateDataArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("DelPrivateData", []interface{}{arg1, arg2}) + fake.delPrivateDataMutex.Unlock() + if fake.DelPrivateDataStub != nil { + return fake.DelPrivateDataStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.delPrivateDataReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) DelPrivateDataCallCount() int { + fake.delPrivateDataMutex.RLock() + defer fake.delPrivateDataMutex.RUnlock() + return len(fake.delPrivateDataArgsForCall) +} + +func (fake *ChaincodeStub) DelPrivateDataCalls(stub func(string, string) error) { + fake.delPrivateDataMutex.Lock() + defer fake.delPrivateDataMutex.Unlock() + fake.DelPrivateDataStub = stub +} + +func (fake *ChaincodeStub) DelPrivateDataArgsForCall(i int) (string, string) { + fake.delPrivateDataMutex.RLock() + defer fake.delPrivateDataMutex.RUnlock() + argsForCall := fake.delPrivateDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) DelPrivateDataReturns(result1 error) { + fake.delPrivateDataMutex.Lock() + defer fake.delPrivateDataMutex.Unlock() + fake.DelPrivateDataStub = nil + fake.delPrivateDataReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) DelPrivateDataReturnsOnCall(i int, result1 error) { + fake.delPrivateDataMutex.Lock() + defer fake.delPrivateDataMutex.Unlock() + fake.DelPrivateDataStub = nil + if fake.delPrivateDataReturnsOnCall == nil { + fake.delPrivateDataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.delPrivateDataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) DelState(arg1 string) error { + fake.delStateMutex.Lock() + ret, specificReturn := fake.delStateReturnsOnCall[len(fake.delStateArgsForCall)] + fake.delStateArgsForCall = append(fake.delStateArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("DelState", []interface{}{arg1}) + fake.delStateMutex.Unlock() + if fake.DelStateStub != nil { + return fake.DelStateStub(arg1) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.delStateReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) DelStateCallCount() int { + fake.delStateMutex.RLock() + defer fake.delStateMutex.RUnlock() + return len(fake.delStateArgsForCall) +} + +func (fake *ChaincodeStub) DelStateCalls(stub func(string) error) { + fake.delStateMutex.Lock() + defer fake.delStateMutex.Unlock() + fake.DelStateStub = stub +} + +func (fake *ChaincodeStub) DelStateArgsForCall(i int) string { + fake.delStateMutex.RLock() + defer fake.delStateMutex.RUnlock() + argsForCall := fake.delStateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) DelStateReturns(result1 error) { + fake.delStateMutex.Lock() + defer fake.delStateMutex.Unlock() + fake.DelStateStub = nil + fake.delStateReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) DelStateReturnsOnCall(i int, result1 error) { + fake.delStateMutex.Lock() + defer fake.delStateMutex.Unlock() + fake.DelStateStub = nil + if fake.delStateReturnsOnCall == nil { + fake.delStateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.delStateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) GetArgs() [][]byte { + fake.getArgsMutex.Lock() + ret, specificReturn := fake.getArgsReturnsOnCall[len(fake.getArgsArgsForCall)] + fake.getArgsArgsForCall = append(fake.getArgsArgsForCall, struct { + }{}) + fake.recordInvocation("GetArgs", []interface{}{}) + fake.getArgsMutex.Unlock() + if fake.GetArgsStub != nil { + return fake.GetArgsStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getArgsReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetArgsCallCount() int { + fake.getArgsMutex.RLock() + defer fake.getArgsMutex.RUnlock() + return len(fake.getArgsArgsForCall) +} + +func (fake *ChaincodeStub) GetArgsCalls(stub func() [][]byte) { + fake.getArgsMutex.Lock() + defer fake.getArgsMutex.Unlock() + fake.GetArgsStub = stub +} + +func (fake *ChaincodeStub) GetArgsReturns(result1 [][]byte) { + fake.getArgsMutex.Lock() + defer fake.getArgsMutex.Unlock() + fake.GetArgsStub = nil + fake.getArgsReturns = struct { + result1 [][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetArgsReturnsOnCall(i int, result1 [][]byte) { + fake.getArgsMutex.Lock() + defer fake.getArgsMutex.Unlock() + fake.GetArgsStub = nil + if fake.getArgsReturnsOnCall == nil { + fake.getArgsReturnsOnCall = make(map[int]struct { + result1 [][]byte + }) + } + fake.getArgsReturnsOnCall[i] = struct { + result1 [][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetArgsSlice() ([]byte, error) { + fake.getArgsSliceMutex.Lock() + ret, specificReturn := fake.getArgsSliceReturnsOnCall[len(fake.getArgsSliceArgsForCall)] + fake.getArgsSliceArgsForCall = append(fake.getArgsSliceArgsForCall, struct { + }{}) + fake.recordInvocation("GetArgsSlice", []interface{}{}) + fake.getArgsSliceMutex.Unlock() + if fake.GetArgsSliceStub != nil { + return fake.GetArgsSliceStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getArgsSliceReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetArgsSliceCallCount() int { + fake.getArgsSliceMutex.RLock() + defer fake.getArgsSliceMutex.RUnlock() + return len(fake.getArgsSliceArgsForCall) +} + +func (fake *ChaincodeStub) GetArgsSliceCalls(stub func() ([]byte, error)) { + fake.getArgsSliceMutex.Lock() + defer fake.getArgsSliceMutex.Unlock() + fake.GetArgsSliceStub = stub +} + +func (fake *ChaincodeStub) GetArgsSliceReturns(result1 []byte, result2 error) { + fake.getArgsSliceMutex.Lock() + defer fake.getArgsSliceMutex.Unlock() + fake.GetArgsSliceStub = nil + fake.getArgsSliceReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetArgsSliceReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getArgsSliceMutex.Lock() + defer fake.getArgsSliceMutex.Unlock() + fake.GetArgsSliceStub = nil + if fake.getArgsSliceReturnsOnCall == nil { + fake.getArgsSliceReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getArgsSliceReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetBinding() ([]byte, error) { + fake.getBindingMutex.Lock() + ret, specificReturn := fake.getBindingReturnsOnCall[len(fake.getBindingArgsForCall)] + fake.getBindingArgsForCall = append(fake.getBindingArgsForCall, struct { + }{}) + fake.recordInvocation("GetBinding", []interface{}{}) + fake.getBindingMutex.Unlock() + if fake.GetBindingStub != nil { + return fake.GetBindingStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getBindingReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetBindingCallCount() int { + fake.getBindingMutex.RLock() + defer fake.getBindingMutex.RUnlock() + return len(fake.getBindingArgsForCall) +} + +func (fake *ChaincodeStub) GetBindingCalls(stub func() ([]byte, error)) { + fake.getBindingMutex.Lock() + defer fake.getBindingMutex.Unlock() + fake.GetBindingStub = stub +} + +func (fake *ChaincodeStub) GetBindingReturns(result1 []byte, result2 error) { + fake.getBindingMutex.Lock() + defer fake.getBindingMutex.Unlock() + fake.GetBindingStub = nil + fake.getBindingReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetBindingReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getBindingMutex.Lock() + defer fake.getBindingMutex.Unlock() + fake.GetBindingStub = nil + if fake.getBindingReturnsOnCall == nil { + fake.getBindingReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getBindingReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetChannelID() string { + fake.getChannelIDMutex.Lock() + ret, specificReturn := fake.getChannelIDReturnsOnCall[len(fake.getChannelIDArgsForCall)] + fake.getChannelIDArgsForCall = append(fake.getChannelIDArgsForCall, struct { + }{}) + fake.recordInvocation("GetChannelID", []interface{}{}) + fake.getChannelIDMutex.Unlock() + if fake.GetChannelIDStub != nil { + return fake.GetChannelIDStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getChannelIDReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetChannelIDCallCount() int { + fake.getChannelIDMutex.RLock() + defer fake.getChannelIDMutex.RUnlock() + return len(fake.getChannelIDArgsForCall) +} + +func (fake *ChaincodeStub) GetChannelIDCalls(stub func() string) { + fake.getChannelIDMutex.Lock() + defer fake.getChannelIDMutex.Unlock() + fake.GetChannelIDStub = stub +} + +func (fake *ChaincodeStub) GetChannelIDReturns(result1 string) { + fake.getChannelIDMutex.Lock() + defer fake.getChannelIDMutex.Unlock() + fake.GetChannelIDStub = nil + fake.getChannelIDReturns = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetChannelIDReturnsOnCall(i int, result1 string) { + fake.getChannelIDMutex.Lock() + defer fake.getChannelIDMutex.Unlock() + fake.GetChannelIDStub = nil + if fake.getChannelIDReturnsOnCall == nil { + fake.getChannelIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.getChannelIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetCreator() ([]byte, error) { + fake.getCreatorMutex.Lock() + ret, specificReturn := fake.getCreatorReturnsOnCall[len(fake.getCreatorArgsForCall)] + fake.getCreatorArgsForCall = append(fake.getCreatorArgsForCall, struct { + }{}) + fake.recordInvocation("GetCreator", []interface{}{}) + fake.getCreatorMutex.Unlock() + if fake.GetCreatorStub != nil { + return fake.GetCreatorStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getCreatorReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetCreatorCallCount() int { + fake.getCreatorMutex.RLock() + defer fake.getCreatorMutex.RUnlock() + return len(fake.getCreatorArgsForCall) +} + +func (fake *ChaincodeStub) GetCreatorCalls(stub func() ([]byte, error)) { + fake.getCreatorMutex.Lock() + defer fake.getCreatorMutex.Unlock() + fake.GetCreatorStub = stub +} + +func (fake *ChaincodeStub) GetCreatorReturns(result1 []byte, result2 error) { + fake.getCreatorMutex.Lock() + defer fake.getCreatorMutex.Unlock() + fake.GetCreatorStub = nil + fake.getCreatorReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetCreatorReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getCreatorMutex.Lock() + defer fake.getCreatorMutex.Unlock() + fake.GetCreatorStub = nil + if fake.getCreatorReturnsOnCall == nil { + fake.getCreatorReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getCreatorReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetDecorations() map[string][]byte { + fake.getDecorationsMutex.Lock() + ret, specificReturn := fake.getDecorationsReturnsOnCall[len(fake.getDecorationsArgsForCall)] + fake.getDecorationsArgsForCall = append(fake.getDecorationsArgsForCall, struct { + }{}) + fake.recordInvocation("GetDecorations", []interface{}{}) + fake.getDecorationsMutex.Unlock() + if fake.GetDecorationsStub != nil { + return fake.GetDecorationsStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getDecorationsReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetDecorationsCallCount() int { + fake.getDecorationsMutex.RLock() + defer fake.getDecorationsMutex.RUnlock() + return len(fake.getDecorationsArgsForCall) +} + +func (fake *ChaincodeStub) GetDecorationsCalls(stub func() map[string][]byte) { + fake.getDecorationsMutex.Lock() + defer fake.getDecorationsMutex.Unlock() + fake.GetDecorationsStub = stub +} + +func (fake *ChaincodeStub) GetDecorationsReturns(result1 map[string][]byte) { + fake.getDecorationsMutex.Lock() + defer fake.getDecorationsMutex.Unlock() + fake.GetDecorationsStub = nil + fake.getDecorationsReturns = struct { + result1 map[string][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetDecorationsReturnsOnCall(i int, result1 map[string][]byte) { + fake.getDecorationsMutex.Lock() + defer fake.getDecorationsMutex.Unlock() + fake.GetDecorationsStub = nil + if fake.getDecorationsReturnsOnCall == nil { + fake.getDecorationsReturnsOnCall = make(map[int]struct { + result1 map[string][]byte + }) + } + fake.getDecorationsReturnsOnCall[i] = struct { + result1 map[string][]byte + }{result1} +} + +func (fake *ChaincodeStub) GetFunctionAndParameters() (string, []string) { + fake.getFunctionAndParametersMutex.Lock() + ret, specificReturn := fake.getFunctionAndParametersReturnsOnCall[len(fake.getFunctionAndParametersArgsForCall)] + fake.getFunctionAndParametersArgsForCall = append(fake.getFunctionAndParametersArgsForCall, struct { + }{}) + fake.recordInvocation("GetFunctionAndParameters", []interface{}{}) + fake.getFunctionAndParametersMutex.Unlock() + if fake.GetFunctionAndParametersStub != nil { + return fake.GetFunctionAndParametersStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getFunctionAndParametersReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetFunctionAndParametersCallCount() int { + fake.getFunctionAndParametersMutex.RLock() + defer fake.getFunctionAndParametersMutex.RUnlock() + return len(fake.getFunctionAndParametersArgsForCall) +} + +func (fake *ChaincodeStub) GetFunctionAndParametersCalls(stub func() (string, []string)) { + fake.getFunctionAndParametersMutex.Lock() + defer fake.getFunctionAndParametersMutex.Unlock() + fake.GetFunctionAndParametersStub = stub +} + +func (fake *ChaincodeStub) GetFunctionAndParametersReturns(result1 string, result2 []string) { + fake.getFunctionAndParametersMutex.Lock() + defer fake.getFunctionAndParametersMutex.Unlock() + fake.GetFunctionAndParametersStub = nil + fake.getFunctionAndParametersReturns = struct { + result1 string + result2 []string + }{result1, result2} +} + +func (fake *ChaincodeStub) GetFunctionAndParametersReturnsOnCall(i int, result1 string, result2 []string) { + fake.getFunctionAndParametersMutex.Lock() + defer fake.getFunctionAndParametersMutex.Unlock() + fake.GetFunctionAndParametersStub = nil + if fake.getFunctionAndParametersReturnsOnCall == nil { + fake.getFunctionAndParametersReturnsOnCall = make(map[int]struct { + result1 string + result2 []string + }) + } + fake.getFunctionAndParametersReturnsOnCall[i] = struct { + result1 string + result2 []string + }{result1, result2} +} + +func (fake *ChaincodeStub) GetHistoryForKey(arg1 string) (shim.HistoryQueryIteratorInterface, error) { + fake.getHistoryForKeyMutex.Lock() + ret, specificReturn := fake.getHistoryForKeyReturnsOnCall[len(fake.getHistoryForKeyArgsForCall)] + fake.getHistoryForKeyArgsForCall = append(fake.getHistoryForKeyArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetHistoryForKey", []interface{}{arg1}) + fake.getHistoryForKeyMutex.Unlock() + if fake.GetHistoryForKeyStub != nil { + return fake.GetHistoryForKeyStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getHistoryForKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetHistoryForKeyCallCount() int { + fake.getHistoryForKeyMutex.RLock() + defer fake.getHistoryForKeyMutex.RUnlock() + return len(fake.getHistoryForKeyArgsForCall) +} + +func (fake *ChaincodeStub) GetHistoryForKeyCalls(stub func(string) (shim.HistoryQueryIteratorInterface, error)) { + fake.getHistoryForKeyMutex.Lock() + defer fake.getHistoryForKeyMutex.Unlock() + fake.GetHistoryForKeyStub = stub +} + +func (fake *ChaincodeStub) GetHistoryForKeyArgsForCall(i int) string { + fake.getHistoryForKeyMutex.RLock() + defer fake.getHistoryForKeyMutex.RUnlock() + argsForCall := fake.getHistoryForKeyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetHistoryForKeyReturns(result1 shim.HistoryQueryIteratorInterface, result2 error) { + fake.getHistoryForKeyMutex.Lock() + defer fake.getHistoryForKeyMutex.Unlock() + fake.GetHistoryForKeyStub = nil + fake.getHistoryForKeyReturns = struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetHistoryForKeyReturnsOnCall(i int, result1 shim.HistoryQueryIteratorInterface, result2 error) { + fake.getHistoryForKeyMutex.Lock() + defer fake.getHistoryForKeyMutex.Unlock() + fake.GetHistoryForKeyStub = nil + if fake.getHistoryForKeyReturnsOnCall == nil { + fake.getHistoryForKeyReturnsOnCall = make(map[int]struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + }) + } + fake.getHistoryForKeyReturnsOnCall[i] = struct { + result1 shim.HistoryQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateData(arg1 string, arg2 string) ([]byte, error) { + fake.getPrivateDataMutex.Lock() + ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)] + fake.getPrivateDataArgsForCall = append(fake.getPrivateDataArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateData", []interface{}{arg1, arg2}) + fake.getPrivateDataMutex.Unlock() + if fake.GetPrivateDataStub != nil { + return fake.GetPrivateDataStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataCallCount() int { + fake.getPrivateDataMutex.RLock() + defer fake.getPrivateDataMutex.RUnlock() + return len(fake.getPrivateDataArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataCalls(stub func(string, string) ([]byte, error)) { + fake.getPrivateDataMutex.Lock() + defer fake.getPrivateDataMutex.Unlock() + fake.GetPrivateDataStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataArgsForCall(i int) (string, string) { + fake.getPrivateDataMutex.RLock() + defer fake.getPrivateDataMutex.RUnlock() + argsForCall := fake.getPrivateDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataReturns(result1 []byte, result2 error) { + fake.getPrivateDataMutex.Lock() + defer fake.getPrivateDataMutex.Unlock() + fake.GetPrivateDataStub = nil + fake.getPrivateDataReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getPrivateDataMutex.Lock() + defer fake.getPrivateDataMutex.Unlock() + fake.GetPrivateDataStub = nil + if fake.getPrivateDataReturnsOnCall == nil { + fake.getPrivateDataReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getPrivateDataReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKey(arg1 string, arg2 string, arg3 []string) (shim.StateQueryIteratorInterface, error) { + var arg3Copy []string + if arg3 != nil { + arg3Copy = make([]string, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + ret, specificReturn := fake.getPrivateDataByPartialCompositeKeyReturnsOnCall[len(fake.getPrivateDataByPartialCompositeKeyArgsForCall)] + fake.getPrivateDataByPartialCompositeKeyArgsForCall = append(fake.getPrivateDataByPartialCompositeKeyArgsForCall, struct { + arg1 string + arg2 string + arg3 []string + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("GetPrivateDataByPartialCompositeKey", []interface{}{arg1, arg2, arg3Copy}) + fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + if fake.GetPrivateDataByPartialCompositeKeyStub != nil { + return fake.GetPrivateDataByPartialCompositeKeyStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataByPartialCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyCallCount() int { + fake.getPrivateDataByPartialCompositeKeyMutex.RLock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.RUnlock() + return len(fake.getPrivateDataByPartialCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyCalls(stub func(string, string, []string) (shim.StateQueryIteratorInterface, error)) { + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + fake.GetPrivateDataByPartialCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyArgsForCall(i int) (string, string, []string) { + fake.getPrivateDataByPartialCompositeKeyMutex.RLock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.RUnlock() + argsForCall := fake.getPrivateDataByPartialCompositeKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + fake.GetPrivateDataByPartialCompositeKeyStub = nil + fake.getPrivateDataByPartialCompositeKeyReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByPartialCompositeKeyReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByPartialCompositeKeyMutex.Lock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.Unlock() + fake.GetPrivateDataByPartialCompositeKeyStub = nil + if fake.getPrivateDataByPartialCompositeKeyReturnsOnCall == nil { + fake.getPrivateDataByPartialCompositeKeyReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getPrivateDataByPartialCompositeKeyReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByRange(arg1 string, arg2 string, arg3 string) (shim.StateQueryIteratorInterface, error) { + fake.getPrivateDataByRangeMutex.Lock() + ret, specificReturn := fake.getPrivateDataByRangeReturnsOnCall[len(fake.getPrivateDataByRangeArgsForCall)] + fake.getPrivateDataByRangeArgsForCall = append(fake.getPrivateDataByRangeArgsForCall, struct { + arg1 string + arg2 string + arg3 string + }{arg1, arg2, arg3}) + fake.recordInvocation("GetPrivateDataByRange", []interface{}{arg1, arg2, arg3}) + fake.getPrivateDataByRangeMutex.Unlock() + if fake.GetPrivateDataByRangeStub != nil { + return fake.GetPrivateDataByRangeStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataByRangeReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeCallCount() int { + fake.getPrivateDataByRangeMutex.RLock() + defer fake.getPrivateDataByRangeMutex.RUnlock() + return len(fake.getPrivateDataByRangeArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeCalls(stub func(string, string, string) (shim.StateQueryIteratorInterface, error)) { + fake.getPrivateDataByRangeMutex.Lock() + defer fake.getPrivateDataByRangeMutex.Unlock() + fake.GetPrivateDataByRangeStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeArgsForCall(i int) (string, string, string) { + fake.getPrivateDataByRangeMutex.RLock() + defer fake.getPrivateDataByRangeMutex.RUnlock() + argsForCall := fake.getPrivateDataByRangeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByRangeMutex.Lock() + defer fake.getPrivateDataByRangeMutex.Unlock() + fake.GetPrivateDataByRangeStub = nil + fake.getPrivateDataByRangeReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataByRangeReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataByRangeMutex.Lock() + defer fake.getPrivateDataByRangeMutex.Unlock() + fake.GetPrivateDataByRangeStub = nil + if fake.getPrivateDataByRangeReturnsOnCall == nil { + fake.getPrivateDataByRangeReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getPrivateDataByRangeReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataHash(arg1 string, arg2 string) ([]byte, error) { + fake.getPrivateDataHashMutex.Lock() + ret, specificReturn := fake.getPrivateDataHashReturnsOnCall[len(fake.getPrivateDataHashArgsForCall)] + fake.getPrivateDataHashArgsForCall = append(fake.getPrivateDataHashArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateDataHash", []interface{}{arg1, arg2}) + fake.getPrivateDataHashMutex.Unlock() + if fake.GetPrivateDataHashStub != nil { + return fake.GetPrivateDataHashStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataHashReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataHashCallCount() int { + fake.getPrivateDataHashMutex.RLock() + defer fake.getPrivateDataHashMutex.RUnlock() + return len(fake.getPrivateDataHashArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataHashCalls(stub func(string, string) ([]byte, error)) { + fake.getPrivateDataHashMutex.Lock() + defer fake.getPrivateDataHashMutex.Unlock() + fake.GetPrivateDataHashStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataHashArgsForCall(i int) (string, string) { + fake.getPrivateDataHashMutex.RLock() + defer fake.getPrivateDataHashMutex.RUnlock() + argsForCall := fake.getPrivateDataHashArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataHashReturns(result1 []byte, result2 error) { + fake.getPrivateDataHashMutex.Lock() + defer fake.getPrivateDataHashMutex.Unlock() + fake.GetPrivateDataHashStub = nil + fake.getPrivateDataHashReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataHashReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getPrivateDataHashMutex.Lock() + defer fake.getPrivateDataHashMutex.Unlock() + fake.GetPrivateDataHashStub = nil + if fake.getPrivateDataHashReturnsOnCall == nil { + fake.getPrivateDataHashReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getPrivateDataHashReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResult(arg1 string, arg2 string) (shim.StateQueryIteratorInterface, error) { + fake.getPrivateDataQueryResultMutex.Lock() + ret, specificReturn := fake.getPrivateDataQueryResultReturnsOnCall[len(fake.getPrivateDataQueryResultArgsForCall)] + fake.getPrivateDataQueryResultArgsForCall = append(fake.getPrivateDataQueryResultArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateDataQueryResult", []interface{}{arg1, arg2}) + fake.getPrivateDataQueryResultMutex.Unlock() + if fake.GetPrivateDataQueryResultStub != nil { + return fake.GetPrivateDataQueryResultStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataQueryResultReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultCallCount() int { + fake.getPrivateDataQueryResultMutex.RLock() + defer fake.getPrivateDataQueryResultMutex.RUnlock() + return len(fake.getPrivateDataQueryResultArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultCalls(stub func(string, string) (shim.StateQueryIteratorInterface, error)) { + fake.getPrivateDataQueryResultMutex.Lock() + defer fake.getPrivateDataQueryResultMutex.Unlock() + fake.GetPrivateDataQueryResultStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultArgsForCall(i int) (string, string) { + fake.getPrivateDataQueryResultMutex.RLock() + defer fake.getPrivateDataQueryResultMutex.RUnlock() + argsForCall := fake.getPrivateDataQueryResultArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataQueryResultMutex.Lock() + defer fake.getPrivateDataQueryResultMutex.Unlock() + fake.GetPrivateDataQueryResultStub = nil + fake.getPrivateDataQueryResultReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataQueryResultReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getPrivateDataQueryResultMutex.Lock() + defer fake.getPrivateDataQueryResultMutex.Unlock() + fake.GetPrivateDataQueryResultStub = nil + if fake.getPrivateDataQueryResultReturnsOnCall == nil { + fake.getPrivateDataQueryResultReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getPrivateDataQueryResultReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameter(arg1 string, arg2 string) ([]byte, error) { + fake.getPrivateDataValidationParameterMutex.Lock() + ret, specificReturn := fake.getPrivateDataValidationParameterReturnsOnCall[len(fake.getPrivateDataValidationParameterArgsForCall)] + fake.getPrivateDataValidationParameterArgsForCall = append(fake.getPrivateDataValidationParameterArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetPrivateDataValidationParameter", []interface{}{arg1, arg2}) + fake.getPrivateDataValidationParameterMutex.Unlock() + if fake.GetPrivateDataValidationParameterStub != nil { + return fake.GetPrivateDataValidationParameterStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataValidationParameterReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterCallCount() int { + fake.getPrivateDataValidationParameterMutex.RLock() + defer fake.getPrivateDataValidationParameterMutex.RUnlock() + return len(fake.getPrivateDataValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterCalls(stub func(string, string) ([]byte, error)) { + fake.getPrivateDataValidationParameterMutex.Lock() + defer fake.getPrivateDataValidationParameterMutex.Unlock() + fake.GetPrivateDataValidationParameterStub = stub +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterArgsForCall(i int) (string, string) { + fake.getPrivateDataValidationParameterMutex.RLock() + defer fake.getPrivateDataValidationParameterMutex.RUnlock() + argsForCall := fake.getPrivateDataValidationParameterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterReturns(result1 []byte, result2 error) { + fake.getPrivateDataValidationParameterMutex.Lock() + defer fake.getPrivateDataValidationParameterMutex.Unlock() + fake.GetPrivateDataValidationParameterStub = nil + fake.getPrivateDataValidationParameterReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetPrivateDataValidationParameterReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getPrivateDataValidationParameterMutex.Lock() + defer fake.getPrivateDataValidationParameterMutex.Unlock() + fake.GetPrivateDataValidationParameterStub = nil + if fake.getPrivateDataValidationParameterReturnsOnCall == nil { + fake.getPrivateDataValidationParameterReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getPrivateDataValidationParameterReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetQueryResult(arg1 string) (shim.StateQueryIteratorInterface, error) { + fake.getQueryResultMutex.Lock() + ret, specificReturn := fake.getQueryResultReturnsOnCall[len(fake.getQueryResultArgsForCall)] + fake.getQueryResultArgsForCall = append(fake.getQueryResultArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetQueryResult", []interface{}{arg1}) + fake.getQueryResultMutex.Unlock() + if fake.GetQueryResultStub != nil { + return fake.GetQueryResultStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getQueryResultReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetQueryResultCallCount() int { + fake.getQueryResultMutex.RLock() + defer fake.getQueryResultMutex.RUnlock() + return len(fake.getQueryResultArgsForCall) +} + +func (fake *ChaincodeStub) GetQueryResultCalls(stub func(string) (shim.StateQueryIteratorInterface, error)) { + fake.getQueryResultMutex.Lock() + defer fake.getQueryResultMutex.Unlock() + fake.GetQueryResultStub = stub +} + +func (fake *ChaincodeStub) GetQueryResultArgsForCall(i int) string { + fake.getQueryResultMutex.RLock() + defer fake.getQueryResultMutex.RUnlock() + argsForCall := fake.getQueryResultArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetQueryResultReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getQueryResultMutex.Lock() + defer fake.getQueryResultMutex.Unlock() + fake.GetQueryResultStub = nil + fake.getQueryResultReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetQueryResultReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getQueryResultMutex.Lock() + defer fake.getQueryResultMutex.Unlock() + fake.GetQueryResultStub = nil + if fake.getQueryResultReturnsOnCall == nil { + fake.getQueryResultReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getQueryResultReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetQueryResultWithPagination(arg1 string, arg2 int32, arg3 string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) { + fake.getQueryResultWithPaginationMutex.Lock() + ret, specificReturn := fake.getQueryResultWithPaginationReturnsOnCall[len(fake.getQueryResultWithPaginationArgsForCall)] + fake.getQueryResultWithPaginationArgsForCall = append(fake.getQueryResultWithPaginationArgsForCall, struct { + arg1 string + arg2 int32 + arg3 string + }{arg1, arg2, arg3}) + fake.recordInvocation("GetQueryResultWithPagination", []interface{}{arg1, arg2, arg3}) + fake.getQueryResultWithPaginationMutex.Unlock() + if fake.GetQueryResultWithPaginationStub != nil { + return fake.GetQueryResultWithPaginationStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getQueryResultWithPaginationReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationCallCount() int { + fake.getQueryResultWithPaginationMutex.RLock() + defer fake.getQueryResultWithPaginationMutex.RUnlock() + return len(fake.getQueryResultWithPaginationArgsForCall) +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationCalls(stub func(string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error)) { + fake.getQueryResultWithPaginationMutex.Lock() + defer fake.getQueryResultWithPaginationMutex.Unlock() + fake.GetQueryResultWithPaginationStub = stub +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationArgsForCall(i int) (string, int32, string) { + fake.getQueryResultWithPaginationMutex.RLock() + defer fake.getQueryResultWithPaginationMutex.RUnlock() + argsForCall := fake.getQueryResultWithPaginationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationReturns(result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getQueryResultWithPaginationMutex.Lock() + defer fake.getQueryResultWithPaginationMutex.Unlock() + fake.GetQueryResultWithPaginationStub = nil + fake.getQueryResultWithPaginationReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetQueryResultWithPaginationReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getQueryResultWithPaginationMutex.Lock() + defer fake.getQueryResultWithPaginationMutex.Unlock() + fake.GetQueryResultWithPaginationStub = nil + if fake.getQueryResultWithPaginationReturnsOnCall == nil { + fake.getQueryResultWithPaginationReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }) + } + fake.getQueryResultWithPaginationReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetSignedProposal() (*peer.SignedProposal, error) { + fake.getSignedProposalMutex.Lock() + ret, specificReturn := fake.getSignedProposalReturnsOnCall[len(fake.getSignedProposalArgsForCall)] + fake.getSignedProposalArgsForCall = append(fake.getSignedProposalArgsForCall, struct { + }{}) + fake.recordInvocation("GetSignedProposal", []interface{}{}) + fake.getSignedProposalMutex.Unlock() + if fake.GetSignedProposalStub != nil { + return fake.GetSignedProposalStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getSignedProposalReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetSignedProposalCallCount() int { + fake.getSignedProposalMutex.RLock() + defer fake.getSignedProposalMutex.RUnlock() + return len(fake.getSignedProposalArgsForCall) +} + +func (fake *ChaincodeStub) GetSignedProposalCalls(stub func() (*peer.SignedProposal, error)) { + fake.getSignedProposalMutex.Lock() + defer fake.getSignedProposalMutex.Unlock() + fake.GetSignedProposalStub = stub +} + +func (fake *ChaincodeStub) GetSignedProposalReturns(result1 *peer.SignedProposal, result2 error) { + fake.getSignedProposalMutex.Lock() + defer fake.getSignedProposalMutex.Unlock() + fake.GetSignedProposalStub = nil + fake.getSignedProposalReturns = struct { + result1 *peer.SignedProposal + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetSignedProposalReturnsOnCall(i int, result1 *peer.SignedProposal, result2 error) { + fake.getSignedProposalMutex.Lock() + defer fake.getSignedProposalMutex.Unlock() + fake.GetSignedProposalStub = nil + if fake.getSignedProposalReturnsOnCall == nil { + fake.getSignedProposalReturnsOnCall = make(map[int]struct { + result1 *peer.SignedProposal + result2 error + }) + } + fake.getSignedProposalReturnsOnCall[i] = struct { + result1 *peer.SignedProposal + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetState(arg1 string) ([]byte, error) { + fake.getStateMutex.Lock() + ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] + fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetState", []interface{}{arg1}) + fake.getStateMutex.Unlock() + if fake.GetStateStub != nil { + return fake.GetStateStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateCallCount() int { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + return len(fake.getStateArgsForCall) +} + +func (fake *ChaincodeStub) GetStateCalls(stub func(string) ([]byte, error)) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = stub +} + +func (fake *ChaincodeStub) GetStateArgsForCall(i int) string { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + argsForCall := fake.getStateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetStateReturns(result1 []byte, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + fake.getStateReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + if fake.getStateReturnsOnCall == nil { + fake.getStateReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getStateReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKey(arg1 string, arg2 []string) (shim.StateQueryIteratorInterface, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.getStateByPartialCompositeKeyMutex.Lock() + ret, specificReturn := fake.getStateByPartialCompositeKeyReturnsOnCall[len(fake.getStateByPartialCompositeKeyArgsForCall)] + fake.getStateByPartialCompositeKeyArgsForCall = append(fake.getStateByPartialCompositeKeyArgsForCall, struct { + arg1 string + arg2 []string + }{arg1, arg2Copy}) + fake.recordInvocation("GetStateByPartialCompositeKey", []interface{}{arg1, arg2Copy}) + fake.getStateByPartialCompositeKeyMutex.Unlock() + if fake.GetStateByPartialCompositeKeyStub != nil { + return fake.GetStateByPartialCompositeKeyStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateByPartialCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyCallCount() int { + fake.getStateByPartialCompositeKeyMutex.RLock() + defer fake.getStateByPartialCompositeKeyMutex.RUnlock() + return len(fake.getStateByPartialCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyCalls(stub func(string, []string) (shim.StateQueryIteratorInterface, error)) { + fake.getStateByPartialCompositeKeyMutex.Lock() + defer fake.getStateByPartialCompositeKeyMutex.Unlock() + fake.GetStateByPartialCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyArgsForCall(i int) (string, []string) { + fake.getStateByPartialCompositeKeyMutex.RLock() + defer fake.getStateByPartialCompositeKeyMutex.RUnlock() + argsForCall := fake.getStateByPartialCompositeKeyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByPartialCompositeKeyMutex.Lock() + defer fake.getStateByPartialCompositeKeyMutex.Unlock() + fake.GetStateByPartialCompositeKeyStub = nil + fake.getStateByPartialCompositeKeyReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByPartialCompositeKeyMutex.Lock() + defer fake.getStateByPartialCompositeKeyMutex.Unlock() + fake.GetStateByPartialCompositeKeyStub = nil + if fake.getStateByPartialCompositeKeyReturnsOnCall == nil { + fake.getStateByPartialCompositeKeyReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getStateByPartialCompositeKeyReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPagination(arg1 string, arg2 []string, arg3 int32, arg4 string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + ret, specificReturn := fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall[len(fake.getStateByPartialCompositeKeyWithPaginationArgsForCall)] + fake.getStateByPartialCompositeKeyWithPaginationArgsForCall = append(fake.getStateByPartialCompositeKeyWithPaginationArgsForCall, struct { + arg1 string + arg2 []string + arg3 int32 + arg4 string + }{arg1, arg2Copy, arg3, arg4}) + fake.recordInvocation("GetStateByPartialCompositeKeyWithPagination", []interface{}{arg1, arg2Copy, arg3, arg4}) + fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + if fake.GetStateByPartialCompositeKeyWithPaginationStub != nil { + return fake.GetStateByPartialCompositeKeyWithPaginationStub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getStateByPartialCompositeKeyWithPaginationReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationCallCount() int { + fake.getStateByPartialCompositeKeyWithPaginationMutex.RLock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.RUnlock() + return len(fake.getStateByPartialCompositeKeyWithPaginationArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationCalls(stub func(string, []string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error)) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + fake.GetStateByPartialCompositeKeyWithPaginationStub = stub +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationArgsForCall(i int) (string, []string, int32, string) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.RLock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.RUnlock() + argsForCall := fake.getStateByPartialCompositeKeyWithPaginationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationReturns(result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + fake.GetStateByPartialCompositeKeyWithPaginationStub = nil + fake.getStateByPartialCompositeKeyWithPaginationReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateByPartialCompositeKeyWithPaginationReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByPartialCompositeKeyWithPaginationMutex.Lock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.Unlock() + fake.GetStateByPartialCompositeKeyWithPaginationStub = nil + if fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall == nil { + fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }) + } + fake.getStateByPartialCompositeKeyWithPaginationReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateByRange(arg1 string, arg2 string) (shim.StateQueryIteratorInterface, error) { + fake.getStateByRangeMutex.Lock() + ret, specificReturn := fake.getStateByRangeReturnsOnCall[len(fake.getStateByRangeArgsForCall)] + fake.getStateByRangeArgsForCall = append(fake.getStateByRangeArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetStateByRange", []interface{}{arg1, arg2}) + fake.getStateByRangeMutex.Unlock() + if fake.GetStateByRangeStub != nil { + return fake.GetStateByRangeStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateByRangeReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateByRangeCallCount() int { + fake.getStateByRangeMutex.RLock() + defer fake.getStateByRangeMutex.RUnlock() + return len(fake.getStateByRangeArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByRangeCalls(stub func(string, string) (shim.StateQueryIteratorInterface, error)) { + fake.getStateByRangeMutex.Lock() + defer fake.getStateByRangeMutex.Unlock() + fake.GetStateByRangeStub = stub +} + +func (fake *ChaincodeStub) GetStateByRangeArgsForCall(i int) (string, string) { + fake.getStateByRangeMutex.RLock() + defer fake.getStateByRangeMutex.RUnlock() + argsForCall := fake.getStateByRangeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) GetStateByRangeReturns(result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByRangeMutex.Lock() + defer fake.getStateByRangeMutex.Unlock() + fake.GetStateByRangeStub = nil + fake.getStateByRangeReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByRangeReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 error) { + fake.getStateByRangeMutex.Lock() + defer fake.getStateByRangeMutex.Unlock() + fake.GetStateByRangeStub = nil + if fake.getStateByRangeReturnsOnCall == nil { + fake.getStateByRangeReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 error + }) + } + fake.getStateByRangeReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateByRangeWithPagination(arg1 string, arg2 string, arg3 int32, arg4 string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error) { + fake.getStateByRangeWithPaginationMutex.Lock() + ret, specificReturn := fake.getStateByRangeWithPaginationReturnsOnCall[len(fake.getStateByRangeWithPaginationArgsForCall)] + fake.getStateByRangeWithPaginationArgsForCall = append(fake.getStateByRangeWithPaginationArgsForCall, struct { + arg1 string + arg2 string + arg3 int32 + arg4 string + }{arg1, arg2, arg3, arg4}) + fake.recordInvocation("GetStateByRangeWithPagination", []interface{}{arg1, arg2, arg3, arg4}) + fake.getStateByRangeWithPaginationMutex.Unlock() + if fake.GetStateByRangeWithPaginationStub != nil { + return fake.GetStateByRangeWithPaginationStub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.getStateByRangeWithPaginationReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationCallCount() int { + fake.getStateByRangeWithPaginationMutex.RLock() + defer fake.getStateByRangeWithPaginationMutex.RUnlock() + return len(fake.getStateByRangeWithPaginationArgsForCall) +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationCalls(stub func(string, string, int32, string) (shim.StateQueryIteratorInterface, *peer.QueryResponseMetadata, error)) { + fake.getStateByRangeWithPaginationMutex.Lock() + defer fake.getStateByRangeWithPaginationMutex.Unlock() + fake.GetStateByRangeWithPaginationStub = stub +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationArgsForCall(i int) (string, string, int32, string) { + fake.getStateByRangeWithPaginationMutex.RLock() + defer fake.getStateByRangeWithPaginationMutex.RUnlock() + argsForCall := fake.getStateByRangeWithPaginationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationReturns(result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByRangeWithPaginationMutex.Lock() + defer fake.getStateByRangeWithPaginationMutex.Unlock() + fake.GetStateByRangeWithPaginationStub = nil + fake.getStateByRangeWithPaginationReturns = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateByRangeWithPaginationReturnsOnCall(i int, result1 shim.StateQueryIteratorInterface, result2 *peer.QueryResponseMetadata, result3 error) { + fake.getStateByRangeWithPaginationMutex.Lock() + defer fake.getStateByRangeWithPaginationMutex.Unlock() + fake.GetStateByRangeWithPaginationStub = nil + if fake.getStateByRangeWithPaginationReturnsOnCall == nil { + fake.getStateByRangeWithPaginationReturnsOnCall = make(map[int]struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }) + } + fake.getStateByRangeWithPaginationReturnsOnCall[i] = struct { + result1 shim.StateQueryIteratorInterface + result2 *peer.QueryResponseMetadata + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) GetStateValidationParameter(arg1 string) ([]byte, error) { + fake.getStateValidationParameterMutex.Lock() + ret, specificReturn := fake.getStateValidationParameterReturnsOnCall[len(fake.getStateValidationParameterArgsForCall)] + fake.getStateValidationParameterArgsForCall = append(fake.getStateValidationParameterArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("GetStateValidationParameter", []interface{}{arg1}) + fake.getStateValidationParameterMutex.Unlock() + if fake.GetStateValidationParameterStub != nil { + return fake.GetStateValidationParameterStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateValidationParameterReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetStateValidationParameterCallCount() int { + fake.getStateValidationParameterMutex.RLock() + defer fake.getStateValidationParameterMutex.RUnlock() + return len(fake.getStateValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) GetStateValidationParameterCalls(stub func(string) ([]byte, error)) { + fake.getStateValidationParameterMutex.Lock() + defer fake.getStateValidationParameterMutex.Unlock() + fake.GetStateValidationParameterStub = stub +} + +func (fake *ChaincodeStub) GetStateValidationParameterArgsForCall(i int) string { + fake.getStateValidationParameterMutex.RLock() + defer fake.getStateValidationParameterMutex.RUnlock() + argsForCall := fake.getStateValidationParameterArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) GetStateValidationParameterReturns(result1 []byte, result2 error) { + fake.getStateValidationParameterMutex.Lock() + defer fake.getStateValidationParameterMutex.Unlock() + fake.GetStateValidationParameterStub = nil + fake.getStateValidationParameterReturns = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStateValidationParameterReturnsOnCall(i int, result1 []byte, result2 error) { + fake.getStateValidationParameterMutex.Lock() + defer fake.getStateValidationParameterMutex.Unlock() + fake.GetStateValidationParameterStub = nil + if fake.getStateValidationParameterReturnsOnCall == nil { + fake.getStateValidationParameterReturnsOnCall = make(map[int]struct { + result1 []byte + result2 error + }) + } + fake.getStateValidationParameterReturnsOnCall[i] = struct { + result1 []byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetStringArgs() []string { + fake.getStringArgsMutex.Lock() + ret, specificReturn := fake.getStringArgsReturnsOnCall[len(fake.getStringArgsArgsForCall)] + fake.getStringArgsArgsForCall = append(fake.getStringArgsArgsForCall, struct { + }{}) + fake.recordInvocation("GetStringArgs", []interface{}{}) + fake.getStringArgsMutex.Unlock() + if fake.GetStringArgsStub != nil { + return fake.GetStringArgsStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getStringArgsReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetStringArgsCallCount() int { + fake.getStringArgsMutex.RLock() + defer fake.getStringArgsMutex.RUnlock() + return len(fake.getStringArgsArgsForCall) +} + +func (fake *ChaincodeStub) GetStringArgsCalls(stub func() []string) { + fake.getStringArgsMutex.Lock() + defer fake.getStringArgsMutex.Unlock() + fake.GetStringArgsStub = stub +} + +func (fake *ChaincodeStub) GetStringArgsReturns(result1 []string) { + fake.getStringArgsMutex.Lock() + defer fake.getStringArgsMutex.Unlock() + fake.GetStringArgsStub = nil + fake.getStringArgsReturns = struct { + result1 []string + }{result1} +} + +func (fake *ChaincodeStub) GetStringArgsReturnsOnCall(i int, result1 []string) { + fake.getStringArgsMutex.Lock() + defer fake.getStringArgsMutex.Unlock() + fake.GetStringArgsStub = nil + if fake.getStringArgsReturnsOnCall == nil { + fake.getStringArgsReturnsOnCall = make(map[int]struct { + result1 []string + }) + } + fake.getStringArgsReturnsOnCall[i] = struct { + result1 []string + }{result1} +} + +func (fake *ChaincodeStub) GetTransient() (map[string][]byte, error) { + fake.getTransientMutex.Lock() + ret, specificReturn := fake.getTransientReturnsOnCall[len(fake.getTransientArgsForCall)] + fake.getTransientArgsForCall = append(fake.getTransientArgsForCall, struct { + }{}) + fake.recordInvocation("GetTransient", []interface{}{}) + fake.getTransientMutex.Unlock() + if fake.GetTransientStub != nil { + return fake.GetTransientStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getTransientReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetTransientCallCount() int { + fake.getTransientMutex.RLock() + defer fake.getTransientMutex.RUnlock() + return len(fake.getTransientArgsForCall) +} + +func (fake *ChaincodeStub) GetTransientCalls(stub func() (map[string][]byte, error)) { + fake.getTransientMutex.Lock() + defer fake.getTransientMutex.Unlock() + fake.GetTransientStub = stub +} + +func (fake *ChaincodeStub) GetTransientReturns(result1 map[string][]byte, result2 error) { + fake.getTransientMutex.Lock() + defer fake.getTransientMutex.Unlock() + fake.GetTransientStub = nil + fake.getTransientReturns = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetTransientReturnsOnCall(i int, result1 map[string][]byte, result2 error) { + fake.getTransientMutex.Lock() + defer fake.getTransientMutex.Unlock() + fake.GetTransientStub = nil + if fake.getTransientReturnsOnCall == nil { + fake.getTransientReturnsOnCall = make(map[int]struct { + result1 map[string][]byte + result2 error + }) + } + fake.getTransientReturnsOnCall[i] = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetTxID() string { + fake.getTxIDMutex.Lock() + ret, specificReturn := fake.getTxIDReturnsOnCall[len(fake.getTxIDArgsForCall)] + fake.getTxIDArgsForCall = append(fake.getTxIDArgsForCall, struct { + }{}) + fake.recordInvocation("GetTxID", []interface{}{}) + fake.getTxIDMutex.Unlock() + if fake.GetTxIDStub != nil { + return fake.GetTxIDStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getTxIDReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) GetTxIDCallCount() int { + fake.getTxIDMutex.RLock() + defer fake.getTxIDMutex.RUnlock() + return len(fake.getTxIDArgsForCall) +} + +func (fake *ChaincodeStub) GetTxIDCalls(stub func() string) { + fake.getTxIDMutex.Lock() + defer fake.getTxIDMutex.Unlock() + fake.GetTxIDStub = stub +} + +func (fake *ChaincodeStub) GetTxIDReturns(result1 string) { + fake.getTxIDMutex.Lock() + defer fake.getTxIDMutex.Unlock() + fake.GetTxIDStub = nil + fake.getTxIDReturns = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetTxIDReturnsOnCall(i int, result1 string) { + fake.getTxIDMutex.Lock() + defer fake.getTxIDMutex.Unlock() + fake.GetTxIDStub = nil + if fake.getTxIDReturnsOnCall == nil { + fake.getTxIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.getTxIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *ChaincodeStub) GetTxTimestamp() (*timestamp.Timestamp, error) { + fake.getTxTimestampMutex.Lock() + ret, specificReturn := fake.getTxTimestampReturnsOnCall[len(fake.getTxTimestampArgsForCall)] + fake.getTxTimestampArgsForCall = append(fake.getTxTimestampArgsForCall, struct { + }{}) + fake.recordInvocation("GetTxTimestamp", []interface{}{}) + fake.getTxTimestampMutex.Unlock() + if fake.GetTxTimestampStub != nil { + return fake.GetTxTimestampStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getTxTimestampReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *ChaincodeStub) GetTxTimestampCallCount() int { + fake.getTxTimestampMutex.RLock() + defer fake.getTxTimestampMutex.RUnlock() + return len(fake.getTxTimestampArgsForCall) +} + +func (fake *ChaincodeStub) GetTxTimestampCalls(stub func() (*timestamp.Timestamp, error)) { + fake.getTxTimestampMutex.Lock() + defer fake.getTxTimestampMutex.Unlock() + fake.GetTxTimestampStub = stub +} + +func (fake *ChaincodeStub) GetTxTimestampReturns(result1 *timestamp.Timestamp, result2 error) { + fake.getTxTimestampMutex.Lock() + defer fake.getTxTimestampMutex.Unlock() + fake.GetTxTimestampStub = nil + fake.getTxTimestampReturns = struct { + result1 *timestamp.Timestamp + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) GetTxTimestampReturnsOnCall(i int, result1 *timestamp.Timestamp, result2 error) { + fake.getTxTimestampMutex.Lock() + defer fake.getTxTimestampMutex.Unlock() + fake.GetTxTimestampStub = nil + if fake.getTxTimestampReturnsOnCall == nil { + fake.getTxTimestampReturnsOnCall = make(map[int]struct { + result1 *timestamp.Timestamp + result2 error + }) + } + fake.getTxTimestampReturnsOnCall[i] = struct { + result1 *timestamp.Timestamp + result2 error + }{result1, result2} +} + +func (fake *ChaincodeStub) InvokeChaincode(arg1 string, arg2 [][]byte, arg3 string) peer.Response { + var arg2Copy [][]byte + if arg2 != nil { + arg2Copy = make([][]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.invokeChaincodeMutex.Lock() + ret, specificReturn := fake.invokeChaincodeReturnsOnCall[len(fake.invokeChaincodeArgsForCall)] + fake.invokeChaincodeArgsForCall = append(fake.invokeChaincodeArgsForCall, struct { + arg1 string + arg2 [][]byte + arg3 string + }{arg1, arg2Copy, arg3}) + fake.recordInvocation("InvokeChaincode", []interface{}{arg1, arg2Copy, arg3}) + fake.invokeChaincodeMutex.Unlock() + if fake.InvokeChaincodeStub != nil { + return fake.InvokeChaincodeStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.invokeChaincodeReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) InvokeChaincodeCallCount() int { + fake.invokeChaincodeMutex.RLock() + defer fake.invokeChaincodeMutex.RUnlock() + return len(fake.invokeChaincodeArgsForCall) +} + +func (fake *ChaincodeStub) InvokeChaincodeCalls(stub func(string, [][]byte, string) peer.Response) { + fake.invokeChaincodeMutex.Lock() + defer fake.invokeChaincodeMutex.Unlock() + fake.InvokeChaincodeStub = stub +} + +func (fake *ChaincodeStub) InvokeChaincodeArgsForCall(i int) (string, [][]byte, string) { + fake.invokeChaincodeMutex.RLock() + defer fake.invokeChaincodeMutex.RUnlock() + argsForCall := fake.invokeChaincodeArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) InvokeChaincodeReturns(result1 peer.Response) { + fake.invokeChaincodeMutex.Lock() + defer fake.invokeChaincodeMutex.Unlock() + fake.InvokeChaincodeStub = nil + fake.invokeChaincodeReturns = struct { + result1 peer.Response + }{result1} +} + +func (fake *ChaincodeStub) InvokeChaincodeReturnsOnCall(i int, result1 peer.Response) { + fake.invokeChaincodeMutex.Lock() + defer fake.invokeChaincodeMutex.Unlock() + fake.InvokeChaincodeStub = nil + if fake.invokeChaincodeReturnsOnCall == nil { + fake.invokeChaincodeReturnsOnCall = make(map[int]struct { + result1 peer.Response + }) + } + fake.invokeChaincodeReturnsOnCall[i] = struct { + result1 peer.Response + }{result1} +} + +func (fake *ChaincodeStub) PutPrivateData(arg1 string, arg2 string, arg3 []byte) error { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.putPrivateDataMutex.Lock() + ret, specificReturn := fake.putPrivateDataReturnsOnCall[len(fake.putPrivateDataArgsForCall)] + fake.putPrivateDataArgsForCall = append(fake.putPrivateDataArgsForCall, struct { + arg1 string + arg2 string + arg3 []byte + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("PutPrivateData", []interface{}{arg1, arg2, arg3Copy}) + fake.putPrivateDataMutex.Unlock() + if fake.PutPrivateDataStub != nil { + return fake.PutPrivateDataStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.putPrivateDataReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) PutPrivateDataCallCount() int { + fake.putPrivateDataMutex.RLock() + defer fake.putPrivateDataMutex.RUnlock() + return len(fake.putPrivateDataArgsForCall) +} + +func (fake *ChaincodeStub) PutPrivateDataCalls(stub func(string, string, []byte) error) { + fake.putPrivateDataMutex.Lock() + defer fake.putPrivateDataMutex.Unlock() + fake.PutPrivateDataStub = stub +} + +func (fake *ChaincodeStub) PutPrivateDataArgsForCall(i int) (string, string, []byte) { + fake.putPrivateDataMutex.RLock() + defer fake.putPrivateDataMutex.RUnlock() + argsForCall := fake.putPrivateDataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) PutPrivateDataReturns(result1 error) { + fake.putPrivateDataMutex.Lock() + defer fake.putPrivateDataMutex.Unlock() + fake.PutPrivateDataStub = nil + fake.putPrivateDataReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) PutPrivateDataReturnsOnCall(i int, result1 error) { + fake.putPrivateDataMutex.Lock() + defer fake.putPrivateDataMutex.Unlock() + fake.PutPrivateDataStub = nil + if fake.putPrivateDataReturnsOnCall == nil { + fake.putPrivateDataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.putPrivateDataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) PutState(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.putStateMutex.Lock() + ret, specificReturn := fake.putStateReturnsOnCall[len(fake.putStateArgsForCall)] + fake.putStateArgsForCall = append(fake.putStateArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + fake.recordInvocation("PutState", []interface{}{arg1, arg2Copy}) + fake.putStateMutex.Unlock() + if fake.PutStateStub != nil { + return fake.PutStateStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.putStateReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) PutStateCallCount() int { + fake.putStateMutex.RLock() + defer fake.putStateMutex.RUnlock() + return len(fake.putStateArgsForCall) +} + +func (fake *ChaincodeStub) PutStateCalls(stub func(string, []byte) error) { + fake.putStateMutex.Lock() + defer fake.putStateMutex.Unlock() + fake.PutStateStub = stub +} + +func (fake *ChaincodeStub) PutStateArgsForCall(i int) (string, []byte) { + fake.putStateMutex.RLock() + defer fake.putStateMutex.RUnlock() + argsForCall := fake.putStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) PutStateReturns(result1 error) { + fake.putStateMutex.Lock() + defer fake.putStateMutex.Unlock() + fake.PutStateStub = nil + fake.putStateReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) PutStateReturnsOnCall(i int, result1 error) { + fake.putStateMutex.Lock() + defer fake.putStateMutex.Unlock() + fake.PutStateStub = nil + if fake.putStateReturnsOnCall == nil { + fake.putStateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.putStateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetEvent(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.setEventMutex.Lock() + ret, specificReturn := fake.setEventReturnsOnCall[len(fake.setEventArgsForCall)] + fake.setEventArgsForCall = append(fake.setEventArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + fake.recordInvocation("SetEvent", []interface{}{arg1, arg2Copy}) + fake.setEventMutex.Unlock() + if fake.SetEventStub != nil { + return fake.SetEventStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.setEventReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) SetEventCallCount() int { + fake.setEventMutex.RLock() + defer fake.setEventMutex.RUnlock() + return len(fake.setEventArgsForCall) +} + +func (fake *ChaincodeStub) SetEventCalls(stub func(string, []byte) error) { + fake.setEventMutex.Lock() + defer fake.setEventMutex.Unlock() + fake.SetEventStub = stub +} + +func (fake *ChaincodeStub) SetEventArgsForCall(i int) (string, []byte) { + fake.setEventMutex.RLock() + defer fake.setEventMutex.RUnlock() + argsForCall := fake.setEventArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) SetEventReturns(result1 error) { + fake.setEventMutex.Lock() + defer fake.setEventMutex.Unlock() + fake.SetEventStub = nil + fake.setEventReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetEventReturnsOnCall(i int, result1 error) { + fake.setEventMutex.Lock() + defer fake.setEventMutex.Unlock() + fake.SetEventStub = nil + if fake.setEventReturnsOnCall == nil { + fake.setEventReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setEventReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameter(arg1 string, arg2 string, arg3 []byte) error { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.setPrivateDataValidationParameterMutex.Lock() + ret, specificReturn := fake.setPrivateDataValidationParameterReturnsOnCall[len(fake.setPrivateDataValidationParameterArgsForCall)] + fake.setPrivateDataValidationParameterArgsForCall = append(fake.setPrivateDataValidationParameterArgsForCall, struct { + arg1 string + arg2 string + arg3 []byte + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("SetPrivateDataValidationParameter", []interface{}{arg1, arg2, arg3Copy}) + fake.setPrivateDataValidationParameterMutex.Unlock() + if fake.SetPrivateDataValidationParameterStub != nil { + return fake.SetPrivateDataValidationParameterStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.setPrivateDataValidationParameterReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterCallCount() int { + fake.setPrivateDataValidationParameterMutex.RLock() + defer fake.setPrivateDataValidationParameterMutex.RUnlock() + return len(fake.setPrivateDataValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterCalls(stub func(string, string, []byte) error) { + fake.setPrivateDataValidationParameterMutex.Lock() + defer fake.setPrivateDataValidationParameterMutex.Unlock() + fake.SetPrivateDataValidationParameterStub = stub +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterArgsForCall(i int) (string, string, []byte) { + fake.setPrivateDataValidationParameterMutex.RLock() + defer fake.setPrivateDataValidationParameterMutex.RUnlock() + argsForCall := fake.setPrivateDataValidationParameterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterReturns(result1 error) { + fake.setPrivateDataValidationParameterMutex.Lock() + defer fake.setPrivateDataValidationParameterMutex.Unlock() + fake.SetPrivateDataValidationParameterStub = nil + fake.setPrivateDataValidationParameterReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetPrivateDataValidationParameterReturnsOnCall(i int, result1 error) { + fake.setPrivateDataValidationParameterMutex.Lock() + defer fake.setPrivateDataValidationParameterMutex.Unlock() + fake.SetPrivateDataValidationParameterStub = nil + if fake.setPrivateDataValidationParameterReturnsOnCall == nil { + fake.setPrivateDataValidationParameterReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setPrivateDataValidationParameterReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetStateValidationParameter(arg1 string, arg2 []byte) error { + var arg2Copy []byte + if arg2 != nil { + arg2Copy = make([]byte, len(arg2)) + copy(arg2Copy, arg2) + } + fake.setStateValidationParameterMutex.Lock() + ret, specificReturn := fake.setStateValidationParameterReturnsOnCall[len(fake.setStateValidationParameterArgsForCall)] + fake.setStateValidationParameterArgsForCall = append(fake.setStateValidationParameterArgsForCall, struct { + arg1 string + arg2 []byte + }{arg1, arg2Copy}) + fake.recordInvocation("SetStateValidationParameter", []interface{}{arg1, arg2Copy}) + fake.setStateValidationParameterMutex.Unlock() + if fake.SetStateValidationParameterStub != nil { + return fake.SetStateValidationParameterStub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.setStateValidationParameterReturns + return fakeReturns.result1 +} + +func (fake *ChaincodeStub) SetStateValidationParameterCallCount() int { + fake.setStateValidationParameterMutex.RLock() + defer fake.setStateValidationParameterMutex.RUnlock() + return len(fake.setStateValidationParameterArgsForCall) +} + +func (fake *ChaincodeStub) SetStateValidationParameterCalls(stub func(string, []byte) error) { + fake.setStateValidationParameterMutex.Lock() + defer fake.setStateValidationParameterMutex.Unlock() + fake.SetStateValidationParameterStub = stub +} + +func (fake *ChaincodeStub) SetStateValidationParameterArgsForCall(i int) (string, []byte) { + fake.setStateValidationParameterMutex.RLock() + defer fake.setStateValidationParameterMutex.RUnlock() + argsForCall := fake.setStateValidationParameterArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *ChaincodeStub) SetStateValidationParameterReturns(result1 error) { + fake.setStateValidationParameterMutex.Lock() + defer fake.setStateValidationParameterMutex.Unlock() + fake.SetStateValidationParameterStub = nil + fake.setStateValidationParameterReturns = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SetStateValidationParameterReturnsOnCall(i int, result1 error) { + fake.setStateValidationParameterMutex.Lock() + defer fake.setStateValidationParameterMutex.Unlock() + fake.SetStateValidationParameterStub = nil + if fake.setStateValidationParameterReturnsOnCall == nil { + fake.setStateValidationParameterReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setStateValidationParameterReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *ChaincodeStub) SplitCompositeKey(arg1 string) (string, []string, error) { + fake.splitCompositeKeyMutex.Lock() + ret, specificReturn := fake.splitCompositeKeyReturnsOnCall[len(fake.splitCompositeKeyArgsForCall)] + fake.splitCompositeKeyArgsForCall = append(fake.splitCompositeKeyArgsForCall, struct { + arg1 string + }{arg1}) + fake.recordInvocation("SplitCompositeKey", []interface{}{arg1}) + fake.splitCompositeKeyMutex.Unlock() + if fake.SplitCompositeKeyStub != nil { + return fake.SplitCompositeKeyStub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + fakeReturns := fake.splitCompositeKeyReturns + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *ChaincodeStub) SplitCompositeKeyCallCount() int { + fake.splitCompositeKeyMutex.RLock() + defer fake.splitCompositeKeyMutex.RUnlock() + return len(fake.splitCompositeKeyArgsForCall) +} + +func (fake *ChaincodeStub) SplitCompositeKeyCalls(stub func(string) (string, []string, error)) { + fake.splitCompositeKeyMutex.Lock() + defer fake.splitCompositeKeyMutex.Unlock() + fake.SplitCompositeKeyStub = stub +} + +func (fake *ChaincodeStub) SplitCompositeKeyArgsForCall(i int) string { + fake.splitCompositeKeyMutex.RLock() + defer fake.splitCompositeKeyMutex.RUnlock() + argsForCall := fake.splitCompositeKeyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *ChaincodeStub) SplitCompositeKeyReturns(result1 string, result2 []string, result3 error) { + fake.splitCompositeKeyMutex.Lock() + defer fake.splitCompositeKeyMutex.Unlock() + fake.SplitCompositeKeyStub = nil + fake.splitCompositeKeyReturns = struct { + result1 string + result2 []string + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) SplitCompositeKeyReturnsOnCall(i int, result1 string, result2 []string, result3 error) { + fake.splitCompositeKeyMutex.Lock() + defer fake.splitCompositeKeyMutex.Unlock() + fake.SplitCompositeKeyStub = nil + if fake.splitCompositeKeyReturnsOnCall == nil { + fake.splitCompositeKeyReturnsOnCall = make(map[int]struct { + result1 string + result2 []string + result3 error + }) + } + fake.splitCompositeKeyReturnsOnCall[i] = struct { + result1 string + result2 []string + result3 error + }{result1, result2, result3} +} + +func (fake *ChaincodeStub) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.createCompositeKeyMutex.RLock() + defer fake.createCompositeKeyMutex.RUnlock() + fake.delPrivateDataMutex.RLock() + defer fake.delPrivateDataMutex.RUnlock() + fake.delStateMutex.RLock() + defer fake.delStateMutex.RUnlock() + fake.getArgsMutex.RLock() + defer fake.getArgsMutex.RUnlock() + fake.getArgsSliceMutex.RLock() + defer fake.getArgsSliceMutex.RUnlock() + fake.getBindingMutex.RLock() + defer fake.getBindingMutex.RUnlock() + fake.getChannelIDMutex.RLock() + defer fake.getChannelIDMutex.RUnlock() + fake.getCreatorMutex.RLock() + defer fake.getCreatorMutex.RUnlock() + fake.getDecorationsMutex.RLock() + defer fake.getDecorationsMutex.RUnlock() + fake.getFunctionAndParametersMutex.RLock() + defer fake.getFunctionAndParametersMutex.RUnlock() + fake.getHistoryForKeyMutex.RLock() + defer fake.getHistoryForKeyMutex.RUnlock() + fake.getPrivateDataMutex.RLock() + defer fake.getPrivateDataMutex.RUnlock() + fake.getPrivateDataByPartialCompositeKeyMutex.RLock() + defer fake.getPrivateDataByPartialCompositeKeyMutex.RUnlock() + fake.getPrivateDataByRangeMutex.RLock() + defer fake.getPrivateDataByRangeMutex.RUnlock() + fake.getPrivateDataHashMutex.RLock() + defer fake.getPrivateDataHashMutex.RUnlock() + fake.getPrivateDataQueryResultMutex.RLock() + defer fake.getPrivateDataQueryResultMutex.RUnlock() + fake.getPrivateDataValidationParameterMutex.RLock() + defer fake.getPrivateDataValidationParameterMutex.RUnlock() + fake.getQueryResultMutex.RLock() + defer fake.getQueryResultMutex.RUnlock() + fake.getQueryResultWithPaginationMutex.RLock() + defer fake.getQueryResultWithPaginationMutex.RUnlock() + fake.getSignedProposalMutex.RLock() + defer fake.getSignedProposalMutex.RUnlock() + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + fake.getStateByPartialCompositeKeyMutex.RLock() + defer fake.getStateByPartialCompositeKeyMutex.RUnlock() + fake.getStateByPartialCompositeKeyWithPaginationMutex.RLock() + defer fake.getStateByPartialCompositeKeyWithPaginationMutex.RUnlock() + fake.getStateByRangeMutex.RLock() + defer fake.getStateByRangeMutex.RUnlock() + fake.getStateByRangeWithPaginationMutex.RLock() + defer fake.getStateByRangeWithPaginationMutex.RUnlock() + fake.getStateValidationParameterMutex.RLock() + defer fake.getStateValidationParameterMutex.RUnlock() + fake.getStringArgsMutex.RLock() + defer fake.getStringArgsMutex.RUnlock() + fake.getTransientMutex.RLock() + defer fake.getTransientMutex.RUnlock() + fake.getTxIDMutex.RLock() + defer fake.getTxIDMutex.RUnlock() + fake.getTxTimestampMutex.RLock() + defer fake.getTxTimestampMutex.RUnlock() + fake.invokeChaincodeMutex.RLock() + defer fake.invokeChaincodeMutex.RUnlock() + fake.putPrivateDataMutex.RLock() + defer fake.putPrivateDataMutex.RUnlock() + fake.putStateMutex.RLock() + defer fake.putStateMutex.RUnlock() + fake.setEventMutex.RLock() + defer fake.setEventMutex.RUnlock() + fake.setPrivateDataValidationParameterMutex.RLock() + defer fake.setPrivateDataValidationParameterMutex.RUnlock() + fake.setStateValidationParameterMutex.RLock() + defer fake.setStateValidationParameterMutex.RUnlock() + fake.splitCompositeKeyMutex.RLock() + defer fake.splitCompositeKeyMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *ChaincodeStub) 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 _ contract.ChaincodeStub = new(ChaincodeStub) diff --git a/chaincode/fabcar/go/contract/mocks/statequeryiterator.go b/chaincode/fabcar/go/contract/mocks/statequeryiterator.go new file mode 100644 index 00000000..cea427ce --- /dev/null +++ b/chaincode/fabcar/go/contract/mocks/statequeryiterator.go @@ -0,0 +1,235 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + "github.com/hyperledger/fabric-protos-go/ledger/queryresult" + "github.com/hyperledger/fabric-samples/chaincode/fabcar/go/contract" +) + +type StateQueryIterator struct { + CloseStub func() error + closeMutex sync.RWMutex + closeArgsForCall []struct { + } + closeReturns struct { + result1 error + } + closeReturnsOnCall map[int]struct { + result1 error + } + HasNextStub func() bool + hasNextMutex sync.RWMutex + hasNextArgsForCall []struct { + } + hasNextReturns struct { + result1 bool + } + hasNextReturnsOnCall map[int]struct { + result1 bool + } + NextStub func() (*queryresult.KV, error) + nextMutex sync.RWMutex + nextArgsForCall []struct { + } + nextReturns struct { + result1 *queryresult.KV + result2 error + } + nextReturnsOnCall map[int]struct { + result1 *queryresult.KV + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *StateQueryIterator) Close() error { + fake.closeMutex.Lock() + ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] + fake.closeArgsForCall = append(fake.closeArgsForCall, struct { + }{}) + fake.recordInvocation("Close", []interface{}{}) + fake.closeMutex.Unlock() + if fake.CloseStub != nil { + return fake.CloseStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.closeReturns + return fakeReturns.result1 +} + +func (fake *StateQueryIterator) CloseCallCount() int { + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + return len(fake.closeArgsForCall) +} + +func (fake *StateQueryIterator) CloseCalls(stub func() error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = stub +} + +func (fake *StateQueryIterator) CloseReturns(result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + fake.closeReturns = struct { + result1 error + }{result1} +} + +func (fake *StateQueryIterator) CloseReturnsOnCall(i int, result1 error) { + fake.closeMutex.Lock() + defer fake.closeMutex.Unlock() + fake.CloseStub = nil + if fake.closeReturnsOnCall == nil { + fake.closeReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.closeReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *StateQueryIterator) HasNext() bool { + fake.hasNextMutex.Lock() + ret, specificReturn := fake.hasNextReturnsOnCall[len(fake.hasNextArgsForCall)] + fake.hasNextArgsForCall = append(fake.hasNextArgsForCall, struct { + }{}) + fake.recordInvocation("HasNext", []interface{}{}) + fake.hasNextMutex.Unlock() + if fake.HasNextStub != nil { + return fake.HasNextStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.hasNextReturns + return fakeReturns.result1 +} + +func (fake *StateQueryIterator) HasNextCallCount() int { + fake.hasNextMutex.RLock() + defer fake.hasNextMutex.RUnlock() + return len(fake.hasNextArgsForCall) +} + +func (fake *StateQueryIterator) HasNextCalls(stub func() bool) { + fake.hasNextMutex.Lock() + defer fake.hasNextMutex.Unlock() + fake.HasNextStub = stub +} + +func (fake *StateQueryIterator) HasNextReturns(result1 bool) { + fake.hasNextMutex.Lock() + defer fake.hasNextMutex.Unlock() + fake.HasNextStub = nil + fake.hasNextReturns = struct { + result1 bool + }{result1} +} + +func (fake *StateQueryIterator) HasNextReturnsOnCall(i int, result1 bool) { + fake.hasNextMutex.Lock() + defer fake.hasNextMutex.Unlock() + fake.HasNextStub = nil + if fake.hasNextReturnsOnCall == nil { + fake.hasNextReturnsOnCall = make(map[int]struct { + result1 bool + }) + } + fake.hasNextReturnsOnCall[i] = struct { + result1 bool + }{result1} +} + +func (fake *StateQueryIterator) Next() (*queryresult.KV, error) { + fake.nextMutex.Lock() + ret, specificReturn := fake.nextReturnsOnCall[len(fake.nextArgsForCall)] + fake.nextArgsForCall = append(fake.nextArgsForCall, struct { + }{}) + fake.recordInvocation("Next", []interface{}{}) + fake.nextMutex.Unlock() + if fake.NextStub != nil { + return fake.NextStub() + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.nextReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *StateQueryIterator) NextCallCount() int { + fake.nextMutex.RLock() + defer fake.nextMutex.RUnlock() + return len(fake.nextArgsForCall) +} + +func (fake *StateQueryIterator) NextCalls(stub func() (*queryresult.KV, error)) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = stub +} + +func (fake *StateQueryIterator) NextReturns(result1 *queryresult.KV, result2 error) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = nil + fake.nextReturns = struct { + result1 *queryresult.KV + result2 error + }{result1, result2} +} + +func (fake *StateQueryIterator) NextReturnsOnCall(i int, result1 *queryresult.KV, result2 error) { + fake.nextMutex.Lock() + defer fake.nextMutex.Unlock() + fake.NextStub = nil + if fake.nextReturnsOnCall == nil { + fake.nextReturnsOnCall = make(map[int]struct { + result1 *queryresult.KV + result2 error + }) + } + fake.nextReturnsOnCall[i] = struct { + result1 *queryresult.KV + result2 error + }{result1, result2} +} + +func (fake *StateQueryIterator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.closeMutex.RLock() + defer fake.closeMutex.RUnlock() + fake.hasNextMutex.RLock() + defer fake.hasNextMutex.RUnlock() + fake.nextMutex.RLock() + defer fake.nextMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *StateQueryIterator) 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 _ contract.StateQueryIterator = new(StateQueryIterator) diff --git a/chaincode/fabcar/go/contract/mocks/transaction.go b/chaincode/fabcar/go/contract/mocks/transaction.go new file mode 100644 index 00000000..cf5dde0a --- /dev/null +++ b/chaincode/fabcar/go/contract/mocks/transaction.go @@ -0,0 +1,167 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + "github.com/hyperledger/fabric-chaincode-go/pkg/cid" + "github.com/hyperledger/fabric-chaincode-go/shim" + "github.com/hyperledger/fabric-samples/chaincode/fabcar/go/contract" +) + +type TransactionContext struct { + GetClientIdentityStub func() cid.ClientIdentity + getClientIdentityMutex sync.RWMutex + getClientIdentityArgsForCall []struct { + } + getClientIdentityReturns struct { + result1 cid.ClientIdentity + } + getClientIdentityReturnsOnCall map[int]struct { + result1 cid.ClientIdentity + } + GetStubStub func() shim.ChaincodeStubInterface + getStubMutex sync.RWMutex + getStubArgsForCall []struct { + } + getStubReturns struct { + result1 shim.ChaincodeStubInterface + } + getStubReturnsOnCall map[int]struct { + result1 shim.ChaincodeStubInterface + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *TransactionContext) GetClientIdentity() cid.ClientIdentity { + fake.getClientIdentityMutex.Lock() + ret, specificReturn := fake.getClientIdentityReturnsOnCall[len(fake.getClientIdentityArgsForCall)] + fake.getClientIdentityArgsForCall = append(fake.getClientIdentityArgsForCall, struct { + }{}) + fake.recordInvocation("GetClientIdentity", []interface{}{}) + fake.getClientIdentityMutex.Unlock() + if fake.GetClientIdentityStub != nil { + return fake.GetClientIdentityStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getClientIdentityReturns + return fakeReturns.result1 +} + +func (fake *TransactionContext) GetClientIdentityCallCount() int { + fake.getClientIdentityMutex.RLock() + defer fake.getClientIdentityMutex.RUnlock() + return len(fake.getClientIdentityArgsForCall) +} + +func (fake *TransactionContext) GetClientIdentityCalls(stub func() cid.ClientIdentity) { + fake.getClientIdentityMutex.Lock() + defer fake.getClientIdentityMutex.Unlock() + fake.GetClientIdentityStub = stub +} + +func (fake *TransactionContext) GetClientIdentityReturns(result1 cid.ClientIdentity) { + fake.getClientIdentityMutex.Lock() + defer fake.getClientIdentityMutex.Unlock() + fake.GetClientIdentityStub = nil + fake.getClientIdentityReturns = struct { + result1 cid.ClientIdentity + }{result1} +} + +func (fake *TransactionContext) GetClientIdentityReturnsOnCall(i int, result1 cid.ClientIdentity) { + fake.getClientIdentityMutex.Lock() + defer fake.getClientIdentityMutex.Unlock() + fake.GetClientIdentityStub = nil + if fake.getClientIdentityReturnsOnCall == nil { + fake.getClientIdentityReturnsOnCall = make(map[int]struct { + result1 cid.ClientIdentity + }) + } + fake.getClientIdentityReturnsOnCall[i] = struct { + result1 cid.ClientIdentity + }{result1} +} + +func (fake *TransactionContext) GetStub() shim.ChaincodeStubInterface { + fake.getStubMutex.Lock() + ret, specificReturn := fake.getStubReturnsOnCall[len(fake.getStubArgsForCall)] + fake.getStubArgsForCall = append(fake.getStubArgsForCall, struct { + }{}) + fake.recordInvocation("GetStub", []interface{}{}) + fake.getStubMutex.Unlock() + if fake.GetStubStub != nil { + return fake.GetStubStub() + } + if specificReturn { + return ret.result1 + } + fakeReturns := fake.getStubReturns + return fakeReturns.result1 +} + +func (fake *TransactionContext) GetStubCallCount() int { + fake.getStubMutex.RLock() + defer fake.getStubMutex.RUnlock() + return len(fake.getStubArgsForCall) +} + +func (fake *TransactionContext) GetStubCalls(stub func() shim.ChaincodeStubInterface) { + fake.getStubMutex.Lock() + defer fake.getStubMutex.Unlock() + fake.GetStubStub = stub +} + +func (fake *TransactionContext) GetStubReturns(result1 shim.ChaincodeStubInterface) { + fake.getStubMutex.Lock() + defer fake.getStubMutex.Unlock() + fake.GetStubStub = nil + fake.getStubReturns = struct { + result1 shim.ChaincodeStubInterface + }{result1} +} + +func (fake *TransactionContext) GetStubReturnsOnCall(i int, result1 shim.ChaincodeStubInterface) { + fake.getStubMutex.Lock() + defer fake.getStubMutex.Unlock() + fake.GetStubStub = nil + if fake.getStubReturnsOnCall == nil { + fake.getStubReturnsOnCall = make(map[int]struct { + result1 shim.ChaincodeStubInterface + }) + } + fake.getStubReturnsOnCall[i] = struct { + result1 shim.ChaincodeStubInterface + }{result1} +} + +func (fake *TransactionContext) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.getClientIdentityMutex.RLock() + defer fake.getClientIdentityMutex.RUnlock() + fake.getStubMutex.RLock() + defer fake.getStubMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *TransactionContext) 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 _ contract.TransactionContext = new(TransactionContext) diff --git a/chaincode/fabcar/go/contract/shim.go b/chaincode/fabcar/go/contract/shim.go new file mode 100644 index 00000000..c0add45a --- /dev/null +++ b/chaincode/fabcar/go/contract/shim.go @@ -0,0 +1,21 @@ +package contract + +import ( + "github.com/hyperledger/fabric-chaincode-go/shim" + "github.com/hyperledger/fabric-contract-api-go/contractapi" +) + +//go:generate counterfeiter -o mocks/transaction.go -fake-name TransactionContext . TransactionContext +type TransactionContext interface { + contractapi.TransactionContextInterface +} + +//go:generate counterfeiter -o mocks/chaincodestub.go -fake-name ChaincodeStub . ChaincodeStub +type ChaincodeStub interface { + shim.ChaincodeStubInterface +} + +//go:generate counterfeiter -o mocks/statequeryiterator.go -fake-name StateQueryIterator . StateQueryIterator +type StateQueryIterator interface { + shim.StateQueryIteratorInterface +} diff --git a/chaincode/fabcar/go/contract/smartcontract.go b/chaincode/fabcar/go/contract/smartcontract.go new file mode 100644 index 00000000..744f080d --- /dev/null +++ b/chaincode/fabcar/go/contract/smartcontract.go @@ -0,0 +1,127 @@ +package contract + +import ( + "encoding/json" + "fmt" + + "github.com/hyperledger/fabric-contract-api-go/contractapi" +) + +// SmartContract provides functions for managing a car +type SmartContract struct { + contractapi.Contract +} + +// Car describes basic details of what makes up a car +type Car struct { + Make string `json:"make"` + Model string `json:"model"` + Colour string `json:"colour"` + Owner string `json:"owner"` +} + +// QueryResult structure used for handling result of query +type QueryResult struct { + Key string `json:"Key"` + Record *Car +} + +// InitLedger adds a base set of cars to the ledger +func (s *SmartContract) InitLedger(ctx contractapi.TransactionContextInterface) error { + cars := []Car{ + {Make: "Toyota", Model: "Prius", Colour: "blue", Owner: "Tomoko"}, + {Make: "Ford", Model: "Mustang", Colour: "red", Owner: "Brad"}, + {Make: "Hyundai", Model: "Tucson", Colour: "green", Owner: "Jin Soo"}, + {Make: "Volkswagen", Model: "Passat", Colour: "yellow", Owner: "Max"}, + {Make: "Tesla", Model: "S", Colour: "black", Owner: "Adriana"}, + {Make: "Peugeot", Model: "205", Colour: "purple", Owner: "Michel"}, + {Make: "Chery", Model: "S22L", Colour: "white", Owner: "Aarav"}, + {Make: "Fiat", Model: "Punto", Colour: "violet", Owner: "Pari"}, + {Make: "Tata", Model: "Nano", Colour: "indigo", Owner: "Valeria"}, + {Make: "Holden", Model: "Barina", Colour: "brown", Owner: "Shotaro"}, + } + + for i, car := range cars { + carAsBytes, _ := json.Marshal(car) + key := fmt.Sprintf("CAR%d", i) + err := ctx.GetStub().PutState(key, carAsBytes) + if err != nil { + return fmt.Errorf("failed to put to world state. %v", err) + } + } + + return nil +} + +// CreateCar adds a new car to the world state with given details +func (s *SmartContract) CreateCar(ctx contractapi.TransactionContextInterface, carNumber string, make string, model string, colour string, owner string) error { + car := Car{ + Make: make, + Model: model, + Colour: colour, + Owner: owner, + } + carAsBytes, err := json.Marshal(car) + if err != nil { + return fmt.Errorf("failed marshalling to json: %v", err) + } + return ctx.GetStub().PutState(carNumber, carAsBytes) +} + +// QueryCar returns the car stored in the world state with given id +func (s *SmartContract) QueryCar(ctx contractapi.TransactionContextInterface, carNumber string) (*Car, error) { + carAsBytes, err := ctx.GetStub().GetState(carNumber) + if err != nil { + return nil, fmt.Errorf("failed to read from world state: %v", err) + } + if carAsBytes == nil { + return nil, fmt.Errorf("%s does not exist", carNumber) + } + var car Car + err = json.Unmarshal(carAsBytes, &car) + if err != nil { + return nil, err + } + return &car, nil +} + +// QueryAllCars returns all cars found in world state +func (s *SmartContract) QueryAllCars(ctx contractapi.TransactionContextInterface) ([]QueryResult, error) { + // Return all cars by using empty startKey and endKey + resultsIterator, err := ctx.GetStub().GetStateByRange("", "") + if err != nil { + return nil, err + } + defer resultsIterator.Close() + + var results []QueryResult + for resultsIterator.HasNext() { + queryResponse, err := resultsIterator.Next() + if err != nil { + return nil, err + } + var car *Car + err = json.Unmarshal(queryResponse.Value, &car) + if err != nil { + return nil, fmt.Errorf("failed marshalling to json: %v", err) + } + queryResult := QueryResult{Key: queryResponse.Key, Record: car} + results = append(results, queryResult) + } + return results, nil +} + +// ChangeCarOwner updates the owner field of car with given id in world state +func (s *SmartContract) ChangeCarOwner(ctx contractapi.TransactionContextInterface, carNumber string, newOwner string) error { + car, err := s.QueryCar(ctx, carNumber) + if err != nil { + return err + } + + car.Owner = newOwner + carAsBytes, err := json.Marshal(car) + if err != nil { + return fmt.Errorf("failed marshalling to json: %v", err) + } + return ctx.GetStub().PutState(carNumber, carAsBytes) +} diff --git a/chaincode/fabcar/go/contract/smartcontract_test.go b/chaincode/fabcar/go/contract/smartcontract_test.go new file mode 100644 index 00000000..36a47748 --- /dev/null +++ b/chaincode/fabcar/go/contract/smartcontract_test.go @@ -0,0 +1,133 @@ +package contract_test + +import ( + "encoding/json" + "fmt" + "testing" + + "github.com/hyperledger/fabric-protos-go/ledger/queryresult" + "github.com/hyperledger/fabric-samples/chaincode/fabcar/go/contract" + "github.com/hyperledger/fabric-samples/chaincode/fabcar/go/contract/mocks" + "github.com/stretchr/testify/require" +) + +func TestInitLedger(t *testing.T) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + fabcar := &contract.SmartContract{} + err := fabcar.InitLedger(transactionContext) + require.NoError(t, err) + + chaincodeStub.PutStateReturns(fmt.Errorf("failed inserting key")) + err = fabcar.InitLedger(transactionContext) + require.EqualError(t, err, "failed to put to world state. failed inserting key") +} + +func TestCreateCar(t *testing.T) { + chaincodeStub := &mocks.ChaincodeStub{} + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + fabcar := &contract.SmartContract{} + err := fabcar.CreateCar(transactionContext, "CAR1", "Ford", "F150", "red", "Tim") + require.NoError(t, err) + + chaincodeStub.PutStateReturns(fmt.Errorf("failed inserting key")) + err = fabcar.CreateCar(transactionContext, "CAR1", "Ford", "F150", "red", "Tim") + require.EqualError(t, err, "failed inserting key") + +} + +func TestQueryCar(t *testing.T) { + car := &contract.Car{ + Make: "Ford", + Model: "F150", + Colour: "red", + Owner: "Tim", + } + bytes, err := json.Marshal(car) + require.NoError(t, err) + + chaincodeStub := &mocks.ChaincodeStub{} + chaincodeStub.GetStateReturns(bytes, nil) + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + fabcar := &contract.SmartContract{} + car, err = fabcar.QueryCar(transactionContext, "CAR1") + require.NoError(t, err) + require.NotNil(t, car) + + chaincodeStub.GetStateReturns(nil, nil) + car, err = fabcar.QueryCar(transactionContext, "CAR1") + require.EqualError(t, err, "CAR1 does not exist") + require.Nil(t, car) + + chaincodeStub.GetStateReturns([]byte{}, fmt.Errorf("failed retrieving key")) + car, err = fabcar.QueryCar(transactionContext, "CAR1") + require.Nil(t, car) + require.EqualError(t, err, "failed to read from world state: failed retrieving key") +} + +func TestQueryAllCars(t *testing.T) { + car := &contract.Car{ + Make: "Ford", + Model: "F150", + Colour: "red", + Owner: "Tim", + } + bytes, err := json.Marshal(car) + require.NoError(t, err) + + iterator := &mocks.StateQueryIterator{} + iterator.HasNextReturnsOnCall(0, true) + iterator.HasNextReturnsOnCall(1, false) + iterator.NextReturns(&queryresult.KV{Value: bytes}, nil) + + chaincodeStub := &mocks.ChaincodeStub{} + chaincodeStub.GetStateByRangeReturns(iterator, nil) + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + fabcar := &contract.SmartContract{} + cars, err := fabcar.QueryAllCars(transactionContext) + require.NoError(t, err) + require.NotNil(t, cars) + + iterator.HasNextReturns(true) + iterator.NextReturns(nil, fmt.Errorf("failed retrieving next item")) + cars, err = fabcar.QueryAllCars(transactionContext) + require.EqualError(t, err, "failed retrieving next item") + require.Nil(t, cars) + + chaincodeStub.GetStateByRangeReturns(nil, fmt.Errorf("failed retrieving all cars")) + cars, err = fabcar.QueryAllCars(transactionContext) + require.EqualError(t, err, "failed retrieving all cars") + require.Nil(t, cars) +} + +func TestChangeCarOwner(t *testing.T) { + car := &contract.Car{ + Make: "Ford", + Model: "F150", + Colour: "red", + Owner: "Tim", + } + bytes, err := json.Marshal(car) + require.NoError(t, err) + + chaincodeStub := &mocks.ChaincodeStub{} + chaincodeStub.GetStateReturns(bytes, nil) + transactionContext := &mocks.TransactionContext{} + transactionContext.GetStubReturns(chaincodeStub) + + fabcar := &contract.SmartContract{} + err = fabcar.ChangeCarOwner(transactionContext, "CAR1", "Ben") + require.NoError(t, err) + + chaincodeStub.GetStateReturns(nil, nil) + err = fabcar.ChangeCarOwner(transactionContext, "CAR1", "Ben") + require.EqualError(t, err, "CAR1 does not exist") +} diff --git a/chaincode/fabcar/go/fabcar.go b/chaincode/fabcar/go/fabcar.go index 3cc666ae..abf17f1c 100644 --- a/chaincode/fabcar/go/fabcar.go +++ b/chaincode/fabcar/go/fabcar.go @@ -5,135 +5,14 @@ SPDX-License-Identifier: Apache-2.0 package main import ( - "encoding/json" - "fmt" "log" "github.com/hyperledger/fabric-contract-api-go/contractapi" + "github.com/hyperledger/fabric-samples/chaincode/fabcar/go/contract" ) -// SmartContract provides functions for managing a car -type SmartContract struct { - contractapi.Contract -} - -// Car describes basic details of what makes up a car -type Car struct { - Make string `json:"make"` - Model string `json:"model"` - Colour string `json:"colour"` - Owner string `json:"owner"` -} - -// QueryResult structure used for handling result of query -type QueryResult struct { - Key string `json:"Key"` - Record *Car -} - -// InitLedger adds a base set of cars to the ledger -func (s *SmartContract) InitLedger(ctx contractapi.TransactionContextInterface) error { - cars := []Car{ - {Make: "Toyota", Model: "Prius", Colour: "blue", Owner: "Tomoko"}, - {Make: "Ford", Model: "Mustang", Colour: "red", Owner: "Brad"}, - {Make: "Hyundai", Model: "Tucson", Colour: "green", Owner: "Jin Soo"}, - {Make: "Volkswagen", Model: "Passat", Colour: "yellow", Owner: "Max"}, - {Make: "Tesla", Model: "S", Colour: "black", Owner: "Adriana"}, - {Make: "Peugeot", Model: "205", Colour: "purple", Owner: "Michel"}, - {Make: "Chery", Model: "S22L", Colour: "white", Owner: "Aarav"}, - {Make: "Fiat", Model: "Punto", Colour: "violet", Owner: "Pari"}, - {Make: "Tata", Model: "Nano", Colour: "indigo", Owner: "Valeria"}, - {Make: "Holden", Model: "Barina", Colour: "brown", Owner: "Shotaro"}, - } - - for i, car := range cars { - carAsBytes, _ := json.Marshal(car) - key := fmt.Sprintf("CAR%d", i) - err := ctx.GetStub().PutState(key, carAsBytes) - if err != nil { - return fmt.Errorf("failed to put to world state. %v", err) - } - } - - return nil -} - -// CreateCar adds a new car to the world state with given details -func (s *SmartContract) CreateCar(ctx contractapi.TransactionContextInterface, carNumber string, make string, model string, colour string, owner string) error { - car := Car{ - Make: make, - Model: model, - Colour: colour, - Owner: owner, - } - carAsBytes, err := json.Marshal(car) - if err != nil { - return fmt.Errorf("failed marshalling to json: %v", err) - } - return ctx.GetStub().PutState(carNumber, carAsBytes) -} - -// QueryCar returns the car stored in the world state with given id -func (s *SmartContract) QueryCar(ctx contractapi.TransactionContextInterface, carNumber string) (*Car, error) { - carAsBytes, err := ctx.GetStub().GetState(carNumber) - if err != nil { - return nil, fmt.Errorf("failed to read from world state: %v", err) - } - if carAsBytes == nil { - return nil, fmt.Errorf("%s does not exist", carNumber) - } - var car *Car - err = json.Unmarshal(carAsBytes, car) - if err != nil { - return nil, err - } - return car, nil -} - -// QueryAllCars returns all cars found in world state -func (s *SmartContract) QueryAllCars(ctx contractapi.TransactionContextInterface) ([]QueryResult, error) { - // Return all cars by using empty startKey and endKey - resultsIterator, err := ctx.GetStub().GetStateByRange("", "") - if err != nil { - return nil, err - } - defer resultsIterator.Close() - - var results []QueryResult - for resultsIterator.HasNext() { - queryResponse, err := resultsIterator.Next() - if err != nil { - return nil, err - } - - var car *Car - err = json.Unmarshal(queryResponse.Value, car) - if err != nil { - return nil, fmt.Errorf("failed marshalling to json: %v", err) - } - queryResult := QueryResult{Key: queryResponse.Key, Record: car} - results = append(results, queryResult) - } - return results, nil -} - -// ChangeCarOwner updates the owner field of car with given id in world state -func (s *SmartContract) ChangeCarOwner(ctx contractapi.TransactionContextInterface, carNumber string, newOwner string) error { - car, err := s.QueryCar(ctx, carNumber) - if err != nil { - return err - } - - car.Owner = newOwner - carAsBytes, err := json.Marshal(car) - if err != nil { - return fmt.Errorf("failed marshalling to json: %v", err) - } - return ctx.GetStub().PutState(carNumber, carAsBytes) -} - func main() { - chaincode, err := contractapi.NewChaincode(&SmartContract{}) + chaincode, err := contractapi.NewChaincode(&contract.SmartContract{}) if err != nil { log.Panicf("Error create fabcar chaincode: %v", err) } diff --git a/chaincode/fabcar/go/go.mod b/chaincode/fabcar/go/go.mod index 6ae88ed0..6b2408ff 100644 --- a/chaincode/fabcar/go/go.mod +++ b/chaincode/fabcar/go/go.mod @@ -2,4 +2,11 @@ module github.com/hyperledger/fabric-samples/chaincode/fabcar/go go 1.13 -require github.com/hyperledger/fabric-contract-api-go v1.1.0 +require ( + github.com/hyperledger/fabric-contract-api-go v1.1.0 + github.com/golang/protobuf v1.3.2 + github.com/hyperledger/fabric-chaincode-go v0.0.0-20200424173110-d7076418f212 + github.com/hyperledger/fabric-contract-api-go v1.1.0 + github.com/hyperledger/fabric-protos-go v0.0.0-20200424173316-dd554ba3746e + github.com/stretchr/testify v1.5.1 +)