github.com/ewagmig/fabric@v2.1.1+incompatible/core/chaincode/platforms/java/platform_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package java_test
     8  
     9  import (
    10  	"archive/tar"
    11  	"bytes"
    12  	"compress/gzip"
    13  	"fmt"
    14  	"io"
    15  	"os"
    16  	"strings"
    17  	"testing"
    18  	"time"
    19  
    20  	pb "github.com/hyperledger/fabric-protos-go/peer"
    21  	"github.com/hyperledger/fabric/core/chaincode/platforms/java"
    22  	"github.com/hyperledger/fabric/core/chaincode/platforms/util"
    23  	"github.com/hyperledger/fabric/core/config/configtest"
    24  	"github.com/spf13/viper"
    25  	"github.com/stretchr/testify/assert"
    26  	"github.com/stretchr/testify/require"
    27  )
    28  
    29  const chaincodePathFolderGradle = "testdata/gradle"
    30  
    31  var spec = &pb.ChaincodeSpec{
    32  	Type: pb.ChaincodeSpec_JAVA,
    33  	ChaincodeId: &pb.ChaincodeID{
    34  		Name: "ssample",
    35  		Path: chaincodePathFolderGradle,
    36  	},
    37  	Input: &pb.ChaincodeInput{
    38  		Args: [][]byte{
    39  			[]byte("f"),
    40  		},
    41  	},
    42  }
    43  
    44  func TestMain(m *testing.M) {
    45  	viper.SetConfigName("core")
    46  	viper.SetEnvPrefix("CORE")
    47  	configtest.AddDevConfigPath(nil)
    48  	viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
    49  	viper.AutomaticEnv()
    50  	if err := viper.ReadInConfig(); err != nil {
    51  		fmt.Printf("could not read config %s\n", err)
    52  		os.Exit(-1)
    53  	}
    54  	os.Exit(m.Run())
    55  }
    56  
    57  func TestValidatePath(t *testing.T) {
    58  	platform := java.Platform{}
    59  
    60  	err := platform.ValidatePath(spec.ChaincodeId.Path)
    61  	assert.NoError(t, err)
    62  }
    63  
    64  func TestValidateCodePackage(t *testing.T) {
    65  	platform := java.Platform{}
    66  	b, _ := generateMockPackegeBytes("src/pom.xml", 0100400)
    67  	assert.NoError(t, platform.ValidateCodePackage(b))
    68  
    69  	b, _ = generateMockPackegeBytes("src/pom.xml", 0100555)
    70  	assert.Error(t, platform.ValidateCodePackage(b))
    71  
    72  	b, _ = generateMockPackegeBytes("src/build.gradle", 0100400)
    73  	assert.NoError(t, platform.ValidateCodePackage(b))
    74  
    75  	b, _ = generateMockPackegeBytes("src/build.xml", 0100400)
    76  	assert.Error(t, platform.ValidateCodePackage(b))
    77  
    78  	b, _ = generateMockPackegeBytes("src/src/Main.java", 0100400)
    79  	assert.NoError(t, platform.ValidateCodePackage(b))
    80  
    81  	b, _ = generateMockPackegeBytes("src/build/Main.java", 0100400)
    82  	assert.Error(t, platform.ValidateCodePackage(b))
    83  
    84  	b, _ = generateMockPackegeBytes("src/src/xyz/main.java", 0100400)
    85  	assert.NoError(t, platform.ValidateCodePackage(b))
    86  
    87  	b, _ = generateMockPackegeBytes("src/src/xyz/main.class", 0100400)
    88  	assert.Error(t, platform.ValidateCodePackage(b))
    89  
    90  	b, _ = platform.GetDeploymentPayload(chaincodePathFolderGradle)
    91  	assert.NoError(t, platform.ValidateCodePackage(b))
    92  }
    93  
    94  func TestGetDeploymentPayload(t *testing.T) {
    95  	platform := java.Platform{}
    96  
    97  	_, err := platform.GetDeploymentPayload("")
    98  	assert.Contains(t, err.Error(), "ChaincodeSpec's path cannot be empty")
    99  
   100  	spec.ChaincodeId.Path = chaincodePathFolderGradle
   101  
   102  	payload, err := platform.GetDeploymentPayload(chaincodePathFolderGradle)
   103  	assert.NoError(t, err)
   104  	assert.NotZero(t, len(payload))
   105  
   106  	is := bytes.NewReader(payload)
   107  	gr, err := gzip.NewReader(is)
   108  	require.NoError(t, err, "failed to open zip stream")
   109  	defer gr.Close()
   110  
   111  	tr := tar.NewReader(gr)
   112  
   113  	contents := map[string]bool{}
   114  	for {
   115  		header, err := tr.Next()
   116  		if err == io.EOF {
   117  			break
   118  		}
   119  		assert.NoError(t, err)
   120  
   121  		if strings.Contains(header.Name, ".class") {
   122  			assert.Fail(t, "Result package can't contain class file")
   123  		}
   124  		if strings.Contains(header.Name, "target/") {
   125  			assert.Fail(t, "Result package can't contain target folder")
   126  		}
   127  		if strings.Contains(header.Name, "build/") {
   128  			assert.Fail(t, "Result package can't contain build folder")
   129  		}
   130  		contents[header.Name] = true
   131  	}
   132  
   133  	// generated from observed behavior
   134  	assert.Contains(t, contents, "src/build.gradle")
   135  	assert.Contains(t, contents, "src/pom.xml")
   136  	assert.Contains(t, contents, "src/settings.gradle")
   137  	assert.Contains(t, contents, "src/src/main/java/example/ExampleCC.java")
   138  }
   139  
   140  func TestGenerateDockerfile(t *testing.T) {
   141  	platform := java.Platform{}
   142  
   143  	spec.ChaincodeId.Path = chaincodePathFolderGradle
   144  	_, err := platform.GetDeploymentPayload(spec.ChaincodeId.Path)
   145  	if err != nil {
   146  		t.Fatalf("failed to get Java CC payload: %s", err)
   147  	}
   148  
   149  	dockerfile, err := platform.GenerateDockerfile()
   150  	assert.NoError(t, err)
   151  
   152  	var buf []string
   153  
   154  	buf = append(buf, "FROM "+util.GetDockerImageFromConfig("chaincode.java.runtime"))
   155  	buf = append(buf, "ADD binpackage.tar /root/chaincode-java/chaincode")
   156  
   157  	dockerFileContents := strings.Join(buf, "\n")
   158  
   159  	assert.Equal(t, dockerFileContents, dockerfile)
   160  }
   161  
   162  func TestDockerBuildOptions(t *testing.T) {
   163  	platform := java.Platform{}
   164  
   165  	opts, err := platform.DockerBuildOptions("path")
   166  	assert.NoError(t, err, "unexpected error from DockerBuildOptions")
   167  
   168  	expectedOpts := util.DockerBuildOptions{
   169  		Image: "hyperledger/fabric-javaenv:latest",
   170  		Cmd:   "./build.sh",
   171  	}
   172  	assert.Equal(t, expectedOpts, opts)
   173  }
   174  
   175  func generateMockPackegeBytes(fileName string, mode int64) ([]byte, error) {
   176  	var zeroTime time.Time
   177  	codePackage := bytes.NewBuffer(nil)
   178  	gw := gzip.NewWriter(codePackage)
   179  	tw := tar.NewWriter(gw)
   180  	payload := make([]byte, 25, 25)
   181  	err := tw.WriteHeader(&tar.Header{Name: fileName, Size: int64(len(payload)), ModTime: zeroTime, AccessTime: zeroTime, ChangeTime: zeroTime, Mode: mode})
   182  	if err != nil {
   183  		return nil, err
   184  	}
   185  	_, err = tw.Write(payload)
   186  	if err != nil {
   187  		return nil, err
   188  	}
   189  	tw.Close()
   190  	gw.Close()
   191  	return codePackage.Bytes(), nil
   192  }