fix lint-submodules errors (#137)

* fix lint-submodules errors

Signed-off-by: Jiehua Huang <huangjiehua@aisino.com>

test/integration/base_test_setup.go

@@ -594,13 +594,28 @@ func ResetKeys(t *testing.T, ctx contextAPI.ChannelProvider, chaincodeID, value
 	require.NoError(t, err, "Failed to create new channel client for resetting keys")
 	for _, key := range keys {
 		// Synchronous transaction
-		_, e := chClient.Execute(
-			channel.Request{
-				ChaincodeID: chaincodeID,
-				Fcn:         "invoke",
-				Args:        ExampleCCTxSetArgs(key, value),
-			},
-			channel.WithRetry(retry.DefaultChannelOpts))
+		req := channel.Request{
+			ChaincodeID: chaincodeID,
+			Fcn:         "invoke",
+			Args:        ExampleCCTxSetArgs(key, value),
+		}
+		e := invoke(chClient, req)
 		require.NoError(t, e, "Failed to reset keys")
 	}
 }
+
+func invoke(chClient *channel.Client, req channel.Request) error {
+
+	// Synchronous transaction
+	_, e := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
+		func() (interface{}, error) {
+			re, e := chClient.Execute(req)
+			if e != nil {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("Execute returned error: %v", e), nil)
+			}
+			return re, e
+		},
+	)
+	return e
+
+}

test/integration/e2e/orgs/multiple_orgs_test.go

