github.com/lzy4123/fabric@v2.1.1+incompatible/internal/peer/chaincode/upgrade_test.go (about)

     1  /*
     2  Copyright Digital Asset Holdings, LLC. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package chaincode
     8  
     9  import (
    10  	"errors"
    11  	"fmt"
    12  	"testing"
    13  	"time"
    14  
    15  	pb "github.com/hyperledger/fabric-protos-go/peer"
    16  	"github.com/hyperledger/fabric/bccsp/sw"
    17  	"github.com/hyperledger/fabric/internal/peer/common"
    18  	"github.com/spf13/viper"
    19  	"github.com/stretchr/testify/assert"
    20  )
    21  
    22  func TestUpgradeCmd(t *testing.T) {
    23  	signer, err := common.GetDefaultSigner()
    24  	if err != nil {
    25  		t.Fatalf("Get default signer error: %v", err)
    26  	}
    27  
    28  	mockResponse := &pb.ProposalResponse{
    29  		Response:    &pb.Response{Status: 200},
    30  		Endorsement: &pb.Endorsement{},
    31  	}
    32  	mockEndorserClients := []pb.EndorserClient{common.GetMockEndorserClient(mockResponse, nil)}
    33  	mockBroadcastClient := common.GetMockBroadcastClient(nil)
    34  	mockCF := &ChaincodeCmdFactory{
    35  		EndorserClients: mockEndorserClients,
    36  		Signer:          signer,
    37  		BroadcastClient: mockBroadcastClient,
    38  	}
    39  
    40  	// reset channelID, it might have been set by previous test
    41  	channelID = ""
    42  
    43  	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
    44  	assert.NoError(t, err)
    45  	cmd := upgradeCmd(mockCF, cryptoProvider)
    46  	addFlags(cmd)
    47  
    48  	args := []string{"-n", "mychaincode", "-p", "mychaincodepath",
    49  		"-v", "anotherversion", "-c", "{\"Function\":\"init\",\"Args\": [\"param\",\"1\"]}"}
    50  	cmd.SetArgs(args)
    51  	err = cmd.Execute()
    52  	assert.Error(t, err, "'peer chaincode upgrade' command should have failed without -C flag")
    53  
    54  	args = []string{"-C", "mychannel", "-n", "mychaincode", "-p", "mychaincodepath",
    55  		"-v", "anotherversion", "-c", "{\"Function\":\"init\",\"Args\": [\"param\",\"1\"]}"}
    56  	cmd.SetArgs(args)
    57  	err = cmd.Execute()
    58  	assert.NoError(t, err, "'peer chaincode upgrade' command failed")
    59  }
    60  
    61  func TestUpgradeCmdEndorseFail(t *testing.T) {
    62  	signer, err := common.GetDefaultSigner()
    63  	if err != nil {
    64  		t.Fatalf("Get default signer error: %v", err)
    65  	}
    66  
    67  	errCode := int32(500)
    68  	errMsg := "upgrade error"
    69  	mockResponse := &pb.ProposalResponse{Response: &pb.Response{Status: errCode, Message: errMsg}}
    70  
    71  	mockEndorserClients := []pb.EndorserClient{common.GetMockEndorserClient(mockResponse, nil)}
    72  	mockBroadcastClient := common.GetMockBroadcastClient(nil)
    73  	mockCF := &ChaincodeCmdFactory{
    74  		EndorserClients: mockEndorserClients,
    75  		Signer:          signer,
    76  		BroadcastClient: mockBroadcastClient,
    77  	}
    78  
    79  	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
    80  	assert.NoError(t, err)
    81  	cmd := upgradeCmd(mockCF, cryptoProvider)
    82  	addFlags(cmd)
    83  
    84  	args := []string{"-C", "mychannel", "-n", "mychaincode", "-p", "mychaincodepath",
    85  		"-v", "anotherversion", "-c", "{\"Function\":\"init\",\"Args\": [\"param\",\"1\"]}"}
    86  	cmd.SetArgs(args)
    87  
    88  	expectErrMsg := fmt.Sprintf("could not assemble transaction, err proposal response was not successful, error code %d, msg %s", errCode, errMsg)
    89  	if err := cmd.Execute(); err == nil {
    90  		t.Errorf("Run chaincode upgrade cmd error:%v", err)
    91  	} else {
    92  		if err.Error() != expectErrMsg {
    93  			t.Errorf("Run chaincode upgrade cmd get unexpected error: %s", err.Error())
    94  		}
    95  	}
    96  }
    97  
    98  func TestUpgradeCmdSendTXFail(t *testing.T) {
    99  	signer, err := common.GetDefaultSigner()
   100  	if err != nil {
   101  		t.Fatalf("Get default signer error: %v", err)
   102  	}
   103  
   104  	mockResponse := &pb.ProposalResponse{
   105  		Response:    &pb.Response{Status: 200},
   106  		Endorsement: &pb.Endorsement{},
   107  	}
   108  	mockEndorserClients := []pb.EndorserClient{common.GetMockEndorserClient(mockResponse, nil)}
   109  	sendErr := errors.New("send tx failed")
   110  	mockBroadcastClient := common.GetMockBroadcastClient(sendErr)
   111  	mockCF := &ChaincodeCmdFactory{
   112  		EndorserClients: mockEndorserClients,
   113  		Signer:          signer,
   114  		BroadcastClient: mockBroadcastClient,
   115  	}
   116  
   117  	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
   118  	assert.NoError(t, err)
   119  	cmd := upgradeCmd(mockCF, cryptoProvider)
   120  	addFlags(cmd)
   121  
   122  	args := []string{"-C", "mychannel", "-n", "mychaincode", "-p", "mychaincodepath", "-v", "anotherversion", "-c", "{\"Function\":\"init\",\"Args\": [\"param\",\"1\"]}"}
   123  	cmd.SetArgs(args)
   124  
   125  	expectErrMsg := sendErr.Error()
   126  	if err := cmd.Execute(); err == nil {
   127  		t.Errorf("Run chaincode upgrade cmd error:%v", err)
   128  	} else {
   129  		if err.Error() != expectErrMsg {
   130  			t.Errorf("Run chaincode upgrade cmd get unexpected error: %s", err.Error())
   131  		}
   132  	}
   133  }
   134  
   135  func TestUpgradeCmdWithNilCF(t *testing.T) {
   136  	defer viper.Reset()
   137  	defer resetFlags()
   138  
   139  	// set timeout for failure cases
   140  	viper.Set("peer.client.connTimeout", 10*time.Millisecond)
   141  
   142  	// trap possible SIGSEV panic
   143  	defer func() {
   144  		var err error
   145  		if r := recover(); r != nil {
   146  			err = fmt.Errorf("%v", r)
   147  		}
   148  		assert.NoError(t, err, "'peer chaincode upgrade' command should have failed without a panic")
   149  	}()
   150  
   151  	channelID = ""
   152  
   153  	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
   154  	assert.NoError(t, err)
   155  	cmd := upgradeCmd(nil, cryptoProvider)
   156  	addFlags(cmd)
   157  
   158  	args := []string{"-C", "mychannel", "-n", "mychaincode", "-p", "mychaincodepath",
   159  		"-v", "anotherversion", "-c", "{\"Function\":\"init\",\"Args\": [\"param\",\"1\"]}"}
   160  	cmd.SetArgs(args)
   161  	err = cmd.Execute()
   162  	assert.Error(t, err, "'peer chaincode upgrade' command should have failed without a panic")
   163  }