Add unit test in idiomatic go, original changes from PR

Signed-off-by: Sijo Cherian <sijo@ibm.com>

asset-transfer-private-data/chaincode-go/chaincode/asset_queries.go

@@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved.
 SPDX-License-Identifier: Apache-2.0
 */
 
-package main
+package chaincode
 
 import (
 	"encoding/json"
@@ -20,7 +20,7 @@ func (s *SmartContract) ReadAsset(ctx contractapi.TransactionContextInterface, a
 	log.Printf("ReadAsset: collection %v, ID %v", assetCollection, assetID)
 	assetJSON, err := ctx.GetStub().GetPrivateData(assetCollection, assetID) //get the asset from chaincode state
 	if err != nil {
-		return nil, fmt.Errorf("failed to read from asset %v", err)
+		return nil, fmt.Errorf("failed to read asset: %v", err)
 	}
 
 	//No Asset found, return empty response
@@ -44,7 +44,7 @@ func (s *SmartContract) ReadAssetPrivateDetails(ctx contractapi.TransactionConte
 	log.Printf("ReadAssetPrivateDetails: collection %v, ID %v", collection, assetID)
 	assetDetailsJSON, err := ctx.GetStub().GetPrivateData(collection, assetID) // Get the asset from chaincode state
 	if err != nil {
-		return nil, fmt.Errorf("failed to read from asset details %v", err)
+		return nil, fmt.Errorf("failed to read asset details: %v", err)
 	}
 	if assetDetailsJSON == nil {
 		log.Printf("AssetPrivateDetails for %v does not exist in collection %v", assetID, collection)

asset-transfer-private-data/chaincode-go/chaincode/asset_transfer.go

@@ -4,7 +4,7 @@ Copyright IBM Corp. All Rights Reserved.
 SPDX-License-Identifier: Apache-2.0
 */
 
-package main
+package chaincode
 
 import (
 	"bytes"
@@ -19,6 +19,11 @@ import (
 const assetCollection = "assetCollection"
 const transferAgreementObjectType = "transferAgreement"
 
+// SmartContract of this fabric sample
+type SmartContract struct {
+	contractapi.Contract
+}
+
 // Asset describes main asset details that are visible to all organizations
 type Asset struct {
 	Type  string `json:"objectType"` //Type is used to distinguish the various types of objects in state database
@@ -40,11 +45,6 @@ type TransferAgreement struct {
 	BuyerID string `json:"buyerID"`
 }
 
-// SmartContract of this fabric sample
-type SmartContract struct {
-	contractapi.Contract
-}
-
 // CreateAsset creates a new asset by placing the main asset details in the assetCollection
 // that can be read by both organizations. The appraisal value is stored in the owners org specific collection.
 func (s *SmartContract) CreateAsset(ctx contractapi.TransactionContextInterface) error {
@@ -281,9 +281,11 @@ func (s *SmartContract) TransferAsset(ctx contractapi.TransactionContextInterfac
 	// Read asset from the private data collection
 	asset, err := s.ReadAsset(ctx, assetTransferInput.ID)
 	if err != nil {
-		return fmt.Errorf("failed to get asset: %v", err)
+		return fmt.Errorf("error reading asset: %v", err)
+	}
+	if asset == nil {
+		return fmt.Errorf("%v does not exist", assetTransferInput.ID)
 	}
-
 	// Verify that the client is submitting request to peer in their organization
 	err = verifyClientOrgMatchesPeerOrg(ctx)
 	if err != nil {
@@ -569,17 +571,3 @@ func verifyClientOrgMatchesPeerOrg(ctx contractapi.TransactionContextInterface)
 
 	return nil
 }
-
-func main() {
-
-	chaincode, err := contractapi.NewChaincode(new(SmartContract))
-
-	if err != nil {
-		log.Panicf("error creating the chaincode: %v", err)
-		return
-	}
-
-	if err := chaincode.Start(); err != nil {
-		log.Panicf("error starting the chaincode: %v", err)
-	}
-}

asset-transfer-private-data/chaincode-go/chaincode/mocks/clientIdentity.go

@@ -0,0 +1,399 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package mocks
+
+import (
+	"crypto/x509"
+	"sync"
+)
+
+type ClientIdentity struct {
+	AssertAttributeValueStub        func(string, string) error
+	assertAttributeValueMutex       sync.RWMutex
+	assertAttributeValueArgsForCall []struct {
+		arg1 string
+		arg2 string
+	}
+	assertAttributeValueReturns struct {
+		result1 error
+	}
+	assertAttributeValueReturnsOnCall map[int]struct {
+		result1 error
+	}
+	GetAttributeValueStub        func(string) (string, bool, error)
+	getAttributeValueMutex       sync.RWMutex
+	getAttributeValueArgsForCall []struct {
+		arg1 string
+	}
+	getAttributeValueReturns struct {
+		result1 string
+		result2 bool
+		result3 error
+	}
+	getAttributeValueReturnsOnCall map[int]struct {
+		result1 string
+		result2 bool
+		result3 error
+	}
+	GetIDStub        func() (string, error)
+	getIDMutex       sync.RWMutex
+	getIDArgsForCall []struct {
+	}
+	getIDReturns struct {
+		result1 string
+		result2 error
+	}
+	getIDReturnsOnCall map[int]struct {
+		result1 string
+		result2 error
+	}
+	GetMSPIDStub        func() (string, error)
+	getMSPIDMutex       sync.RWMutex
+	getMSPIDArgsForCall []struct {
+	}
+	getMSPIDReturns struct {
+		result1 string
+		result2 error
+	}
+	getMSPIDReturnsOnCall map[int]struct {
+		result1 string
+		result2 error
+	}
+	GetX509CertificateStub        func() (*x509.Certificate, error)
+	getX509CertificateMutex       sync.RWMutex
+	getX509CertificateArgsForCall []struct {
+	}
+	getX509CertificateReturns struct {
+		result1 *x509.Certificate
+		result2 error
+	}
+	getX509CertificateReturnsOnCall map[int]struct {
+		result1 *x509.Certificate
+		result2 error
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *ClientIdentity) AssertAttributeValue(arg1 string, arg2 string) error {
+	fake.assertAttributeValueMutex.Lock()
+	ret, specificReturn := fake.assertAttributeValueReturnsOnCall[len(fake.assertAttributeValueArgsForCall)]
+	fake.assertAttributeValueArgsForCall = append(fake.assertAttributeValueArgsForCall, struct {
+		arg1 string
+		arg2 string
+	}{arg1, arg2})
+	fake.recordInvocation("AssertAttributeValue", []interface{}{arg1, arg2})
+	fake.assertAttributeValueMutex.Unlock()
+	if fake.AssertAttributeValueStub != nil {
+		return fake.AssertAttributeValueStub(arg1, arg2)
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	fakeReturns := fake.assertAttributeValueReturns
+	return fakeReturns.result1
+}
+
+func (fake *ClientIdentity) AssertAttributeValueCallCount() int {
+	fake.assertAttributeValueMutex.RLock()
+	defer fake.assertAttributeValueMutex.RUnlock()
+	return len(fake.assertAttributeValueArgsForCall)
+}
+
+func (fake *ClientIdentity) AssertAttributeValueCalls(stub func(string, string) error) {
+	fake.assertAttributeValueMutex.Lock()
+	defer fake.assertAttributeValueMutex.Unlock()
+	fake.AssertAttributeValueStub = stub
+}
+
+func (fake *ClientIdentity) AssertAttributeValueArgsForCall(i int) (string, string) {
+	fake.assertAttributeValueMutex.RLock()
+	defer fake.assertAttributeValueMutex.RUnlock()
+	argsForCall := fake.assertAttributeValueArgsForCall[i]
+	return argsForCall.arg1, argsForCall.arg2
+}
+
+func (fake *ClientIdentity) AssertAttributeValueReturns(result1 error) {
+	fake.assertAttributeValueMutex.Lock()
+	defer fake.assertAttributeValueMutex.Unlock()
+	fake.AssertAttributeValueStub = nil
+	fake.assertAttributeValueReturns = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *ClientIdentity) AssertAttributeValueReturnsOnCall(i int, result1 error) {
+	fake.assertAttributeValueMutex.Lock()
+	defer fake.assertAttributeValueMutex.Unlock()
+	fake.AssertAttributeValueStub = nil
+	if fake.assertAttributeValueReturnsOnCall == nil {
+		fake.assertAttributeValueReturnsOnCall = make(map[int]struct {
+			result1 error
+		})
+	}
+	fake.assertAttributeValueReturnsOnCall[i] = struct {
+		result1 error
+	}{result1}
+}
+
+func (fake *ClientIdentity) GetAttributeValue(arg1 string) (string, bool, error) {
+	fake.getAttributeValueMutex.Lock()
+	ret, specificReturn := fake.getAttributeValueReturnsOnCall[len(fake.getAttributeValueArgsForCall)]
+	fake.getAttributeValueArgsForCall = append(fake.getAttributeValueArgsForCall, struct {
+		arg1 string
+	}{arg1})
+	fake.recordInvocation("GetAttributeValue", []interface{}{arg1})
+	fake.getAttributeValueMutex.Unlock()
+	if fake.GetAttributeValueStub != nil {
+		return fake.GetAttributeValueStub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2, ret.result3
+	}
+	fakeReturns := fake.getAttributeValueReturns
+	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
+}
+
+func (fake *ClientIdentity) GetAttributeValueCallCount() int {
+	fake.getAttributeValueMutex.RLock()
+	defer fake.getAttributeValueMutex.RUnlock()
+	return len(fake.getAttributeValueArgsForCall)
+}
+
+func (fake *ClientIdentity) GetAttributeValueCalls(stub func(string) (string, bool, error)) {
+	fake.getAttributeValueMutex.Lock()
+	defer fake.getAttributeValueMutex.Unlock()
+	fake.GetAttributeValueStub = stub
+}
+
+func (fake *ClientIdentity) GetAttributeValueArgsForCall(i int) string {
+	fake.getAttributeValueMutex.RLock()
+	defer fake.getAttributeValueMutex.RUnlock()
+	argsForCall := fake.getAttributeValueArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *ClientIdentity) GetAttributeValueReturns(result1 string, result2 bool, result3 error) {
+	fake.getAttributeValueMutex.Lock()
+	defer fake.getAttributeValueMutex.Unlock()
+	fake.GetAttributeValueStub = nil
+	fake.getAttributeValueReturns = struct {
+		result1 string
+		result2 bool
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *ClientIdentity) GetAttributeValueReturnsOnCall(i int, result1 string, result2 bool, result3 error) {
+	fake.getAttributeValueMutex.Lock()
+	defer fake.getAttributeValueMutex.Unlock()
+	fake.GetAttributeValueStub = nil
+	if fake.getAttributeValueReturnsOnCall == nil {
+		fake.getAttributeValueReturnsOnCall = make(map[int]struct {
+			result1 string
+			result2 bool
+			result3 error
+		})
+	}
+	fake.getAttributeValueReturnsOnCall[i] = struct {
+		result1 string
+		result2 bool
+		result3 error
+	}{result1, result2, result3}
+}
+
+func (fake *ClientIdentity) GetID() (string, error) {
+	fake.getIDMutex.Lock()
+	ret, specificReturn := fake.getIDReturnsOnCall[len(fake.getIDArgsForCall)]
+	fake.getIDArgsForCall = append(fake.getIDArgsForCall, struct {
+	}{})
+	fake.recordInvocation("GetID", []interface{}{})
+	fake.getIDMutex.Unlock()
+	if fake.GetIDStub != nil {
+		return fake.GetIDStub()
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	fakeReturns := fake.getIDReturns
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ClientIdentity) GetIDCallCount() int {
+	fake.getIDMutex.RLock()
+	defer fake.getIDMutex.RUnlock()
+	return len(fake.getIDArgsForCall)
+}
+
+func (fake *ClientIdentity) GetIDCalls(stub func() (string, error)) {
+	fake.getIDMutex.Lock()
+	defer fake.getIDMutex.Unlock()
+	fake.GetIDStub = stub
+}
+
+func (fake *ClientIdentity) GetIDReturns(result1 string, result2 error) {
+	fake.getIDMutex.Lock()
+	defer fake.getIDMutex.Unlock()
+	fake.GetIDStub = nil
+	fake.getIDReturns = struct {
+		result1 string
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *ClientIdentity) GetIDReturnsOnCall(i int, result1 string, result2 error) {
+	fake.getIDMutex.Lock()
+	defer fake.getIDMutex.Unlock()
+	fake.GetIDStub = nil
+	if fake.getIDReturnsOnCall == nil {
+		fake.getIDReturnsOnCall = make(map[int]struct {
+			result1 string
+			result2 error
+		})
+	}
+	fake.getIDReturnsOnCall[i] = struct {
+		result1 string
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *ClientIdentity) GetMSPID() (string, error) {
+	fake.getMSPIDMutex.Lock()
+	ret, specificReturn := fake.getMSPIDReturnsOnCall[len(fake.getMSPIDArgsForCall)]
+	fake.getMSPIDArgsForCall = append(fake.getMSPIDArgsForCall, struct {
+	}{})
+	fake.recordInvocation("GetMSPID", []interface{}{})
+	fake.getMSPIDMutex.Unlock()
+	if fake.GetMSPIDStub != nil {
+		return fake.GetMSPIDStub()
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	fakeReturns := fake.getMSPIDReturns
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ClientIdentity) GetMSPIDCallCount() int {
+	fake.getMSPIDMutex.RLock()
+	defer fake.getMSPIDMutex.RUnlock()
+	return len(fake.getMSPIDArgsForCall)
+}
+
+func (fake *ClientIdentity) GetMSPIDCalls(stub func() (string, error)) {
+	fake.getMSPIDMutex.Lock()
+	defer fake.getMSPIDMutex.Unlock()
+	fake.GetMSPIDStub = stub
+}
+
+func (fake *ClientIdentity) GetMSPIDReturns(result1 string, result2 error) {
+	fake.getMSPIDMutex.Lock()
+	defer fake.getMSPIDMutex.Unlock()
+	fake.GetMSPIDStub = nil
+	fake.getMSPIDReturns = struct {
+		result1 string
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *ClientIdentity) GetMSPIDReturnsOnCall(i int, result1 string, result2 error) {
+	fake.getMSPIDMutex.Lock()
+	defer fake.getMSPIDMutex.Unlock()
+	fake.GetMSPIDStub = nil
+	if fake.getMSPIDReturnsOnCall == nil {
+		fake.getMSPIDReturnsOnCall = make(map[int]struct {
+			result1 string
+			result2 error
+		})
+	}
+	fake.getMSPIDReturnsOnCall[i] = struct {
+		result1 string
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *ClientIdentity) GetX509Certificate() (*x509.Certificate, error) {
+	fake.getX509CertificateMutex.Lock()
+	ret, specificReturn := fake.getX509CertificateReturnsOnCall[len(fake.getX509CertificateArgsForCall)]
+	fake.getX509CertificateArgsForCall = append(fake.getX509CertificateArgsForCall, struct {
+	}{})
+	fake.recordInvocation("GetX509Certificate", []interface{}{})
+	fake.getX509CertificateMutex.Unlock()
+	if fake.GetX509CertificateStub != nil {
+		return fake.GetX509CertificateStub()
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	fakeReturns := fake.getX509CertificateReturns
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *ClientIdentity) GetX509CertificateCallCount() int {
+	fake.getX509CertificateMutex.RLock()
+	defer fake.getX509CertificateMutex.RUnlock()
+	return len(fake.getX509CertificateArgsForCall)
+}
+
+func (fake *ClientIdentity) GetX509CertificateCalls(stub func() (*x509.Certificate, error)) {
+	fake.getX509CertificateMutex.Lock()
+	defer fake.getX509CertificateMutex.Unlock()
+	fake.GetX509CertificateStub = stub
+}
+
+func (fake *ClientIdentity) GetX509CertificateReturns(result1 *x509.Certificate, result2 error) {
+	fake.getX509CertificateMutex.Lock()
+	defer fake.getX509CertificateMutex.Unlock()
+	fake.GetX509CertificateStub = nil
+	fake.getX509CertificateReturns = struct {
+		result1 *x509.Certificate
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *ClientIdentity) GetX509CertificateReturnsOnCall(i int, result1 *x509.Certificate, result2 error) {
+	fake.getX509CertificateMutex.Lock()
+	defer fake.getX509CertificateMutex.Unlock()
+	fake.GetX509CertificateStub = nil
+	if fake.getX509CertificateReturnsOnCall == nil {
+		fake.getX509CertificateReturnsOnCall = make(map[int]struct {
+			result1 *x509.Certificate
+			result2 error
+		})
+	}
+	fake.getX509CertificateReturnsOnCall[i] = struct {
+		result1 *x509.Certificate
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *ClientIdentity) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.assertAttributeValueMutex.RLock()
+	defer fake.assertAttributeValueMutex.RUnlock()
+	fake.getAttributeValueMutex.RLock()
+	defer fake.getAttributeValueMutex.RUnlock()
+	fake.getIDMutex.RLock()
+	defer fake.getIDMutex.RUnlock()
+	fake.getMSPIDMutex.RLock()
+	defer fake.getMSPIDMutex.RUnlock()
+	fake.getX509CertificateMutex.RLock()
+	defer fake.getX509CertificateMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *ClientIdentity) 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)
+}

asset-transfer-private-data/chaincode-go/chaincode/mocks/statequeryiterator.go

@@ -0,0 +1,232 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package mocks
+
+import (
+	"sync"
+
+	"github.com/hyperledger/fabric-protos-go/ledger/queryresult"
+)
+
+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)
+}

asset-transfer-private-data/chaincode-go/chaincode/mocks/transaction.go

@@ -0,0 +1,164 @@
+// 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"
+)
+
+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)
+}

asset-transfer-private-data/chaincode-go/go.mod

@@ -1,4 +1,4 @@
-module github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/go
+module github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go
 
 go 1.14
 
@@ -11,14 +11,15 @@ require (
 	github.com/golang/protobuf v1.4.2 // indirect
 	github.com/hyperledger/fabric-chaincode-go v0.0.0-20200511190512-bcfeb58dd83a
 	github.com/hyperledger/fabric-contract-api-go v1.1.0
-	github.com/hyperledger/fabric-protos-go v0.0.0-20200707132912-fee30f3ccd23 // indirect
+	github.com/hyperledger/fabric-protos-go v0.0.0-20200707132912-fee30f3ccd23
 	github.com/mailru/easyjson v0.7.1 // indirect
 	github.com/rogpeppe/go-internal v1.6.0 // indirect
+	github.com/stretchr/testify v1.5.1
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
 	golang.org/x/net v0.0.0-20200707034311-ab3426394381 // indirect
 	golang.org/x/sys v0.0.0-20200720211630-cb9d2d5c5666 // indirect
 	google.golang.org/genproto v0.0.0-20200721032028-5044d0edf986 // indirect
 	google.golang.org/grpc v1.30.0 // indirect
-	google.golang.org/protobuf v1.25.0 // indirect
+	google.golang.org/protobuf v1.25.0
 	gopkg.in/yaml.v2 v2.3.0 // indirect
 )

asset-transfer-private-data/chaincode-go/main.go

@@ -0,0 +1,23 @@
+/*
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package main
+
+import (
+	"log"
+
+	"github.com/hyperledger/fabric-contract-api-go/contractapi"
+	"github.com/hyperledger/fabric-samples/asset-transfer-private-data/chaincode-go/chaincode"
+)
+
+func main() {
+	assetChaincode, err := contractapi.NewChaincode(&chaincode.SmartContract{})
+	if err != nil {
+		log.Panicf("Error creating asset-transfer-private-data chaincode: %v", err)
+	}
+
+	if err := assetChaincode.Start(); err != nil {
+		log.Panicf("Error starting asset-transfer-private-data chaincode: %v", err)
+	}
+}