Refactor _lifecycle CLI query + tests

Initial refactoring of code and rewrite of
unit tests in ginkgo.

FAB-14299 #done

Change-Id: I36de0ec19137759d6eca3541e19062abd76cbc14
Signed-off-by: Will Lahti <wtlahti@us.ibm.com>

Author: wlahti

internal/peer/lifecycle/chaincode/chaincode.go

@@ -39,11 +39,11 @@ func Cmd(cf *CmdFactory) *cobra.Command {
 
 	chaincodeCmd.AddCommand(PackageCmd(nil))
 	chaincodeCmd.AddCommand(InstallCmd(nil))
-	chaincodeCmd.AddCommand(queryInstalledCmd(cf))
+	chaincodeCmd.AddCommand(QueryInstalledCmd(nil))
 	chaincodeCmd.AddCommand(approveForMyOrgCmd(cf, nil))
 	chaincodeCmd.AddCommand(commitCmd(cf, nil))
-	chaincodeCmd.AddCommand(queryCommittedCmd(cf))
 	chaincodeCmd.AddCommand(queryApprovalStatusCmd(cf, nil))
+	chaincodeCmd.AddCommand(QueryCommittedCmd(nil))
 
 	return chaincodeCmd
 }

internal/peer/lifecycle/chaincode/common.go

@@ -7,17 +7,33 @@ SPDX-License-Identifier: Apache-2.0
 package chaincode
 
 import (
+	"context"
 	"crypto/tls"
 	"fmt"
 
+	"github.com/golang/protobuf/proto"
 	"github.com/hyperledger/fabric/internal/peer/common"
 	"github.com/hyperledger/fabric/internal/peer/common/api"
 	"github.com/hyperledger/fabric/internal/pkg/identity"
+	"github.com/hyperledger/fabric/protos/peer"
 	pb "github.com/hyperledger/fabric/protos/peer"
 	"github.com/pkg/errors"
 	"github.com/spf13/viper"
+	"google.golang.org/grpc"
 )
 
