// ConstructTransaction constructs a transaction for testing func ConstructTransaction(t *testing.T, simulationResults []byte, sign bool) (*common.Envelope, string, error) { ccName := "foo" txID := util.GenerateUUID() var txEnv *common.Envelope var err error if sign { txEnv, err = ptestutils.ConstructSingedTxEnvWithDefaultSigner(txID, util.GetTestChainID(), ccName, simulationResults, nil, nil) } else { txEnv, err = ptestutils.ConstructUnsingedTxEnv(txID, util.GetTestChainID(), ccName, simulationResults, nil, nil) } return txEnv, txID, err }
func TestExecuteInvokeTransaction(t *testing.T) { chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { t.Fail() t.Logf("Error creating peer: %s", err) } defer finitPeer(lis, chainID) var ctxt = context.Background() cccid := NewCCContext(chainID, "example02", "", "", false, nil) url := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02" chaincodeID := &pb.ChaincodeID{Name: "example02", Path: url} args := []string{"a", "b", "10"} err = invokeExample02Transaction(ctxt, cccid, chaincodeID, args, true) if err != nil { t.Fail() t.Logf("Error invoking transaction: %s", err) } else { fmt.Printf("Invoke test passed\n") t.Logf("Invoke test passed") } theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) }
//TestRedeploy - deploy two times, second time should fail but example02 should remain deployed func TestRedeploy(t *testing.T) { chainID := util.GetTestChainID() //invalid arguments spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "ex02", Path: "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}}} cccid := chaincode.NewCCContext(chainID, "ex02", "", "", false, nil) _, _, err := deploy(endorserServer, chainID, spec, nil) if err != nil { t.Fail() t.Logf("error in endorserServer.ProcessProposal %s", err) chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } //second time should not fail as we are just simulating _, _, err = deploy(endorserServer, chainID, spec, nil) if err != nil { t.Fail() t.Logf("error in endorserServer.ProcessProposal %s", err) chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
func TestGetMSPManagerFromBlock(t *testing.T) { conf, err := msp.GetLocalMspConfig("../../../msp/sampleconfig/") if err != nil { t.Fatalf("GetLocalMspConfig failed, err %s", err) } block, err := msptestutils.GetTestBlockFromMspConfig(conf) if err != nil { t.Fatalf("getTestBlockFromMspConfig failed, err %s", err) } mgr, err := GetMSPManagerFromBlock(block) if err != nil { t.Fatalf("GetMSPManagerFromBlock failed, err %s", err) } else if mgr == nil { t.Fatalf("Returned nil manager") } msps, err := mgr.GetMSPs() if err != nil { t.Fatalf("EnlistedMSPs failed, err %s", err) } if msps == nil || len(msps) == 0 { t.Fatalf("There are no MSPS in the manager for chain %s", util.GetTestChainID()) } }
// Test deploy of a transaction with a GOPATH with multiple elements func TestGopathExecuteDeployTransaction(t *testing.T) { chainID := util.GetTestChainID() // add a trailing slash to GOPATH // and a couple of elements - it doesn't matter what they are os.Setenv("GOPATH", os.Getenv("GOPATH")+string(os.PathSeparator)+string(os.PathListSeparator)+"/tmp/foo"+string(os.PathListSeparator)+"/tmp/bar") executeDeployTransaction(t, chainID, "example01", "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01") }
// Test deploy of a transaction with a chaincode over HTTP. func TestHTTPExecuteDeployTransaction(t *testing.T) { chainID := util.GetTestChainID() // The chaincode used here cannot be from the fabric repo // itself or it won't be downloaded because it will be found // in GOPATH, which would defeat the test executeDeployTransaction(t, chainID, "example01", "http://gopkg.in/mastersingh24/fabric-test-resources.v1") }
func getProposal() (*peer.Proposal, error) { cis := &peer.ChaincodeInvocationSpec{ ChaincodeSpec: &peer.ChaincodeSpec{ ChaincodeID: &peer.ChaincodeID{Name: "foo"}, Type: peer.ChaincodeSpec_GOLANG}} uuid := util.GenerateUUID() return utils.CreateProposalFromCIS(uuid, util.GetTestChainID(), cis, signerSerialized) }
// TODO: as soon as proper per-chain MSP support is developed, this test will no longer be required func TestFakeSetup(t *testing.T) { err := LoadFakeSetupWithLocalMspAndTestChainMsp("../../../msp/sampleconfig/") if err != nil { t.Fatalf("LoadLocalMsp failed, err %s", err) } _, err = GetLocalMSP().GetDefaultSigningIdentity() if err != nil { t.Fatalf("GetDefaultSigningIdentity failed, err %s", err) } msps, err := GetManagerForChain(util.GetTestChainID()).GetMSPs() if err != nil { t.Fatalf("EnlistedMSPs failed, err %s", err) } if msps == nil || len(msps) == 0 { t.Fatalf("There are no MSPS in the manager for chain %s", util.GetTestChainID()) } }
// TestUpgradeAndInvoke deploys chaincode_example01, upgrade it with chaincode_example02, then invoke it func TestDeployAndUpgrade(t *testing.T) { chainID := util.GetTestChainID() var ctxt = context.Background() url1 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01" url2 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02" chaincodeID1 := &pb.ChaincodeID{Path: url1, Name: "upgradeex01"} chaincodeID2 := &pb.ChaincodeID{Path: url2, Name: "upgradeex01"} f := "init" argsDeploy := util.ToChaincodeArgs(f, "a", "100", "b", "200") spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID1, CtorMsg: &pb.ChaincodeInput{Args: argsDeploy}} cccid1 := chaincode.NewCCContext(chainID, "upgradeex01", "", "", false, nil) cccid2 := chaincode.NewCCContext(chainID, "upgradeex02", "", "", false, nil) resp, prop, err := deploy(endorserServer, chainID, spec, nil) chaincodeName := spec.ChaincodeID.Name if err != nil { t.Fail() chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) t.Logf("Error deploying <%s>: %s", chaincodeName, err) return } err = endorserServer.(*Endorser).commitTxSimulation(prop, chainID, signer, resp) if err != nil { t.Fail() chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) t.Logf("Error committing <%s>: %s", chaincodeName, err) return } argsUpgrade := util.ToChaincodeArgs(f, "a", "150", "b", "300") spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID2, CtorMsg: &pb.ChaincodeInput{Args: argsUpgrade}} resp, prop, err = upgrade(endorserServer, chainID, spec, nil) if err != nil { t.Fail() chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) t.Logf("Error upgrading <%s>: %s", chaincodeName, err) return } fmt.Printf("Upgrade test passed\n") t.Logf("Upgrade test passed") chaincode.GetChain().Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID1}}) chaincode.GetChain().Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID2}}) }
// Test the invocation of a transaction. func TestRangeQuery(t *testing.T) { //TODO enable after ledger enables RangeQuery t.Skip() chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { t.Fail() t.Logf("Error creating peer: %s", err) } defer finitPeer(lis, chainID) var ctxt = context.Background() url := "github.com/hyperledger/fabric/examples/chaincode/go/map" cID := &pb.ChaincodeID{Name: "tmap", Path: url} f := "init" args := util.ToChaincodeArgs(f) spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID, CtorMsg: &pb.ChaincodeInput{Args: args}} cccid := NewCCContext(chainID, "tmap", "", "", false, nil) _, err = deploy(ctxt, cccid, spec) chaincodeID := spec.ChaincodeID.Name if err != nil { t.Fail() t.Logf("Error initializing chaincode %s(%s)", chaincodeID, err) theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } // Invoke second chaincode, which will inturn invoke the first chaincode f = "keys" args = util.ToChaincodeArgs(f) spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID, CtorMsg: &pb.ChaincodeInput{Args: args}} _, _, _, err = invoke(ctxt, chainID, spec) if err != nil { t.Fail() t.Logf("Error invoking <%s>: %s", chaincodeID, err) theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
// createChaincodeDeploymentSpec Returns a deployment proposal of chaincode type func createProposalForChaincode(ccChaincodeDeploymentSpec *pb.ChaincodeDeploymentSpec, creator []byte) (proposal *pb.Proposal, err error) { var ccDeploymentSpecBytes []byte if ccDeploymentSpecBytes, err = proto.Marshal(ccChaincodeDeploymentSpec); err != nil { return nil, fmt.Errorf("Error creating proposal from ChaincodeDeploymentSpec: %s", err) } lcChaincodeSpec := &pb.ChaincodeSpec{Type: pb.ChaincodeSpec_GOLANG, ChaincodeID: &pb.ChaincodeID{Name: "lccc"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("deploy"), []byte("default"), ccDeploymentSpecBytes}}} lcChaincodeInvocationSpec := &pb.ChaincodeInvocationSpec{ChaincodeSpec: lcChaincodeSpec} uuid := createProposalID() // make proposal return putils.CreateChaincodeProposal(uuid, util.GetTestChainID(), lcChaincodeInvocationSpec, creator) }
//TestDeploy deploy chaincode example01 func TestDeploy(t *testing.T) { chainID := util.GetTestChainID() spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "ex01", Path: "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}}} cccid := chaincode.NewCCContext(chainID, "ex01", "", "", false, nil) _, _, err := deploy(endorserServer, chainID, spec, nil) if err != nil { t.Fail() t.Logf("Deploy-error in deploy %s", err) chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
// TestDeployAndInvoke deploys and invokes chaincode_example01 func TestDeployAndInvoke(t *testing.T) { chainID := util.GetTestChainID() var ctxt = context.Background() url := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01" chaincodeID := &pb.ChaincodeID{Path: url, Name: "ex01"} args := []string{"10"} f := "init" argsDeploy := util.ToChaincodeArgs(f, "a", "100", "b", "200") spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID, CtorMsg: &pb.ChaincodeInput{Args: argsDeploy}} cccid := chaincode.NewCCContext(chainID, "ex01", "", "", false, nil) resp, prop, err := deploy(endorserServer, chainID, spec, nil) chaincodeID1 := spec.ChaincodeID.Name if err != nil { t.Fail() t.Logf("Error deploying <%s>: %s", chaincodeID1, err) chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } err = endorserServer.(*Endorser).commitTxSimulation(prop, chainID, signer, resp) if err != nil { t.Fail() t.Logf("Error committing <%s>: %s", chaincodeID1, err) chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } f = "invoke" invokeArgs := append([]string{f}, args...) spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: chaincodeID, CtorMsg: &pb.ChaincodeInput{Args: util.ToChaincodeArgs(invokeArgs...)}} resp, err = invoke(chainID, spec) if err != nil { t.Fail() t.Logf("Error invoking transaction: %s", err) chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } fmt.Printf("Invoke test passed\n") t.Logf("Invoke test passed") chaincode.GetChain().Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) }
func createTx() (*common.Envelope, error) { cis := &peer.ChaincodeInvocationSpec{ChaincodeSpec: &peer.ChaincodeSpec{ChaincodeID: &peer.ChaincodeID{Name: "foo"}}} uuid := util.GenerateUUID() prop, err := utils.CreateProposalFromCIS(uuid, util.GetTestChainID(), cis, sid) if err != nil { return nil, err } presp, err := utils.CreateProposalResponse(prop.Header, prop.Payload, []byte("res"), nil, nil, id) if err != nil { return nil, err } return utils.CreateSignedTx(prop, id, presp) }
//TestDeployBadPayload set payload to nil and do a deploy. It should fail and example02 should not be deployed func TestDeployBadPayload(t *testing.T) { chainID := util.GetTestChainID() //invalid arguments spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Name: "ex02", Path: "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02"}, CtorMsg: &pb.ChaincodeInput{Args: [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}}} cccid := chaincode.NewCCContext(chainID, "ex02", "", "", false, nil) f := func(cds *pb.ChaincodeDeploymentSpec) { cds.CodePackage = nil } _, _, err := deploy(endorserServer, chainID, spec, f) if err == nil { t.Fail() t.Log("DeployBadPayload-expected error in deploy but succeeded") chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } chaincode.GetChain().Stop(context.Background(), cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
// FIXME: this is required for now because we need a local MSP // and also the MSP mgr for the test chain; as soon as the code // to setup chains is ready, the chain should be setup using // the method below and this method should disappear func LoadFakeSetupWithLocalMspAndTestChainMsp(dir string) error { conf, err := msp.GetLocalMspConfig(dir) if err != nil { return err } err = GetLocalMSP().Setup(conf) if err != nil { return err } fakeConfig := []*mspprotos.MSPConfig{conf} err = GetManagerForChain(util.GetTestChainID()).Setup(fakeConfig) if err != nil { return err } return nil }
func AddFlags(cmd *cobra.Command) { flags := cmd.PersistentFlags() flags.StringVarP(&chaincodeLang, "lang", "l", "golang", fmt.Sprintf("Language the %s is written in", chainFuncName)) flags.StringVarP(&chaincodeCtorJSON, "ctor", "c", "{}", fmt.Sprintf("Constructor message for the %s in JSON format", chainFuncName)) flags.StringVarP(&chaincodeAttributesJSON, "attributes", "a", "[]", fmt.Sprintf("User attributes for the %s in JSON format", chainFuncName)) flags.StringVarP(&chaincodePath, "path", "p", common.UndefinedParamValue, fmt.Sprintf("Path to %s", chainFuncName)) flags.StringVarP(&chaincodeName, "name", "n", common.UndefinedParamValue, fmt.Sprint("Name of the chaincode returned by the deploy transaction")) flags.StringVarP(&chaincodeUsr, "username", "u", common.UndefinedParamValue, fmt.Sprint("Username for chaincode operations when security is enabled")) flags.StringVarP(&customIDGenAlg, "tid", "t", common.UndefinedParamValue, fmt.Sprint("Name of a custom ID generation algorithm (hashing and decoding) e.g. sha256base64")) flags.StringVarP(&chainID, "chainID", "C", util.GetTestChainID(), fmt.Sprint("The chain on which this command should be executed")) }
// Test the execution of a chaincode that invokes another chaincode. func TestChaincodeInvokeChaincode(t *testing.T) { chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { t.Fail() t.Logf("Error creating peer: %s", err) } defer finitPeer(lis, chainID) err = chaincodeInvokeChaincode(t, chainID, "") if err != nil { t.Fail() t.Logf("Failed chaincode invoke chaincode : %s", err) closeListenerAndSleep(lis) return } closeListenerAndSleep(lis) }
func TestMain(m *testing.M) { SetupTestConfig() viper.Set("peer.fileSystemPath", filepath.Join(os.TempDir(), "hyperledger", "production")) chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { os.Exit(-1) fmt.Printf("Could not initialize tests") finitPeer(lis) return } endorserServer = NewEndorserServer() // setup the MSP manager so that we can sign/verify mspMgrConfigDir := "../../msp/sampleconfig/" err = mspmgmt.LoadFakeSetupWithLocalMspAndTestChainMsp(mspMgrConfigDir) if err != nil { fmt.Printf("Could not initialize msp/signer, err %s", err) os.Exit(-1) finitPeer(lis) return } signer, err = mspmgmt.GetLocalMSP().GetDefaultSigningIdentity() if err != nil { fmt.Printf("Could not initialize msp/signer") os.Exit(-1) finitPeer(lis) return } retVal := m.Run() finitPeer(lis) os.Exit(retVal) }
// Test the execution of an invalid transaction. func TestExecuteInvokeInvalidTransaction(t *testing.T) { chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { t.Fail() t.Logf("Error creating peer: %s", err) } defer finitPeer(lis, chainID) var ctxt = context.Background() url := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02" chaincodeID := &pb.ChaincodeID{Name: "example02", Path: url} cccid := NewCCContext(chainID, "example02", "", "", false, nil) //FAIL, FAIL! args := []string{"x", "-1"} err = invokeExample02Transaction(ctxt, cccid, chaincodeID, args, false) //this HAS to fail with expectedDeltaStringPrefix if err != nil { errStr := err.Error() t.Logf("Got error %s\n", errStr) t.Logf("InvalidInvoke test passed") theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) return } t.Fail() t.Logf("Error invoking transaction %s", err) theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: &pb.ChaincodeSpec{ChaincodeID: chaincodeID}}) }
// Test the execution of a chaincode that invokes another chaincode with wrong parameters. Should receive error from // from the called chaincode func TestChaincodeInvokeChaincodeErrorCase(t *testing.T) { chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { t.Fail() t.Logf("Error creating peer: %s", err) } defer finitPeer(lis, chainID) var ctxt = context.Background() // Deploy first chaincode url1 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02" cID1 := &pb.ChaincodeID{Name: "example02", Path: url1} f := "init" args := util.ToChaincodeArgs(f, "a", "100", "b", "200") spec1 := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID1, CtorMsg: &pb.ChaincodeInput{Args: args}} cccid1 := NewCCContext(chainID, "example02", "", "", false, nil) _, err = deploy(ctxt, cccid1, spec1) chaincodeID1 := spec1.ChaincodeID.Name if err != nil { t.Fail() t.Logf("Error initializing chaincode %s(%s)", chaincodeID1, err) theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) return } time.Sleep(time.Second) // Deploy second chaincode url2 := "github.com/hyperledger/fabric/examples/chaincode/go/passthru" cID2 := &pb.ChaincodeID{Name: "pthru", Path: url2} f = "init" args = util.ToChaincodeArgs(f) spec2 := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Args: args}} cccid2 := NewCCContext(chainID, "pthru", "", "", false, nil) _, err = deploy(ctxt, cccid2, spec2) chaincodeID2 := spec2.ChaincodeID.Name if err != nil { t.Fail() t.Logf("Error initializing chaincode %s(%s)", chaincodeID2, err) theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) return } time.Sleep(time.Second) // Invoke second chaincode, which will inturn invoke the first chaincode but pass bad params f = chaincodeID1 args = util.ToChaincodeArgs(f, "invoke", "a") spec2 = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Args: args}} // Invoke chaincode _, _, _, err = invoke(ctxt, chainID, spec2) if err == nil { t.Fail() t.Logf("Error invoking <%s>: %s", chaincodeID2, err) theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) return } if strings.Index(err.Error(), "Incorrect number of arguments. Expecting 3") < 0 { t.Fail() t.Logf("Unexpected error %s", err) theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) return } theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) }
func TestGetEvent(t *testing.T) { chainID := util.GetTestChainID() lis, err := initPeer(chainID) if err != nil { t.Fail() t.Logf("Error creating peer: %s", err) } defer finitPeer(lis, chainID) var ctxt = context.Background() url := "github.com/hyperledger/fabric/examples/chaincode/go/eventsender" cID := &pb.ChaincodeID{Name: "esender", Path: url} f := "init" spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID, CtorMsg: &pb.ChaincodeInput{Args: util.ToChaincodeArgs(f)}} cccid := NewCCContext(chainID, "esender", "", "", false, nil) _, err = deploy(ctxt, cccid, spec) chaincodeID := spec.ChaincodeID.Name if err != nil { t.Fail() t.Logf("Error initializing chaincode %s(%s)", chaincodeID, err) theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) return } time.Sleep(time.Second) args := util.ToChaincodeArgs("invoke", "i", "am", "satoshi") spec = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID, CtorMsg: &pb.ChaincodeInput{Args: args}} var ccevt *pb.ChaincodeEvent ccevt, _, _, err = invoke(ctxt, chainID, spec) if err != nil { t.Logf("Error invoking chaincode %s(%s)", chaincodeID, err) t.Fail() } if ccevt == nil { t.Logf("Error ccevt is nil %s(%s)", chaincodeID, err) t.Fail() } if ccevt.ChaincodeID != chaincodeID { t.Logf("Error ccevt id(%s) != cid(%s)", ccevt.ChaincodeID, chaincodeID) t.Fail() } if strings.Index(string(ccevt.Payload), "i,am,satoshi") < 0 { t.Logf("Error expected event not found (%s)", string(ccevt.Payload)) t.Fail() } theChaincodeSupport.Stop(ctxt, cccid, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec}) }
// Test the execution of a chaincode that queries another chaincode // example02 implements "query" as a function in Invoke. example05 calls example02 func TestChaincodeQueryChaincodeUsingInvoke(t *testing.T) { chainID := util.GetTestChainID() var peerLis net.Listener var err error if peerLis, err = initPeer(chainID); err != nil { t.Fail() t.Logf("Error registering user %s", err) return } defer finitPeer(peerLis, chainID) var ctxt = context.Background() // Deploy first chaincode url1 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02" cID1 := &pb.ChaincodeID{Name: "example02", Path: url1} f := "init" args := util.ToChaincodeArgs(f, "a", "100", "b", "200") spec1 := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID1, CtorMsg: &pb.ChaincodeInput{Args: args}} cccid1 := NewCCContext(chainID, "example02", "", "", false, nil) _, err = deploy(ctxt, cccid1, spec1) chaincodeID1 := spec1.ChaincodeID.Name if err != nil { theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) t.Fail() t.Logf("Error initializing chaincode %s(%s)", chaincodeID1, err) return } time.Sleep(time.Second) // Deploy second chaincode url2 := "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example05" cID2 := &pb.ChaincodeID{Name: "example05", Path: url2} f = "init" args = util.ToChaincodeArgs(f, "sum", "0") spec2 := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Args: args}} cccid2 := NewCCContext(chainID, "example05", "", "", false, nil) _, err = deploy(ctxt, cccid2, spec2) chaincodeID2 := spec2.ChaincodeID.Name if err != nil { theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) t.Fail() t.Logf("Error initializing chaincode %s(%s)", chaincodeID2, err) return } time.Sleep(time.Second) // Invoke second chaincode, which will inturn query the first chaincode f = "invoke" args = util.ToChaincodeArgs(f, chaincodeID1, "sum") spec2 = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Args: args}} // Invoke chaincode var retVal []byte _, _, retVal, err = invoke(ctxt, chainID, spec2) if err != nil { theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) t.Fail() t.Logf("Error invoking <%s>: %s", chaincodeID2, err) return } // Check the return value result, err := strconv.Atoi(string(retVal)) if err != nil || result != 300 { theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) t.Fail() t.Logf("Incorrect final state after transaction for <%s>: %s", chaincodeID1, err) return } // Query second chaincode, which will inturn query the first chaincode f = "query" args = util.ToChaincodeArgs(f, chaincodeID1, "sum") spec2 = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Args: args}} // Invoke chaincode _, _, retVal, err = invoke(ctxt, chainID, spec2) if err != nil { theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) t.Fail() t.Logf("Error querying <%s>: %s", chaincodeID2, err) return } // Check the return value result, err = strconv.Atoi(string(retVal)) if err != nil || result != 300 { theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) t.Fail() t.Logf("Incorrect final value after query for <%s>: %s", chaincodeID1, err) return } theChaincodeSupport.Stop(ctxt, cccid1, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec1}) theChaincodeSupport.Stop(ctxt, cccid2, &pb.ChaincodeDeploymentSpec{ChaincodeSpec: spec2}) }
func TestEnvelope(t *testing.T) { // create a proposal from a ChaincodeInvocationSpec uuid := util.GenerateUUID() prop, err := CreateChaincodeProposal(uuid, util.GetTestChainID(), createCIS(), signerSerialized) if err != nil { t.Fatalf("Could not create chaincode proposal, err %s\n", err) return } res := []byte("res") presp, err := CreateProposalResponse(prop.Header, prop.Payload, res, nil, nil, signer) if err != nil { t.Fatalf("Could not create proposal response, err %s\n", err) return } tx, err := CreateSignedTx(prop, signer, presp) if err != nil { t.Fatalf("Could not create signed tx, err %s\n", err) return } envBytes, err := GetBytesEnvelope(tx) if err != nil { t.Fatalf("Could not marshal envelope, err %s\n", err) return } tx, err = GetEnvelope(envBytes) if err != nil { t.Fatalf("Could not unmarshal envelope, err %s\n", err) return } act2, err := GetActionFromEnvelope(envBytes) if err != nil { t.Fatalf("Could not extract actions from envelop, err %s\n", err) return } if bytes.Compare(act2.Results, res) != 0 { t.Fatalf("results don't match") return } txpayl, err := GetPayload(tx) if err != nil { t.Fatalf("Could not unmarshal payload, err %s\n", err) return } tx2, err := GetTransaction(txpayl.Data) if err != nil { t.Fatalf("Could not unmarshal Transaction, err %s\n", err) return } sh, err := GetSignatureHeader(tx2.Actions[0].Header) if err != nil { t.Fatalf("Could not unmarshal SignatureHeader, err %s\n", err) return } if bytes.Compare(sh.Creator, signerSerialized) != 0 { t.Fatalf("creator does not match") return } cap, err := GetChaincodeActionPayload(tx2.Actions[0].Payload) if err != nil { t.Fatalf("Could not unmarshal ChaincodeActionPayload, err %s\n", err) return } assert.NotNil(t, cap) prp, err := GetProposalResponsePayload(cap.Action.ProposalResponsePayload) if err != nil { t.Fatalf("Could not unmarshal ProposalResponsePayload, err %s\n", err) return } ca, err := GetChaincodeAction(prp.Extension) if err != nil { t.Fatalf("Could not unmarshal ChaincodeAction, err %s\n", err) return } if bytes.Compare(ca.Results, res) != 0 { t.Fatalf("results don't match") return } }
func constructTransaction(simulationResults []byte) *common.Envelope { txEnv, _ := ptestutils.ConstructSingedTxEnvWithDefaultSigner(util.GenerateUUID(), util.GetTestChainID(), "foo", simulationResults, nil, nil) return txEnv }
func TestProposal(t *testing.T) { uuid := util.GenerateUUID() // create a proposal from a ChaincodeInvocationSpec prop, err := CreateChaincodeProposal(uuid, util.GetTestChainID(), createCIS(), []byte("creator")) if err != nil { t.Fatalf("Could not create chaincode proposal, err %s\n", err) return } // serialize the proposal pBytes, err := GetBytesProposal(prop) if err != nil { t.Fatalf("Could not serialize the chaincode proposal, err %s\n", err) return } // deserialize it and expect it to be the same propBack, err := GetProposal(pBytes) if err != nil { t.Fatalf("Could not deserialize the chaincode proposal, err %s\n", err) return } if !reflect.DeepEqual(prop, propBack) { t.Fatalf("Proposal and deserialized proposals don't match\n") return } // get back the header hdr, err := GetHeader(prop.Header) if err != nil { t.Fatalf("Could not extract the header from the proposal, err %s\n", err) } hdrBytes, err := GetBytesHeader(hdr) if err != nil { t.Fatalf("Could not marshal the header, err %s\n", err) } hdr, err = GetHeader(hdrBytes) if err != nil { t.Fatalf("Could not unmarshal the header, err %s\n", err) } // sanity check on header if hdr.ChainHeader.Type != int32(common.HeaderType_ENDORSER_TRANSACTION) || hdr.SignatureHeader.Nonce == nil || string(hdr.SignatureHeader.Creator) != "creator" { t.Fatalf("Invalid header after unmarshalling\n") return } // get back the header extension hdrExt, err := GetChaincodeHeaderExtension(hdr) if err != nil { t.Fatalf("Could not extract the header extensions from the proposal, err %s\n", err) return } // sanity check on header extension if string(hdrExt.ChaincodeID.Name) != "chaincode_name" { t.Fatalf("Invalid header extension after unmarshalling\n") return } // get back the ChaincodeInvocationSpec cis, err := GetChaincodeInvocationSpec(prop) if err != nil { t.Fatalf("Could not extract chaincode invocation spec from header, err %s\n", err) return } // sanity check on cis if cis.ChaincodeSpec.Type != pb.ChaincodeSpec_GOLANG || cis.ChaincodeSpec.ChaincodeID.Name != "chaincode_name" || len(cis.ChaincodeSpec.CtorMsg.Args) != 2 || string(cis.ChaincodeSpec.CtorMsg.Args[0]) != "arg1" || string(cis.ChaincodeSpec.CtorMsg.Args[1]) != "arg2" { t.Fatalf("Invalid chaincode invocation spec after unmarshalling\n") return } }
func serve(args []string) error { // Parameter overrides must be processed before any paramaters are // cached. Failures to cache cause the server to terminate immediately. if chaincodeDevMode { logger.Info("Running in chaincode development mode") logger.Info("Set consensus to NOOPS and user starts chaincode") logger.Info("Disable loading validity system chaincode") viper.Set("peer.validator.enabled", "true") viper.Set("peer.validator.consensus", "noops") viper.Set("chaincode.mode", chaincode.DevModeUserRunsChaincode) } if err := peer.CacheConfiguration(); err != nil { return err } peerEndpoint, err := peer.GetPeerEndpoint() if err != nil { err = fmt.Errorf("Failed to get Peer Endpoint: %s", err) return err } listenAddr := viper.GetString("peer.listenAddress") if "" == listenAddr { logger.Debug("Listen address not specified, using peer endpoint address") listenAddr = peerEndpoint.Address } lis, err := net.Listen("tcp", listenAddr) if err != nil { grpclog.Fatalf("Failed to listen: %v", err) } ehubLis, ehubGrpcServer, err := createEventHubServer() if err != nil { grpclog.Fatalf("Failed to create ehub server: %v", err) } logger.Infof("Security enabled status: %t", core.SecurityEnabled()) if viper.GetBool("security.privacy") { if core.SecurityEnabled() { logger.Infof("Privacy enabled status: true") } else { panic(errors.New("Privacy cannot be enabled as requested because security is disabled")) } } else { logger.Infof("Privacy enabled status: false") } var opts []grpc.ServerOption if comm.TLSEnabled() { creds, err := credentials.NewServerTLSFromFile(viper.GetString("peer.tls.cert.file"), viper.GetString("peer.tls.key.file")) if err != nil { grpclog.Fatalf("Failed to generate credentials %v", err) } opts = []grpc.ServerOption{grpc.Creds(creds)} } grpcServer := grpc.NewServer(opts...) registerChaincodeSupport(grpcServer) logger.Debugf("Running peer") // Register the Admin server pb.RegisterAdminServer(grpcServer, core.NewAdminServer()) // Register the Endorser server serverEndorser := endorser.NewEndorserServer() pb.RegisterEndorserServer(grpcServer, serverEndorser) // Initialize gossip component bootstrap := viper.GetStringSlice("peer.gossip.bootstrap") service.InitGossipService(peerEndpoint.Address, grpcServer, bootstrap...) defer service.GetGossipService().Stop() //initialize the env for chainless startup initChainless() // Begin startup of default chain if peerDefaultChain { chainID := util.GetTestChainID() block, err := pbutils.MakeConfigurationBlock(chainID) if nil != err { panic(fmt.Sprintf("Unable to create genesis block for [%s] due to [%s]", chainID, err)) } //this creates block and calls JoinChannel on gossip service if err = peer.CreateChainFromBlock(block); err != nil { panic(fmt.Sprintf("Unable to create chain block for [%s] due to [%s]", chainID, err)) } chaincode.DeploySysCCs(chainID) logger.Infof("Deployed system chaincodes on %s", chainID) commit := peer.GetCommitter(chainID) if commit == nil { panic(fmt.Sprintf("Unable to get committer for [%s]", chainID)) } //this shoul not need the chainID. Delivery should be //split up into network part and chain part. This should //only init the network part...TBD, part of Join work deliverService := noopssinglechain.NewDeliverService(chainID) deliverService.Start(commit) defer noopssinglechain.StopDeliveryService(deliverService) } logger.Infof("Starting peer with ID=%s, network ID=%s, address=%s, rootnodes=%v, validator=%v", peerEndpoint.ID, viper.GetString("peer.networkId"), peerEndpoint.Address, viper.GetString("peer.discovery.rootnode"), peer.ValidatorEnabled()) // Start the grpc server. Done in a goroutine so we can deploy the // genesis block if needed. serve := make(chan error) sigs := make(chan os.Signal, 1) signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM) go func() { sig := <-sigs fmt.Println() fmt.Println(sig) serve <- nil }() go func() { var grpcErr error if grpcErr = grpcServer.Serve(lis); grpcErr != nil { grpcErr = fmt.Errorf("grpc server exited with error: %s", grpcErr) } else { logger.Info("grpc server exited") } serve <- grpcErr }() if err := writePid(viper.GetString("peer.fileSystemPath")+"/peer.pid", os.Getpid()); err != nil { return err } // Start the event hub server if ehubGrpcServer != nil && ehubLis != nil { go ehubGrpcServer.Serve(ehubLis) } if viper.GetBool("peer.profile.enabled") { go func() { profileListenAddress := viper.GetString("peer.profile.listenAddress") logger.Infof("Starting profiling server with listenAddress = %s", profileListenAddress) if profileErr := http.ListenAndServe(profileListenAddress, nil); profileErr != nil { logger.Errorf("Error starting profiler: %s", profileErr) } }() } // sets the logging level for the 'error' module to the default value from // core.yaml. it can also be updated dynamically using // "peer logging setlevel error <log-level>" common.SetErrorLoggingLevel() // Block until grpc server exits return <-serve }
// Test deploy of a transaction func TestExecuteDeployTransaction(t *testing.T) { chainID := util.GetTestChainID() executeDeployTransaction(t, chainID, "example01", "github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example01") }