@@ -857,7 +857,7 @@ func queryApprovedCC(t *testing.T, ccName string, sequence int64, channelID stri
 	for _, p := range org1Peers {
 		resp, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
 			func() (interface{}, error) {
-				resp1, err := mc.org1ResMgmt.LifecycleQueryApprovedCC(channelID, queryApprovedCCReq, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
+				resp1, err := mc.org1ResMgmt.LifecycleQueryApprovedCC(channelID, queryApprovedCCReq, resmgmt.WithTargets(p))
 				if err != nil {
 					return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryApprovedCC returned error: %v", err), nil)
 				}
@@ -913,7 +913,7 @@ func checkCCCommitReadiness(t *testing.T, packageID string, ccName, ccVersion st
 	for _, p := range org1Peers {
 		resp, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
 			func() (interface{}, error) {
-				resp1, err := mc.org1ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
+				resp1, err := mc.org1ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets(p))
 				fmt.Printf("LifecycleCheckCCCommitReadiness cc = %v, = %v\n", ccName, resp1)
 				if err != nil {
 					return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleCheckCCCommitReadiness returned error: %v", err), nil)
@@ -936,7 +936,7 @@ func checkCCCommitReadiness(t *testing.T, packageID string, ccName, ccVersion st
 	for _, p := range org2Peers {
 		resp, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
 			func() (interface{}, error) {
-				resp1, err := mc.org2ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
+				resp1, err := mc.org2ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets(p))
 				fmt.Printf("LifecycleCheckCCCommitReadiness cc = %v, = %v\n", ccName, resp1)
 				if err != nil {
 					return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleCheckCCCommitReadiness returned error: %v", err), nil)
@@ -993,7 +993,7 @@ func queryCommittedCC(t *testing.T, ccName string, channelID string, sequence in
 	for _, p := range org1Peers {
 		resp, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
 			func() (interface{}, error) {
-				resp1, err := mc.org1ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
+				resp1, err := mc.org1ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(p))
 				if err != nil {
 					return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryCommittedCC returned error: %v", err), nil)
 				}
@@ -1018,7 +1018,7 @@ func queryCommittedCC(t *testing.T, ccName string, channelID string, sequence in
 	for _, p := range org2Peers {
 		resp, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
 			func() (interface{}, error) {
-				resp1, err := mc.org2ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
+				resp1, err := mc.org2ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(p))
 				if err != nil {
 					return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryCommittedCC returned error: %v", err), nil)
 				}

test/integration/pkg/client/channel/channel_client_pvt_test.go

@@ -436,16 +436,23 @@ func runPvtDataPreReconcilePutAndGet(t *testing.T, sdk *fabsdk.FabricSDK, orgsCo
 	value1 := "pvtValue1"
 	value2 := "pvtValue2"
 	value3 := "pvtValue3"
-
-	response, err := chClient.Query(
-		channel.Request{
-			ChaincodeID: ccID,
-			Fcn:         "getprivate",
-			Args:        [][]byte{[]byte(coll1), []byte(key1)},
+	re, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
+		func() (interface{}, error) {
+			re, err := chClient.Query(
+				channel.Request{
+					ChaincodeID: ccID,
+					Fcn:         "getprivate",
+					Args:        [][]byte{[]byte(coll1), []byte(key1)},
+				},
+			)
+			if err != nil {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("query returned : %v", re), nil)
+			}
+			return re, nil
 		},
-		channel.WithRetry(retry.DefaultChannelOpts),
 	)
 	require.NoError(t, err)
+	response := re.(channel.Response)
 	t.Logf("Got response payload: [%s]", string(response.Payload))
 	require.Nil(t, response.Payload)
 

test/integration/pkg/client/resmgmt/resmgmt_queries_pvt_test.go

@@ -7,12 +7,14 @@ SPDX-License-Identifier: Apache-2.0
 package resmgmt
 
 import (
+	"fmt"
 	"reflect"
 	"testing"
 
 	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/retry"
+	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/status"
 	"github.com/hyperledger/fabric-sdk-go/pkg/fabsdk"
 	"github.com/hyperledger/fabric-sdk-go/test/integration"
 	"github.com/hyperledger/fabric-sdk-go/test/metadata"
@@ -52,8 +54,17 @@ func TestQueryCollectionsConfig(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Failed to create new resource management client: %s", err)
 	}
+	resp1, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
+		func() (interface{}, error) {
+			resp1, err := client.QueryCollectionsConfig(orgChannelID, ccID)
+			if err != nil {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("QueryCollectionsConfig returned : %v", resp1), nil)
+			}
+			return resp1, err
+		},
+	)
+	resp := resp1.(*pb.CollectionConfigPackage)
 
-	resp, err := client.QueryCollectionsConfig(orgChannelID, ccID, resmgmt.WithRetry(retry.DefaultResMgmtOpts))
 	if err != nil {
 		t.Fatalf("QueryCollectionsConfig return error: %s", err)
 	}

test/integration/pkg/fab/eventclient_test.go

@@ -21,9 +21,9 @@ import (
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/require"
 
+	pb "github.com/hyperledger/fabric-protos-go/peer"
 	"github.com/hyperledger/fabric-sdk-go/pkg/fab/events/deliverclient/seek"
 	"github.com/hyperledger/fabric-sdk-go/test/integration"
-	pb "github.com/hyperledger/fabric-protos-go/peer"
 )
 
 const eventTimeWindow = 20 * time.Second // the maximum amount of time to watch for events.

test/integration/pkg/fab/transient_data_test.go

@@ -8,9 +8,12 @@ package fab
 
 import (
 	reqContext "context"
+	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/retry"
+	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/status"
 	contextAPI "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/context"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab"
 	"github.com/hyperledger/fabric-sdk-go/pkg/context"
@@ -89,7 +92,7 @@ func createAndSendTransactionProposal(transactor fab.ProposalSender, chainCodeID
 		tp  *fab.TransactionProposal
 	}
 
-	invokerResp, err := retry.NewInvoker(retry.New(retry.DefaultChannelOpts)).Invoke(
+	invokerResp, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
 		func() (interface{}, error) {
 			txh, err := transactor.CreateTransactionHeader()
 			if err != nil {
@@ -102,8 +105,8 @@ func createAndSendTransactionProposal(transactor fab.ProposalSender, chainCodeID
 			}
 
 			tpr, err := transactor.SendTransactionProposal(tp, targets)
-			if err != nil {
-				return nil, errors.WithMessage(err, "invoking transaction proposal failed")
+			if err != nil && strings.Contains(err.Error(), "500") {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("creating transaction proposal failed error: %v", err), nil)
 			}
 
 			return &invokerResponse{

test/integration/prepare.go

@@ -16,6 +16,7 @@ import (
 	"github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/retry"
 	"github.com/hyperledger/fabric-sdk-go/pkg/common/errors/status"
+	fabAPI "github.com/hyperledger/fabric-sdk-go/pkg/common/providers/fab"
 	"github.com/hyperledger/fabric-sdk-go/pkg/fab"
 	packager "github.com/hyperledger/fabric-sdk-go/pkg/fab/ccpackager/gopackager"
 	javapackager "github.com/hyperledger/fabric-sdk-go/pkg/fab/ccpackager/javapackager"
@@ -286,15 +287,7 @@ func QueryApprovedCC(mc []*OrgContext, ccName string, sequence int64, channelID
 	}
 	for _, orgCtx := range mc {
 		for _, p := range orgCtx.Peers {
-			_, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
-				func() (interface{}, error) {
-					resp1, err := orgCtx.ResMgmt.LifecycleQueryApprovedCC(channelID, queryApprovedCCReq, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
-					if err != nil {
-						return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryApprovedCC returned error: %v", err), nil)
-					}
-					return resp1, err
-				},
-			)
+			err := queryApprovedCC(orgCtx, channelID, p, queryApprovedCCReq)
 			if err != nil {
 				return errors.WithMessage(err, "QueryApprovedCC example chaincode failed")
 			}
@@ -304,8 +297,26 @@ func QueryApprovedCC(mc []*OrgContext, ccName string, sequence int64, channelID
 
 }
 
+func queryApprovedCC(orgCtx *OrgContext, channelID string, p fabAPI.Peer, req resmgmt.LifecycleQueryApprovedCCRequest) error {
+
+	_, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
+		func() (interface{}, error) {
+			resp1, err := orgCtx.ResMgmt.LifecycleQueryApprovedCC(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
+			if err != nil {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("QueryApprovedCC returned : %v", resp1), nil)
+			}
+			return resp1, err
+		},
+	)
+	if err != nil {
+		return errors.WithMessage(err, "QueryApprovedCC example chaincode failed")
+	}
+
+	return nil
+}
+
 // CheckCCCommitReadiness checkcommit the example CC on the given channel
-func CheckCCCommitReadiness(mc []*OrgContext, packageID string, ccName, ccVersion string, sequence int64, channelID string, ccPolicyStr string) error {
+func CheckCCCommitReadiness(mc []*OrgContext, packageID string, ccName, ccVersion string, sequence int64, channelID string, ccPolicyStr string, collConfigs ...*pb.CollectionConfig) error {
 	ccPolicy, err := policydsl.FromString(ccPolicyStr)
 	if err != nil {
 		return errors.Wrapf(err, "error creating CC policy [%s]", ccPolicyStr)
@@ -319,39 +330,45 @@ func CheckCCCommitReadiness(mc []*OrgContext, packageID string, ccName, ccVersio
 		SignaturePolicy:   ccPolicy,
 		Sequence:          sequence,
 		InitRequired:      true,
+		CollectionConfig:  collConfigs,
 	}
-	/*resp1, err := mc.org1ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets([]fab.Peer{org1Peers[0]}...), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
-	if err != nil {
-		t.Fatal(err)
-	}
-	require.NotNil(t, resp1)*/
+
 	for _, orgCtx := range mc {
 		for _, p := range orgCtx.Peers {
-			_, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
-				func() (interface{}, error) {
-					resp1, err := orgCtx.ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
-					fmt.Printf("LifecycleCheckCCCommitReadiness cc = %v, = %v\n", ccName, resp1)
-					if err != nil {
-						return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleCheckCCCommitReadiness returned error: %v", err), nil)
-					}
-					flag := true
-					for _, r := range resp1.Approvals {
-						flag = flag && r
-					}
-					if !flag {
-						return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleCheckCCCommitReadiness returned : %v", resp1), nil)
-					}
-					return resp1, err
-				},
-			)
+			err = checkCCCommitReadiness(orgCtx, channelID, p, req)
 			if err != nil {
-				errors.WithMessage(err, "LifecycleCheckCCCommitReadiness example chaincode failed")
+				return errors.WithMessage(err, "LifecycleCheckCCCommitReadiness example chaincode failed")
 			}
 		}
 	}
 	return nil
 }
 
+func checkCCCommitReadiness(orgCtx *OrgContext, channelID string, p fabAPI.Peer, req resmgmt.LifecycleCheckCCCommitReadinessRequest) error {
+
+	_, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
+		func() (interface{}, error) {
+			resp1, err := orgCtx.ResMgmt.LifecycleCheckCCCommitReadiness(channelID, req, resmgmt.WithTargets(p))
+			if err != nil {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleCheckCCCommitReadiness returned : %v", resp1), nil)
+			}
+			flag := true
+			for _, r := range resp1.Approvals {
+				flag = flag && r
+			}
+			if !flag {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleCheckCCCommitReadiness returned : %v", resp1), nil)
+			}
+			return resp1, err
+		},
+	)
+	if err != nil {
+		return errors.WithMessage(err, "LifecycleCheckCCCommitReadiness example chaincode failed")
+	}
+
+	return nil
+}
+
 // CommitExampleChaincode approve the example CC on the given channel
 func CommitExampleChaincode(orgs []*OrgContext, channelID, ccID, ccVersion, ccPolicyStr string, sequence int64, collConfigs ...*pb.CollectionConfig) error {
 	ccPolicy, err := policydsl.FromString(ccPolicyStr)
@@ -405,40 +422,47 @@ func QueryCommittedCC(mc []*OrgContext, ccName string, channelID string, sequenc
 	req := resmgmt.LifecycleQueryCommittedCCRequest{
 		Name: ccName,
 	}
-	/*resp1, err := mc.org1ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(org1Peers[0]), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
-	if err != nil {
-		t.Fatal(err)
-	}*/
 	for _, orgCtx := range mc {
 		for _, p := range orgCtx.Peers {
-			_, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
-				func() (interface{}, error) {
-					resp1, err := orgCtx.ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(p), resmgmt.WithRetry(retry.DefaultResMgmtOpts))
-					if err != nil {
-						return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryCommittedCC returned error: %v", err), nil)
-					}
-					flag := false
-					for _, r := range resp1 {
-						if r.Name == ccName && r.Sequence == sequence {
-							flag = true
-							break
-						}
-					}
-					if !flag {
-						return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryCommittedCC returned : %v", resp1), nil)
-					}
-					return resp1, err
-				},
-			)
+			err := queryCommittedCC(orgCtx, ccName, channelID, sequence, p, req)
 			if err != nil {
-				errors.WithMessage(err, "queryCommittedCC example chaincode failed")
+				return errors.WithMessage(err, "queryCommittedCC example chaincode failed")
 			}
 		}
 	}
 	return nil
 
 }
 
+func queryCommittedCC(orgCtx *OrgContext, ccName string, channelID string, sequence int64, p fabAPI.Peer, req resmgmt.LifecycleQueryCommittedCCRequest) error {
+
+	_, err := retry.NewInvoker(retry.New(retry.TestRetryOpts)).Invoke(
+		func() (interface{}, error) {
+			resp1, err := orgCtx.ResMgmt.LifecycleQueryCommittedCC(channelID, req, resmgmt.WithTargets(p))
+			if err != nil {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryCommittedCC returned : %v", resp1), nil)
+			}
+			flag := false
+			for _, r := range resp1 {
+				if r.Name == ccName && r.Sequence == sequence {
+					flag = true
+					break
+				}
+			}
+			if !flag {
+				return nil, status.New(status.TestStatus, status.GenericTransient.ToInt32(), fmt.Sprintf("LifecycleQueryCommittedCC returned : %v", resp1), nil)
+			}
+			return resp1, err
+		},
+	)
+	if err != nil {
+		return errors.WithMessage(err, "queryCommittedCC example chaincode failed")
+	}
+
+	return nil
+
+}
+
 // InstallExamplePvtChaincode installs the example pvt chaincode to all peers in the given orgs
 func InstallExamplePvtChaincode(orgs []*OrgContext, ccID string) error {
 	ccPkg, err := packager.NewCCPackage(examplePvtCCPath, GetDeployPath())
@@ -565,7 +589,7 @@ func instantiateExampleChaincodeLc(sdk *fabsdk.FabricSDK, orgs []*OrgContext, ch
 		return errors.WithMessage(err, "QueryApprovedCC example chaincode failed")
 	}
 
-	err = CheckCCCommitReadiness(orgs, packageID, ccID, ccVersion, sequence, channelID, ccPolicy)
+	err = CheckCCCommitReadiness(orgs, packageID, ccID, ccVersion, sequence, channelID, ccPolicy, collConfigs...)
 	if err != nil {
 		return errors.WithMessage(err, "CheckCCCommitReadiness example chaincode failed")
 	}