+// EndorserClient defines the interface for sending a proposal
+// to an endorser
+type EndorserClient interface {
+	ProcessProposal(ctx context.Context, in *pb.SignedProposal, opts ...grpc.CallOption) (*pb.ProposalResponse, error)
+}
+
+// Signer defines the interface needed for signing messages
+type Signer interface {
+	Sign(msg []byte) ([]byte, error)
+	Serialize() ([]byte, error)
+}
+
 // CmdFactory holds the clients used by ChaincodeCmd
 type CmdFactory struct {
 	EndorserClients []pb.EndorserClient
@@ -148,3 +164,29 @@ func validatePeerConnectionParameters(cmdName string) error {
 
 	return nil
 }
+
+func signProposal(proposal *peer.Proposal, signer Signer) (*peer.SignedProposal, error) {
+	// check for nil argument
+	if proposal == nil {
+		return nil, errors.New("proposal cannot be nil")
+	}
+
+	if signer == nil {
+		return nil, errors.New("signer cannot be nil")
+	}
+
+	proposalBytes, err := proto.Marshal(proposal)
+	if err != nil {
+		return nil, errors.Wrap(err, "error marshaling Proposal")
+	}
+
+	signature, err := signer.Sign(proposalBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return &peer.SignedProposal{
+		ProposalBytes: proposalBytes,
+		Signature:     signature,
+	}, nil
+}

internal/peer/lifecycle/chaincode/install.go

@@ -12,33 +12,19 @@ import (
 	"github.com/gogo/protobuf/proto"
 	"github.com/hyperledger/fabric/core/chaincode/persistence"
 	cb "github.com/hyperledger/fabric/protos/common"
-	"github.com/hyperledger/fabric/protos/peer"
 	pb "github.com/hyperledger/fabric/protos/peer"
 	lb "github.com/hyperledger/fabric/protos/peer/lifecycle"
 	"github.com/hyperledger/fabric/protoutil"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"google.golang.org/grpc"
 )
 
 // Reader defines the interface needed for reading a file.
 type Reader interface {
 	ReadFile(string) ([]byte, error)
 }
 
-// EndorserClient defines the interface for sending a proposal
-// to an endorser.
-type EndorserClient interface {
-	ProcessProposal(ctx context.Context, in *pb.SignedProposal, opts ...grpc.CallOption) (*pb.ProposalResponse, error)
-}
-
-// Signer defines the interface needed for signing messages.
-type Signer interface {
-	Sign(msg []byte) ([]byte, error)
-	Serialize() ([]byte, error)
-}
-
 // Installer holds the dependencies needed to install
 // a chaincode.
 type Installer struct {
@@ -152,7 +138,7 @@ func (i *Installer) Install() error {
 		return err
 	}
 
-	signedProposal, err := i.signProposal(proposal)
+	signedProposal, err := signProposal(proposal, i.Signer)
 	if err != nil {
 		return errors.WithMessage(err, "failed to create signed proposal for chaincode install")
 	}
@@ -215,22 +201,3 @@ func (i *Installer) createInstallProposal(pkgBytes []byte, creatorBytes []byte)
 
 	return proposal, nil
 }
-
-func (i *Installer) signProposal(proposal *peer.Proposal) (*peer.SignedProposal, error) {
-	// check for nil argument
-	if proposal == nil {
-		return nil, errors.New("proposal cannot be nil")
-	}
-
-	proposalBytes, err := proto.Marshal(proposal)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to marshal proposal")
-	}
-
-	signature, err := i.Signer.Sign(proposalBytes)
-	if err != nil {
-		return nil, err
-	}
-
-	return &peer.SignedProposal{ProposalBytes: proposalBytes, Signature: signature}, nil
-}

internal/peer/lifecycle/chaincode/querycommitted.go

@@ -17,22 +17,61 @@ import (
 	"github.com/hyperledger/fabric/protoutil"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 )
 
-var (
-	chaincodeQueryCommittedCmd *cobra.Command
-)
+// CommittedQuerier holds the dependencies needed to query
+// the committed chaincode definitions
+type CommittedQuerier struct {
+	Command        *cobra.Command
+	Input          *CommittedQueryInput
+	EndorserClient EndorserClient
+	Signer         Signer
+}
 
-// queryCommittedCmd returns the cobra command for
+type CommittedQueryInput struct {
+	ChannelID string
+	Name      string
+}
+
+// QueryCommittedCmd returns the cobra command for
 // querying a committed chaincode definition given
 // the chaincode name
-func queryCommittedCmd(cf *CmdFactory) *cobra.Command {
-	chaincodeQueryCommittedCmd = &cobra.Command{
+func QueryCommittedCmd(c *CommittedQuerier) *cobra.Command {
+	chaincodeQueryCommittedCmd := &cobra.Command{
 		Use:   "querycommitted",
-		Short: "Query a committed chaincode definition by name on a peer.",
-		Long:  "Query a committed chaincode definition by name on a peer.",
+		Short: "Query a committed chaincode definition by channel and name on a peer.",
+		Long:  "Query a committed chaincode definition by channel and name on a peer.",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return queryCommitted(cmd, cf)
+			if c == nil {
+				ccInput := &ClientConnectionsInput{
+					CommandName:           cmd.Name(),
+					EndorserRequired:      true,
+					ChannelID:             channelID,
+					PeerAddresses:         peerAddresses,
+					TLSRootCertFiles:      tlsRootCertFiles,
+					ConnectionProfilePath: connectionProfilePath,
+					TLSEnabled:            viper.GetBool("peer.tls.enabled"),
+				}
+
+				cc, err := NewClientConnections(ccInput)
+				if err != nil {
+					return err
+				}
+
+				cqInput := &CommittedQueryInput{
+					ChannelID: channelID,
+					Name:      chaincodeName,
+				}
+
+				c = &CommittedQuerier{
+					Command:        cmd,
+					EndorserClient: cc.EndorserClients[0],
+					Input:          cqInput,
+					Signer:         cc.Signer,
+				}
+			}
+			return c.Query()
 		},
 	}
 
@@ -48,72 +87,84 @@ func queryCommittedCmd(cf *CmdFactory) *cobra.Command {
 	return chaincodeQueryCommittedCmd
 }
 
-func queryCommitted(cmd *cobra.Command, cf *CmdFactory) error {
-	// Parsing of the command line is done so silence cmd usage
-	cmd.SilenceUsage = true
-
-	var err error
-	if cf == nil {
-		cf, err = InitCmdFactory(cmd.Name(), true, false)
-		if err != nil {
-			return err
-		}
+// Query returns the committed chaincode definition
+// for a given channel and chaincode name
+func (c *CommittedQuerier) Query() error {
+	if c.Command != nil {
+		// Parsing of the command line is done so silence cmd usage
+		c.Command.SilenceUsage = true
 	}
 
-	creator, err := cf.Signer.Serialize()
+	err := c.validateInput()
 	if err != nil {
-		return fmt.Errorf("Error serializing identity: %s", err)
+		return err
 	}
 
-	proposal, err := createQueryCommittedChaincodeDefinitionProposal(channelID, chaincodeName, creator)
+	proposal, err := c.createProposal()
 	if err != nil {
-		return errors.WithMessage(err, "error creating proposal")
+		return errors.WithMessage(err, "failed to create proposal")
 	}
 
-	signedProposal, err := protoutil.GetSignedProposal(proposal, cf.Signer)
+	signedProposal, err := signProposal(proposal, c.Signer)
 	if err != nil {
-		return errors.WithMessage(err, "error creating signed proposal")
+		return errors.WithMessage(err, "failed to create signed proposal")
 	}
 
-	// QueryCommittedChaincodeDefinition is currently only supported for one peer
-	proposalResponse, err := cf.EndorserClients[0].ProcessProposal(context.Background(), signedProposal)
+	proposalResponse, err := c.EndorserClient.ProcessProposal(context.Background(), signedProposal)
 	if err != nil {
-		return errors.WithMessage(err, "error endorsing proposal")
+		return errors.WithMessage(err, "failed to endorse proposal")
+	}
+
+	if proposalResponse == nil {
+		return errors.New("received nil proposal response")
 	}
 
 	if proposalResponse.Response == nil {
-		return errors.Errorf("proposal response had nil response")
+		return errors.New("received proposal response with nil response")
 	}
 
 	if proposalResponse.Response.Status != int32(cb.Status_SUCCESS) {
-		return errors.Errorf("bad response: %d - %s", proposalResponse.Response.Status, proposalResponse.Response.Message)
+		return errors.Errorf("query failed with status: %d - %s", proposalResponse.Response.Status, proposalResponse.Response.Message)
 	}
 
-	return printQueryCommittedResponse(proposalResponse)
+	return c.printResponse(proposalResponse)
 }
 
 // printResponse prints the information included in the response
 // from the server.
-func printQueryCommittedResponse(proposalResponse *pb.ProposalResponse) error {
+func (c *CommittedQuerier) printResponse(proposalResponse *pb.ProposalResponse) error {
 	qdcr := &lb.QueryChaincodeDefinitionResult{}
 	err := proto.Unmarshal(proposalResponse.Response.Payload, qdcr)
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to unmarshal proposal response's response payload")
 	}
 	fmt.Printf("Committed chaincode definition for chaincode '%s' on channel '%s':\n", chaincodeName, channelID)
 	fmt.Printf("Version: %s, Sequence: %d, Endorsement Plugin: %s, Validation Plugin: %s\n", qdcr.Version, qdcr.Sequence, qdcr.EndorsementPlugin, qdcr.ValidationPlugin)
+
 	return nil
 
 }
 
-func createQueryCommittedChaincodeDefinitionProposal(channelID, chaincodeName string, creatorBytes []byte) (*pb.Proposal, error) {
+func (c *CommittedQuerier) validateInput() error {
+	if c.Input.ChannelID == "" {
+		return errors.New("channel name must be specified")
+	}
+
+	if c.Input.Name == "" {
+		return errors.New("chaincode name must be specified")
+	}
+
+	return nil
+}
+
+func (c *CommittedQuerier) createProposal() (*pb.Proposal, error) {
 	args := &lb.QueryChaincodeDefinitionArgs{
-		Name: chaincodeName,
+		Name: c.Input.Name,
 	}
 
 	argsBytes, err := proto.Marshal(args)
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to marshal args")
 	}
 	ccInput := &pb.ChaincodeInput{Args: [][]byte{[]byte("QueryChaincodeDefinition"), argsBytes}}
 
@@ -124,9 +175,14 @@ func createQueryCommittedChaincodeDefinitionProposal(channelID, chaincodeName st
 		},
 	}
 
-	proposal, _, err := protoutil.CreateProposalFromCIS(cb.HeaderType_ENDORSER_TRANSACTION, channelID, cis, creatorBytes)
+	signerSerialized, err := c.Signer.Serialize()
+	if err != nil {
+		return nil, errors.WithMessage(err, "failed to serialize identity")
+	}
+
+	proposal, _, err := protoutil.CreateProposalFromCIS(cb.HeaderType_ENDORSER_TRANSACTION, c.Input.ChannelID, cis, signerSerialized)
 	if err != nil {
-		return nil, errors.WithMessage(err, "error creating proposal for ChaincodeInvocationSpec")
+		return nil, errors.WithMessage(err, "failed to create ChaincodeInvocationSpec proposal")
 	}
 
 	return proposal, nil