[FAB-4183]: Add unit tests to ccprovider pkg

Added additional tests to ccprovider package

Change-Id: Ida624943badb5d51802ff4d732b1fafe0a0f7a44
Signed-off-by: Anil Ambati <[email protected]>

Author: Anil Ambati

core/common/ccprovider/ccinfocache.go

@@ -75,11 +75,11 @@ func (c *ccInfoCacheImpl) PutChaincode(depSpec *peer.ChaincodeDeploymentSpec) (C
 	ccversion := depSpec.ChaincodeSpec.ChaincodeId.Version
 
 	if ccname == "" {
-		return nil, fmt.Errorf("the chaincode name cannot be an emoty string")
+		return nil, fmt.Errorf("the chaincode name cannot be an empty string")
 	}
 
 	if ccversion == "" {
-		return nil, fmt.Errorf("the chaincode version cannot be an emoty string")
+		return nil, fmt.Errorf("the chaincode version cannot be an empty string")
 	}
 
 	key := ccname + "/" + ccversion

core/common/ccprovider/ccinfocache_test.go

@@ -20,6 +20,9 @@ import (
 	"archive/tar"
 	"bytes"
 	"compress/gzip"
+	"errors"
+	"io/ioutil"
+	"path/filepath"
 	"testing"
 
 	"os"
@@ -67,10 +70,15 @@ func buildPackage(name string, path string, version string, initArgs [][]byte) (
 }
 
 type mockCCInfoFSStorageMgrImpl struct {
-	CCMap map[string]CCPackage
+	CCMap           map[string]CCPackage
+	putchaincodeErr bool
 }
 
 func (m *mockCCInfoFSStorageMgrImpl) PutChaincode(depSpec *peer.ChaincodeDeploymentSpec) (CCPackage, error) {
+	if m.putchaincodeErr {
+		return nil, errors.New("Error putting the chaincode")
+	}
+
 	buf, err := proto.Marshal(depSpec)
 	if err != nil {
 		return nil, err
@@ -145,6 +153,63 @@ func TestCCInfoCache(t *testing.T) {
 	assert.NotNil(t, cd2)
 }
 
+func TestPutChaincode(t *testing.T) {
+	ccname := ""
+	ccver := "1.0"
+	ccpath := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02"
+
+	ccinfoFs := &mockCCInfoFSStorageMgrImpl{CCMap: map[string]CCPackage{}}
+	cccache := NewCCInfoCache(ccinfoFs)
+
+	// Error case 1: ccname is empty
+	// create a dep spec to put
+	ds, err := getDepSpec(ccname, ccpath, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")})
+	assert.NoError(t, err)
+	_, err = cccache.PutChaincode(ds)
+	assert.Error(t, err)
+	assert.Equal(t, "the chaincode name cannot be an empty string", err.Error(), "Unexpected error received")
+
+	// Error case 2: ccver is empty
+	ccname = "foo"
+	ccver = ""
+	ds, err = getDepSpec(ccname, ccpath, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")})
+	assert.NoError(t, err)
+	_, err = cccache.PutChaincode(ds)
+	assert.Error(t, err)
+	assert.Equal(t, "the chaincode version cannot be an empty string", err.Error(), "Unexpected error received")
+
+	// Error case 3: ccfs.PutChainCode returns an error
+	ccinfoFs = &mockCCInfoFSStorageMgrImpl{CCMap: map[string]CCPackage{}, putchaincodeErr: true}
+	cccache = NewCCInfoCache(ccinfoFs)
+
+	ccname = "foo"
+	ccver = "1.0"
+	ds, err = getDepSpec(ccname, ccpath, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")})
+	assert.NoError(t, err)
+	_, err = cccache.PutChaincode(ds)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "PutChaincodeIntoFS failed", "Unexpected error received")
+}
+
+// here we test the peer's built-in cache after enabling it
+func TestCCInfoFSPeerInstance(t *testing.T) {
+	ccname := "bar"
+	ccver := "1.0"
+	ccpath := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02"
+
+	// the cc data is not yet in the cache
+	_, err := GetChaincodeFromFS(ccname, ccver)
+	assert.Error(t, err)
+
+	// create a dep spec to put
+	ds, err := getDepSpec(ccname, ccpath, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")})
+	assert.NoError(t, err)
+
+	// put it
+	err = PutChaincodeIntoFS(ds)
+	assert.NoError(t, err)
+}
+
 // here we test the peer's built-in cache after enabling it
 func TestCCInfoCachePeerInstance(t *testing.T) {
 	// enable the cache first: it's disabled by default
@@ -166,18 +231,108 @@ func TestCCInfoCachePeerInstance(t *testing.T) {
 	err = PutChaincodeIntoFS(ds)
 	assert.NoError(t, err)
 
+	// Check if chain code package exists
+	exists, err := ChaincodePackageExists(ccname, ccver)
+	assert.NoError(t, err)
+	assert.True(t, exists, "ChaincodePackageExists should have returned true for an existing package")
+
+	// Get all installed chaincodes, it should not return 0 chain codes
+	resp, err := GetInstalledChaincodes()
+	assert.NoError(t, err)
+	assert.NotNil(t, resp)
+	assert.NotZero(t, len(resp.Chaincodes), "GetInstalledChaincodes should not have returned 0 chain codes")
+
 	// expect it to be in the cache
 	cd, err := GetChaincodeFromFS(ccname, ccver)
 	assert.NoError(t, err)
 	assert.NotNil(t, cd)
 }
 
+func TestGetInstalledChaincodesErrorPaths(t *testing.T) {
+	// Get the existing chaincode install path value and set it
+	// back after we are done with the test
+	cip := chaincodeInstallPath
+	defer SetChaincodesPath(cip)
+
+	// Create a temp dir and remove it at the end
+	dir, err := ioutil.TempDir(os.TempDir(), "chaincodes")
+	assert.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	// Set the above created directory as the chain code install path
+	SetChaincodesPath(dir)
+	err = ioutil.WriteFile(filepath.Join(dir, "idontexist.1.0"), []byte("test"), 0777)
+	assert.NoError(t, err)
+	resp, err := GetInstalledChaincodes()
+	assert.NoError(t, err)
+	assert.Equal(t, 0, len(resp.Chaincodes),
+		"Expected 0 chain codes but GetInstalledChaincodes returned %s chain codes", len(resp.Chaincodes))
+}
+
+func TestNewCCContext(t *testing.T) {
+	ccctx := NewCCContext("foo", "foo", "1.0", "", false, nil, nil)
+	assert.NotNil(t, ccctx)
+	canName := ccctx.GetCanonicalName()
+	assert.NotEmpty(t, canName)
+
+	assert.Panics(t, func() {
+		NewCCContext("foo", "foo", "", "", false, nil, nil)
+	}, "NewCCContext should have paniced if version is empty")
+
+	ccctx = &CCContext{"foo", "foo", "1.0", "", false, nil, nil, ""}
+	assert.Panics(t, func() {
+		ccctx.GetCanonicalName()
+	}, "GetConnonicalName should have paniced if cannonical name is empty")
+}
+
+func TestChaincodePackageExists(t *testing.T) {
+	_, err := ChaincodePackageExists("foo1", "1.0")
+	assert.Error(t, err)
+}
+
+func TestSetChaincodesPath(t *testing.T) {
+	dir, err := ioutil.TempDir(os.TempDir(), "setchaincodes")
+	if err != nil {
+		assert.Fail(t, err.Error(), "Unable to create temp dir")
+	}
+	defer os.RemoveAll(dir)
+	t.Logf("created temp dir %s", dir)
+
+	// Get the existing chaincode install path value and set it
+	// back after we are done with the test
+	cip := chaincodeInstallPath
+	defer SetChaincodesPath(cip)
+
+	f, err := ioutil.TempFile(dir, "chaincodes")
+	assert.NoError(t, err)
+	assert.Panics(t, func() {
+		SetChaincodesPath(f.Name())
+	}, "SetChaincodesPath should have paniced if a file is passed to it")
+
+	// Following code works on mac but does not work in CI
+	// // Make the directory read only
+	// err = os.Chmod(dir, 0444)
+	// assert.NoError(t, err)
+	// cdir := filepath.Join(dir, "chaincodesdir")
+	// assert.Panics(t, func() {
+	// 	SetChaincodesPath(cdir)
+	// }, "SetChaincodesPath should have paniced if it is not able to stat the dir")
+
+	// // Make the directory read and execute
+	// err = os.Chmod(dir, 0555)
+	// assert.NoError(t, err)
+	// assert.Panics(t, func() {
+	// 	SetChaincodesPath(cdir)
+	// }, "SetChaincodesPath should have paniced if it is not able to create the dir")
+}
+
 var ccinfocachetestpath = "/tmp/ccinfocachetest"
 
 func TestMain(m *testing.M) {
 	os.RemoveAll(ccinfocachetestpath)
-	defer os.RemoveAll(ccinfocachetestpath)
 
 	SetChaincodesPath(ccinfocachetestpath)
-	os.Exit(m.Run())
+	rc := m.Run()
+	os.RemoveAll(ccinfocachetestpath)
+	os.Exit(rc)
 }

core/common/ccprovider/cdspackage_test.go

@@ -24,6 +24,7 @@ import (
 
 	pb "github.com/hyperledger/fabric/protos/peer"
 	"github.com/hyperledger/fabric/protos/utils"
+	"github.com/stretchr/testify/assert"
 )
 
 func setupccdir() string {
@@ -75,7 +76,8 @@ func TestPutCDSErrorPaths(t *testing.T) {
 	ccdir := setupccdir()
 	defer os.RemoveAll(ccdir)
 
-	cds := &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: 1, ChaincodeId: &pb.ChaincodeID{Name: "testcc", Version: "0"}, Input: &pb.ChaincodeInput{Args: [][]byte{[]byte("")}}}, CodePackage: []byte("code")}
+	cds := &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: 1, ChaincodeId: &pb.ChaincodeID{Name: "testcc", Version: "0"},
+		Input: &pb.ChaincodeInput{Args: [][]byte{[]byte("")}}}, CodePackage: []byte("code")}
 
 	ccpack, b, _, err := processCDS(cds, true)
 	if err != nil {
@@ -174,3 +176,45 @@ func TestCDSSwitchChaincodes(t *testing.T) {
 		return
 	}
 }
+
+func TestPutChaincodeToFSErrorPaths(t *testing.T) {
+	ccpack := &CDSPackage{}
+	err := ccpack.PutChaincodeToFS()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "uninitialized package", "Unexpected error returned")
+
+	ccpack.buf = []byte("hello")
+	err = ccpack.PutChaincodeToFS()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "id cannot be nil if buf is not nil", "Unexpected error returned")
+
+	ccpack.id = []byte("cc123")
+	err = ccpack.PutChaincodeToFS()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "depspec cannot be nil if buf is not nil", "Unexpected error returned")
+
+	ccpack.depSpec = &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: 1, ChaincodeId: &pb.ChaincodeID{Name: "testcc", Version: "0"},
+		Input: &pb.ChaincodeInput{Args: [][]byte{[]byte("")}}}, CodePackage: []byte("code")}
+	err = ccpack.PutChaincodeToFS()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "nil data", "Unexpected error returned")
+
+	ccpack.data = &CDSData{}
+	err = ccpack.PutChaincodeToFS()
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "nil data bytes", "Unexpected error returned")
+}
+
+func TestValidateCCErrorPaths(t *testing.T) {
+	cpack := &CDSPackage{}
+	ccdata := &ChaincodeData{}
+	err := cpack.ValidateCC(ccdata)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "uninitialized package", "Unexpected error returned")
+
+	cpack.depSpec = &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{Type: 1, ChaincodeId: &pb.ChaincodeID{Name: "testcc", Version: "0"},
+		Input: &pb.ChaincodeInput{Args: [][]byte{[]byte("")}}}, CodePackage: []byte("code")}
+	err = cpack.ValidateCC(ccdata)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "nil data", "Unexpected error returned")
+}