[FAB-16525] Integration tests for marbles APIs

This CR includes
- FAB-16525 IT test additions to exercise all APIs
  of marbles chaincode
- FAB-16304 Integration tests for GetHistoryForKey

Change-Id: Ib7512c9503b76e69a9c88b92acbfe4251b7d507a
Signed-off-by: Wenjian Qiao <wenjianq@gmail.com>

Author: wenjianqiao

integration/ledger/marbles_test.go

@@ -0,0 +1,382 @@
+/*
+Copyright IBM Corp All Rights Reserved.
+
+SPDX-License-Identifier: Apache-2.0
+*/
+
+package ledger
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"syscall"
+
+	"github.com/hyperledger/fabric/integration/nwo"
+	"github.com/hyperledger/fabric/integration/nwo/commands"
+	"github.com/hyperledger/fabric/integration/runner"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/gexec"
+	"github.com/tedsuo/ifrit"
+)
+
+var _ bool = Describe("all shim APIs for non-private data", func() {
+	var (
+		setup     *setup
+		helper    *marblesTestHelper
+		chaincode nwo.Chaincode
+	)
+
+	BeforeEach(func() {
+		setup = initThreeOrgsSetup()
+		helper = &marblesTestHelper{
+			networkHelper: &networkHelper{
+				Network:   setup.network,
+				orderer:   setup.orderer,
+				peers:     setup.peers,
+				testDir:   setup.testDir,
+				channelID: setup.channelID,
+			},
+		}
+
+		chaincode = nwo.Chaincode{
+			Name:            "marbles",
+			Version:         "0.0",
+			Path:            "github.com/hyperledger/fabric/integration/chaincode/marbles/cmdwithindexspecs",
+			Lang:            "golang",
+			PackageFile:     filepath.Join(setup.testDir, "marbles.tar.gz"),
+			Label:           "marbles",
+			SignaturePolicy: `OR ('Org1MSP.member','Org2MSP.member', 'Org3MSP.member')`,
+			Sequence:        "1",
+		}
+	})
+
+	AfterEach(func() {
+		setup.cleanup()
+	})
+
+	// assertMarbleAPIs invoke marble APIs to add/transfer/delete marbles and get marbles without rich queries.
+	// These APIs are applicable to both levelDB and CouchDB.
+	assertMarbleAPIs := func(ccName string, peer *nwo.Peer) {
+		height := helper.getLedgerHeight(peer)
+
+		By("adding six marbles, marble-0 to marble-5")
+		for i := 0; i <= 5; i++ {
+			helper.invokeMarblesChaincode(ccName, peer, "initMarble", fmt.Sprintf("marble-%d", i), "blue", "35", "tom")
+			helper.waitUntilEqualLedgerHeight(height + i + 1)
+		}
+
+		By("getting marbles by range")
+		expectedQueryResult := newMarbleQueryResult(1, 4, "blue", 35, "tom")
+		helper.assertQueryMarbles(ccName, peer, expectedQueryResult, "getMarblesByRange", "marble-1", "marble-5")
+
+		By("transferring marble-0 to jerry")
+		helper.invokeMarblesChaincode(ccName, peer, "transferMarble", "marble-0", "jerry")
+
+		By("verifying new owner of marble-0 after transfer")
+		expectedResult := newMarble("marble-0", "blue", 35, "jerry")
+		helper.assertMarbleExists(ccName, peer, expectedResult, "marble-0")
+
+		By("deleting marble-0")
+		helper.invokeMarblesChaincode(ccName, peer, "delete", "marble-0")
+
+		By("verifying deletion of marble-0")
+		helper.assertMarbleDoesNotExist(peer, ccName, "marble-0")
+
+		By("transferring marbles by color")
+		helper.invokeMarblesChaincode(ccName, peer, "transferMarblesBasedOnColor", "blue", "jerry")
+
+		By("verifying new owner after transfer by color")
+		for i := 1; i <= 5; i++ {
+			name := fmt.Sprintf("marble-%d", i)
+			expectedResult = newMarble(name, "blue", 35, "jerry")
+			helper.assertMarbleExists(ccName, peer, expectedResult, name)
+		}
+
+		By("getting history for marble-0")
+		expectedHistoryResult := []*marbleHistoryResult{
+			&marbleHistoryResult{IsDelete: "true"},
+			&marbleHistoryResult{IsDelete: "false", Value: newMarble("marble-0", "blue", 35, "jerry")},
+			&marbleHistoryResult{IsDelete: "false", Value: newMarble("marble-0", "blue", 35, "tom")},
+		}
+		helper.assertGetHistoryForMarble(ccName, peer, expectedHistoryResult, "marble-0")
+	}
+
+	// assertMarbleAPIs verifies marbles APIs using rich queries and pagination that are only applicable to CouchDB.
+	assertMarbleAPIsRichQueries := func(ccName string, peer *nwo.Peer) {
+		By("querying marbles by owner")
+		expectedQueryResult := newMarbleQueryResult(1, 5, "blue", 35, "jerry")
+		helper.assertQueryMarbles(ccName, peer, expectedQueryResult, "queryMarblesByOwner", "jerry")
+
+		By("quering marbles by search criteria")
+		helper.assertQueryMarbles(ccName, peer, expectedQueryResult, "queryMarbles", `{"selector":{"color":"blue"}}`)
+
+		By("quering marbles by range with pagination size 3, 1st call")
+		bookmark := ""
+		expectedQueryResult = newMarbleQueryResult(1, 3, "blue", 35, "jerry")
+		bookmark = helper.assertQueryMarblesWithPagination(ccName, peer, expectedQueryResult,
+			"getMarblesByRangeWithPagination", "marble-1", "marble-6", "3", bookmark)
+
+		By("quering marbles by range with pagination size 3, 2nd call")
+		expectedQueryResult = newMarbleQueryResult(4, 5, "blue", 35, "jerry")
+		bookmark = helper.assertQueryMarblesWithPagination(ccName, peer, expectedQueryResult,
+			"getMarblesByRangeWithPagination", "marble-1", "marble-6", "3", bookmark)
+
+		By("quering marbles by range with pagination size 3, 3rd call should return no marble")
+		expectedQueryResult = make([]*marbleQueryResult, 0)
+		helper.assertQueryMarblesWithPagination(ccName, peer, expectedQueryResult,
+			"getMarblesByRangeWithPagination", "marble-1", "marble-6", "3", bookmark)
+
+		By("quering marbles by search criteria with pagination size 10, 1st call")
+		bookmark = ""
+		expectedQueryResult = newMarbleQueryResult(1, 5, "blue", 35, "jerry")
+		bookmark = helper.assertQueryMarblesWithPagination(ccName, peer, expectedQueryResult,
+			"queryMarblesWithPagination", `{"selector":{"owner":"jerry"}}`, "10", bookmark)
+
+		By("quering marbles by search criteria with pagination size 10, 2nd call should return no marble")
+		expectedQueryResult = make([]*marbleQueryResult, 0)
+		helper.assertQueryMarblesWithPagination(ccName, peer, expectedQueryResult,
+			"queryMarblesWithPagination", `{"selector":{"owner":"jerry"}}`, "10", bookmark)
+	}
+
+	When("levelDB is used as stateDB", func() {
+		It("calls marbles APIs", func() {
+			peer := setup.network.Peer("org2", "peer0")
+
+			By("deploying new lifecycle chaincode")
+			nwo.EnableCapabilities(setup.network, setup.channelID, "Application", "V2_0", setup.orderer, setup.peers...)
+			helper.deployChaincode(chaincode)
+
+			By("verifying marbles chaincode APIs")
+			assertMarbleAPIs(chaincode.Name, peer)
+		})
+	})
+
+	When("CouchDB is used as stateDB", func() {
+		var (
+			couchProcess ifrit.Process
+		)
+
+		BeforeEach(func() {
+			By("stopping peers")
+			setup.stopPeers()
+
+			By("configuring a peer with couchdb")
+			// configure only one of the peers (org2, peer0) to use couchdb.
+			// Note that we do not support a channel with mixed DBs.
+			// However, for testing, it would be fine to use couchdb for one
+			// peer and sending all the couchdb related test queries to this peer
+			couchDB := &runner.CouchDB{}
+			couchProcess = ifrit.Invoke(couchDB)
+			Eventually(couchProcess.Ready(), runner.DefaultStartTimeout).Should(BeClosed())
+			Consistently(couchProcess.Wait()).ShouldNot(Receive())
+			couchAddr := couchDB.Address()
+			peer := setup.network.Peer("org2", "peer0")
+			core := setup.network.ReadPeerConfig(peer)
+			core.Ledger.State.StateDatabase = "CouchDB"
+			core.Ledger.State.CouchDBConfig.CouchDBAddress = couchAddr
+			setup.network.WritePeerConfig(peer, core)
+
+			By("restarting peers with couchDB")
+			setup.startPeers()
+		})
+
+		AfterEach(func() {
+			couchProcess.Signal(syscall.SIGTERM)
+			Eventually(couchProcess.Wait(), setup.network.EventuallyTimeout).Should(Receive())
+		})
+
+		It("calls marbles APIs", func() {
+			peer := setup.network.Peer("org2", "peer0")
+
+			By("deploying new lifecycle chaincode")
+			nwo.EnableCapabilities(setup.network, setup.channelID, "Application", "V2_0", setup.orderer, setup.peers...)
+			helper.deployChaincode(chaincode)
+
+			By("verifying marbles chaincode APIs")
+			assertMarbleAPIs(chaincode.Name, peer)
+
+			By("verifying marbles rich queries")
+			assertMarbleAPIsRichQueries(chaincode.Name, peer)
+		})
+	})
+})
+
+type chaincode struct {
+	nwo.Chaincode
+	isLegacy bool
+}
+
+// marble is the struct to unmarshal the response bytes returned from getMarble API
+type marble struct {
+	ObjectType string `json:"docType"` //docType is "marble"
+	Name       string `json:"name"`
+	Color      string `json:"color"`
+	Size       int    `json:"size"`
+	Owner      string `json:"owner"`
+}
+
+// marbleQueryResult is the struct to unmarshal the response bytes returned from marbles query APIs
+type marbleQueryResult struct {
+	Key    string  `json:"Key"`
+	Record *marble `json:"Record"`
+}
+
+type metadata struct {
+	RecordsCount string `json:"RecordsCount"`
+	Bookmark     string `json:"Bookmark"`
+}
+
+// marbleQueryResult is the struct to unmarshal the metadata bytes returned from marbles pagination APIs
+type paginationMetadata struct {
+	ResponseMetadata *metadata `json:"ResponseMetadata"`
+}
+
+// marbleHistoryResult is the struct to unmarshal the response bytes returned from marbles history API
+type marbleHistoryResult struct {
+	TxId      string  `json:"TxId"`
+	Value     *marble `json:"Value"`
+	Timestamp string  `json:"Timestamp"`
+	IsDelete  string  `json:"IsDelete"`
+}
+
+// newMarble creates a marble object for the given parameters
+func newMarble(name, color string, size int, owner string) *marble {
+	return &marble{"marble", name, color, size, owner}
+}
+
+// newMarbleQueryResult creates a slice of marbleQueryResult for the marbles based on startIndex and endIndex.
+// Both startIndex and endIndex are inclusive
+func newMarbleQueryResult(startIndex, endIndex int, color string, size int, owner string) []*marbleQueryResult {
+	expectedResult := make([]*marbleQueryResult, 0)
+	for i := startIndex; i <= endIndex; i++ {
+		name := fmt.Sprintf("marble-%d", i)
+		item := marbleQueryResult{Key: name, Record: newMarble(name, color, size, owner)}
+		expectedResult = append(expectedResult, &item)
+	}
+	return expectedResult
+}
+
+// marblesTestHelper implements helper methods to call marbles chaincode APIs and verify results
+type marblesTestHelper struct {
+	*networkHelper
+}
+
+// invokeMarblesChaincode invokes marbles APIs such as initMarble, transfer and delete.
+func (th *marblesTestHelper) invokeMarblesChaincode(chaincodeName string, peer *nwo.Peer, funcAndArgs ...string) {
+	command := commands.ChaincodeInvoke{
+		ChannelID: th.channelID,
+		Orderer:   th.OrdererAddress(th.orderer, nwo.ListenPort),
+		Name:      chaincodeName,
+		Ctor:      prepareChaincodeInvokeArgs(funcAndArgs...),
+		PeerAddresses: []string{
+			th.PeerAddress(peer, nwo.ListenPort),
+		},
+		WaitForEvent: true,
+	}
+	th.invokeChaincode(peer, command)
+	nwo.WaitUntilEqualLedgerHeight(th.Network, th.channelID, nwo.GetLedgerHeight(th.Network, peer, th.channelID), th.peers...)
+}
+
+// assertMarbleExists asserts that the marble exists and matches the expected result
+func (th *marblesTestHelper) assertMarbleExists(chaincodeName string, peer *nwo.Peer, expectedResult *marble, marbleName string) {
+	command := commands.ChaincodeQuery{
+		ChannelID: th.channelID,
+		Name:      chaincodeName,
+		Ctor:      fmt.Sprintf(`{"Args":["readMarble","%s"]}`, marbleName),
+	}
+	sess, err := th.PeerUserSession(peer, "User1", command)
+	Expect(err).NotTo(HaveOccurred())
+	Eventually(sess, th.EventuallyTimeout).Should(gexec.Exit(0))
+	result := &marble{}
+	err = json.Unmarshal(sess.Out.Contents(), result)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(result).To(Equal(expectedResult))
+
+}
+
+// assertMarbleDoesNotExist asserts that the marble does not exist
+func (th *marblesTestHelper) assertMarbleDoesNotExist(peer *nwo.Peer, chaincodeName, marbleName string) {
+	command := commands.ChaincodeQuery{
+		ChannelID: th.channelID,
+		Name:      chaincodeName,
+		Ctor:      fmt.Sprintf(`{"Args":["readMarble","%s"]}`, marbleName),
+	}
+	th.queryChaincode(peer, command, "Marble does not exist", false)
+}
+
+// assertQueryMarbles queries the chaincode and verifies the result based on the function and arguments,
+// including range queries and rich queries.
+func (th *marblesTestHelper) assertQueryMarbles(chaincodeName string, peer *nwo.Peer, expectedResult []*marbleQueryResult, funcAndArgs ...string) {
+	command := commands.ChaincodeQuery{
+		ChannelID: th.channelID,
+		Name:      chaincodeName,
+		Ctor:      prepareChaincodeInvokeArgs(funcAndArgs...),
+	}
+	sess, err := th.PeerUserSession(peer, "User1", command)
+	Expect(err).NotTo(HaveOccurred())
+	Eventually(sess, th.EventuallyTimeout).Should(gexec.Exit(0))
+	results := make([]*marbleQueryResult, 0)
+	err = json.Unmarshal(sess.Out.Contents(), &results)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(results).To(Equal(expectedResult))
+}
+
+// assertQueryMarbles queries the chaincode with pagination and verifies the result based on the function and arguments,
+// including range queries and rich queries.
+func (th *marblesTestHelper) assertQueryMarblesWithPagination(chaincodeName string, peer *nwo.Peer, expectedResult []*marbleQueryResult, funcAndArgs ...string) string {
+	command := commands.ChaincodeQuery{
+		ChannelID: th.channelID,
+		Name:      chaincodeName,
+		Ctor:      prepareChaincodeInvokeArgs(funcAndArgs...),
+	}
+	sess, err := th.PeerUserSession(peer, "User1", command)
+	Expect(err).NotTo(HaveOccurred())
+	Eventually(sess, th.EventuallyTimeout).Should(gexec.Exit(0))
+
+	// response bytes contains 2 json arrays: [{"Key":...}][{"ResponseMetadata": ...}]
+	responseBytes := sess.Out.Contents()
+	index := bytes.LastIndex(responseBytes, []byte("]["))
+
+	// unmarshal and verify response result
+	results := make([]*marbleQueryResult, 0)
+	err = json.Unmarshal(responseBytes[:index+1], &results)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(results).To(Equal(expectedResult))
+
+	// unmarshal ResponseMetadata and return bookmark to the caller for next call
+	respMetadata := make([]*paginationMetadata, 0)
+	err = json.Unmarshal(responseBytes[index+1:], &respMetadata)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(respMetadata).To(HaveLen(1))
+
+	return respMetadata[0].ResponseMetadata.Bookmark
+}
+
+// assertGetHistoryForMarble queries the history for a specific marble and verifies the result
+func (th *marblesTestHelper) assertGetHistoryForMarble(chaincodeName string, peer *nwo.Peer, expectedResult []*marbleHistoryResult, marbleName string) {
+	command := commands.ChaincodeQuery{
+		ChannelID: th.channelID,
+		Name:      chaincodeName,
+		Ctor:      fmt.Sprintf(`{"Args":["getHistoryForMarble","%s"]}`, marbleName),
+	}
+	sess, err := th.PeerUserSession(peer, "User1", command)
+	Expect(err).NotTo(HaveOccurred())
+	Eventually(sess, th.EventuallyTimeout).Should(gexec.Exit(0))
+
+	// unmarshal bytes and verify history
+	results := make([]*marbleHistoryResult, 0)
+	err = json.Unmarshal(sess.Out.Contents(), &results)
+	Expect(err).NotTo(HaveOccurred())
+	Expect(results).To(HaveLen(len(expectedResult)))
+	for i, result := range results {
+		Expect(result.IsDelete).To(Equal(expectedResult[i].IsDelete))
+		if result.IsDelete == "true" {
+			Expect(result.Value).To(BeNil())
+			continue
+		}
+		Expect(result.Value).To(Equal(expectedResult[i].Value))
+	}
+}