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

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package chaincode
     8  
     9  import (
    10  	"fmt"
    11  	"io/ioutil"
    12  	"os"
    13  	"testing"
    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/cobra"
    19  	"github.com/spf13/viper"
    20  	"github.com/stretchr/testify/assert"
    21  )
    22  
    23  func initInstallTest(t *testing.T, fsPath string, ec pb.EndorserClient, mockResponse *pb.ProposalResponse) (*cobra.Command, *ChaincodeCmdFactory) {
    24  	viper.Set("peer.fileSystemPath", fsPath)
    25  
    26  	signer, err := common.GetDefaultSigner()
    27  	if err != nil {
    28  		t.Fatalf("Get default signer error: %v", err)
    29  	}
    30  
    31  	if mockResponse == nil {
    32  		mockResponse = &pb.ProposalResponse{
    33  			Response:    &pb.Response{Status: 200},
    34  			Endorsement: &pb.Endorsement{},
    35  		}
    36  	}
    37  	if ec == nil {
    38  		ec = common.GetMockEndorserClient(mockResponse, nil)
    39  	}
    40  
    41  	mockCF := &ChaincodeCmdFactory{
    42  		Signer:          signer,
    43  		EndorserClients: []pb.EndorserClient{ec},
    44  	}
    45  	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
    46  	assert.NoError(t, err)
    47  
    48  	cmd := installCmd(mockCF, nil, cryptoProvider)
    49  	addFlags(cmd)
    50  
    51  	return cmd, mockCF
    52  }
    53  
    54  func cleanupInstallTest(fsPath string) {
    55  	os.RemoveAll(fsPath)
    56  }
    57  
    58  func TestInstallBadVersion(t *testing.T) {
    59  	fsPath, err := ioutil.TempDir("", "installbadversion")
    60  	assert.NoError(t, err)
    61  
    62  	cmd, _ := initInstallTest(t, fsPath, nil, nil)
    63  	defer cleanupInstallTest(fsPath)
    64  
    65  	args := []string{"-n", "mychaincode", "-p", "github.com/hyperledger/fabric/internal/peer/chaincode/testdata/src/chaincodes/noop"}
    66  	cmd.SetArgs(args)
    67  
    68  	if err := cmd.Execute(); err == nil {
    69  		t.Fatal("Expected error executing install command for version not specified")
    70  	}
    71  }
    72  
    73  func TestInstallNonExistentCC(t *testing.T) {
    74  	fsPath, err := ioutil.TempDir("", "install-nonexistentcc")
    75  	assert.NoError(t, err)
    76  
    77  	cmd, _ := initInstallTest(t, fsPath, nil, nil)
    78  	defer cleanupInstallTest(fsPath)
    79  
    80  	args := []string{"-n", "badmychaincode", "-p", "github.com/hyperledger/fabric/internal/peer/chaincode/testdata/src/chaincodes/bad_mychaincode", "-v", "testversion"}
    81  	cmd.SetArgs(args)
    82  
    83  	if err := cmd.Execute(); err == nil {
    84  		t.Fatal("Expected error executing install command for bad chaincode")
    85  	}
    86  
    87  	if _, err := os.Stat(fsPath + "/chaincodes/badmychaincode.testversion"); err == nil {
    88  		t.Fatal("chaincode mychaincode.testversion should not exist")
    89  	}
    90  }
    91  
    92  func TestInstallFromPackage(t *testing.T) {
    93  	pdir := newTempDir()
    94  	defer os.RemoveAll(pdir)
    95  
    96  	ccpackfile := pdir + "/ccpack.file"
    97  	err := createSignedCDSPackage(t, []string{"-n", "somecc", "-p", "some/go/package", "-v", "0", ccpackfile}, false)
    98  	if err != nil {
    99  		t.Fatalf("could not create package :%v", err)
   100  	}
   101  
   102  	fsPath := "/tmp/installtest"
   103  
   104  	cmd, mockCF := initInstallTest(t, fsPath, nil, nil)
   105  	defer cleanupInstallTest(fsPath)
   106  
   107  	mockResponse := &pb.ProposalResponse{
   108  		Response:    &pb.Response{Status: 200},
   109  		Endorsement: &pb.Endorsement{},
   110  	}
   111  	mockEndorserClient := common.GetMockEndorserClient(mockResponse, nil)
   112  	mockCF.EndorserClients = []pb.EndorserClient{mockEndorserClient}
   113  
   114  	args := []string{ccpackfile}
   115  	cmd.SetArgs(args)
   116  
   117  	if err := cmd.Execute(); err != nil {
   118  		t.Fatal("error executing install command from package")
   119  	}
   120  }
   121  
   122  func TestInstallFromBadPackage(t *testing.T) {
   123  	pdir := newTempDir()
   124  	defer os.RemoveAll(pdir)
   125  
   126  	ccpackfile := pdir + "/ccpack.file"
   127  	err := ioutil.WriteFile(ccpackfile, []byte("really bad CC package"), 0700)
   128  	if err != nil {
   129  		t.Fatalf("could not create package :%v", err)
   130  	}
   131  
   132  	fsPath := "/tmp/installtest"
   133  
   134  	cmd, _ := initInstallTest(t, fsPath, nil, nil)
   135  	defer cleanupInstallTest(fsPath)
   136  
   137  	args := []string{ccpackfile}
   138  	cmd.SetArgs(args)
   139  
   140  	if err := cmd.Execute(); err == nil {
   141  		t.Fatal("expected error installing bad package")
   142  	}
   143  }
   144  
   145  func installCC(t *testing.T) error {
   146  	defer viper.Reset()
   147  
   148  	fsPath, err := ioutil.TempDir("", "installLegacyEx02")
   149  	assert.NoError(t, err)
   150  	cmd, _ := initInstallTest(t, fsPath, nil, nil)
   151  	defer cleanupInstallTest(fsPath)
   152  
   153  	args := []string{"-n", "mychaincode", "-p", "github.com/hyperledger/fabric/internal/peer/chaincode/testdata/src/chaincodes/noop", "-v", "anotherversion"}
   154  	cmd.SetArgs(args)
   155  
   156  	if err := cmd.Execute(); err != nil {
   157  		return fmt.Errorf("Run chaincode upgrade cmd error:%v", err)
   158  	}
   159  
   160  	return nil
   161  }
   162  
   163  func TestInstall(t *testing.T) {
   164  	if err := installCC(t); err != nil {
   165  		t.Fatalf("Install failed with error: %v", err)
   166  	}
   167  }
   168  
   169  func newInstallerForTest(t *testing.T, ec pb.EndorserClient) (installer *Installer, cleanup func()) {
   170  	fsPath, err := ioutil.TempDir("", "installerForTest")
   171  	assert.NoError(t, err)
   172  	_, mockCF := initInstallTest(t, fsPath, ec, nil)
   173  
   174  	cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore())
   175  	assert.NoError(t, err)
   176  
   177  	i := &Installer{
   178  		EndorserClients: mockCF.EndorserClients,
   179  		Signer:          mockCF.Signer,
   180  		CryptoProvider:  cryptoProvider,
   181  	}
   182  
   183  	cleanupFunc := func() {
   184  		cleanupInstallTest(fsPath)
   185  	}
   186  
   187  	return i, cleanupFunc
   188  }