// 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")
}