// Test the execution of an invalid transaction.
func TestExecuteInvokeInvalidTransaction(t *testing.T) {
var opts []grpc.ServerOption
if viper.GetBool("peer.tls.enabled") {
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...)
viper.Set("peer.fileSystemPath", "/var/openchain/test/tmpdb")
//use a different address than what we usually use for "peer"
//we override the peerAddress set in chaincode_support.go
peerAddress := "0.0.0.0:40303"
lis, err := net.Listen("tcp", peerAddress)
if err != nil {
t.Fail()
t.Logf("Error starting peer listener %s", err)
return
}
getPeerEndpoint := func() (*pb.PeerEndpoint, error) {
return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil
}
ccStartupTimeout := time.Duration(chaincodeStartupTimeoutDefault) * time.Millisecond
pb.RegisterChaincodeSupportServer(grpcServer, NewChaincodeSupport(DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil))
go grpcServer.Serve(lis)
var ctxt = context.Background()
url := "github.com/openblockchain/obc-peer/openchain/example/chaincode/chaincode_example02"
chaincodeID := &pb.ChaincodeID{Path: url}
//FAIL, FAIL!
args := []string{"x", "-1"}
err = invokeExample02Transaction(ctxt, chaincodeID, args)
//this HAS to fail with expectedDeltaStringPrefix
if err != nil {
errStr := err.Error()
t.Logf("Got error %s\n", errStr)
t.Logf("InvalidInvoke test passed")
GetChain(DefaultChain).stopChaincode(ctxt, chaincodeID)
closeListenerAndSleep(lis)
return
}
t.Fail()
t.Logf("Error invoking transaction %s", err)
GetChain(DefaultChain).stopChaincode(ctxt, chaincodeID)
closeListenerAndSleep(lis)
}
// Test deploy of a transaction.
func TestExecuteDeployTransaction(t *testing.T) {
var opts []grpc.ServerOption
if viper.GetBool("peer.tls.enabled") {
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...)
viper.Set("peer.fileSystemPath", "/var/openchain/test/tmpdb")
//lis, err := net.Listen("tcp", viper.GetString("peer.address"))
//use a different address than what we usually use for "peer"
//we override the peerAddress set in chaincode_support.go
peerAddress := "0.0.0.0:40303"
lis, err := net.Listen("tcp", peerAddress)
if err != nil {
t.Fail()
t.Logf("Error starting peer listener %s", err)
return
}
getPeerEndpoint := func() (*pb.PeerEndpoint, error) {
return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil
}
ccStartupTimeout := time.Duration(chaincodeStartupTimeoutDefault) * time.Millisecond
pb.RegisterChaincodeSupportServer(grpcServer, NewChaincodeSupport(DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil))
go grpcServer.Serve(lis)
var ctxt = context.Background()
url := "github.com/openblockchain/obc-peer/openchain/example/chaincode/chaincode_example01"
f := "init"
args := []string{"a", "100", "b", "200"}
spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: &pb.ChaincodeID{Path: url}, CtorMsg: &pb.ChaincodeInput{Function: f, Args: args}}
_, err = deploy(ctxt, spec)
chaincodeID := spec.ChaincodeID.Name
if err != nil {
GetChain(DefaultChain).stopChaincode(ctxt, spec.ChaincodeID)
closeListenerAndSleep(lis)
t.Fail()
t.Logf("Error deploying <%s>: %s", chaincodeID, err)
return
}
GetChain(DefaultChain).stopChaincode(ctxt, spec.ChaincodeID)
closeListenerAndSleep(lis)
}
func registerChaincodeSupport(chainname chaincode.ChainName, grpcServer *grpc.Server, secHelper crypto.Peer) {
//get user mode
userRunsCC := false
if viper.GetString("chaincode.mode") == chaincode.DevModeUserRunsChaincode {
userRunsCC = true
}
//get chaincode startup timeout
tOut, err := strconv.Atoi(viper.GetString("chaincode.startuptimeout"))
if err != nil { //what went wrong ?
fmt.Printf("could not retrive timeout var...setting to 5secs\n")
tOut = 5000
}
ccStartupTimeout := time.Duration(tOut) * time.Millisecond
pb.RegisterChaincodeSupportServer(grpcServer, chaincode.NewChaincodeSupport(chainname, peer.GetPeerEndpoint, userRunsCC, ccStartupTimeout, secHelper))
}
func TestGenesis(t *testing.T) {
//use a different address than what we usually use for "peer"
//we override the peerAddress set in chaincode_support.go
peerAddress := "0.0.0.0:50303"
lis, err := net.Listen("tcp", peerAddress)
if err != nil {
t.Fail()
t.Logf("Error starting peer listener %s", err)
return
}
var opts []grpc.ServerOption
if viper.GetBool("peer.tls.enabled") {
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...)
getPeerEndpoint := func() (*protos.PeerEndpoint, error) {
return &protos.PeerEndpoint{ID: &protos.PeerID{Name: "testpeer"}, Address: peerAddress}, nil
}
ccStartupTimeout := time.Duration(30000) * time.Millisecond
protos.RegisterChaincodeSupportServer(grpcServer, chaincode.NewChaincodeSupport(chaincode.DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil))
go grpcServer.Serve(lis)
ledger := ledger.InitTestLedger(t)
if ledger.GetBlockchainSize() != 0 {
t.Fatalf("Expected blockchain size of 0, but got %d", ledger.GetBlockchainSize())
}
makeGenesisErr := MakeGenesis()
if makeGenesisErr != nil {
t.Fatalf("Error creating genesis block, %s", makeGenesisErr)
}
if ledger.GetBlockchainSize() != 1 {
t.Fatalf("Expected blockchain size of 1, but got %d", ledger.GetBlockchainSize())
}
}
// Test the execution of a chaincode query that queries another chaincode.
func TestChaincodeQueryChaincode(t *testing.T) {
var opts []grpc.ServerOption
if viper.GetBool("peer.tls.enabled") {
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...)
viper.Set("peer.fileSystemPath", "/var/openchain/test/tmpdb")
//use a different address than what we usually use for "peer"
//we override the peerAddress set in chaincode_support.go
peerAddress := "0.0.0.0:40303"
lis, err := net.Listen("tcp", peerAddress)
if err != nil {
t.Fail()
t.Logf("Error starting peer listener %s", err)
return
}
getPeerEndpoint := func() (*pb.PeerEndpoint, error) {
return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil
}
ccStartupTimeout := time.Duration(chaincodeStartupTimeoutDefault) * time.Millisecond
pb.RegisterChaincodeSupportServer(grpcServer, NewChaincodeSupport(DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil))
go grpcServer.Serve(lis)
var ctxt = context.Background()
// Deploy first chaincode
url1 := "github.com/openblockchain/obc-peer/openchain/example/chaincode/chaincode_example02"
cID1 := &pb.ChaincodeID{Path: url1}
f := "init"
args := []string{"a", "100", "b", "200"}
spec1 := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID1, CtorMsg: &pb.ChaincodeInput{Function: f, Args: args}}
_, err = deploy(ctxt, spec1)
chaincodeID1 := spec1.ChaincodeID.Name
if err != nil {
t.Fail()
t.Logf("Error initializing chaincode %s(%s)", chaincodeID1, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
closeListenerAndSleep(lis)
return
}
time.Sleep(time.Second)
// Deploy second chaincode
url2 := "github.com/openblockchain/obc-peer/openchain/example/chaincode/chaincode_example05"
cID2 := &pb.ChaincodeID{Path: url2}
f = "init"
args = []string{"sum", "0"}
spec2 := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Function: f, Args: args}}
_, err = deploy(ctxt, spec2)
chaincodeID2 := spec2.ChaincodeID.Name
if err != nil {
t.Fail()
t.Logf("Error initializing chaincode %s(%s)", chaincodeID2, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
GetChain(DefaultChain).stopChaincode(ctxt, cID2)
closeListenerAndSleep(lis)
return
}
time.Sleep(time.Second)
// Invoke second chaincode, which will inturn query the first chaincode
t.Logf("Starting chaincode query chaincode in transaction mode")
f = "invoke"
args = []string{chaincodeID1, "sum"}
spec2 = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Function: f, Args: args}}
// Invoke chaincode
var retVal []byte
_, retVal, err = invoke(ctxt, spec2, pb.Transaction_CHAINCODE_EXECUTE)
if err != nil {
t.Fail()
t.Logf("Error invoking <%s>: %s", chaincodeID2, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
GetChain(DefaultChain).stopChaincode(ctxt, cID2)
closeListenerAndSleep(lis)
return
}
// Check the return value
result, err := strconv.Atoi(string(retVal))
if err != nil || result != 300 {
t.Fail()
t.Logf("Incorrect final state after transaction for <%s>: %s", chaincodeID1, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
GetChain(DefaultChain).stopChaincode(ctxt, cID2)
closeListenerAndSleep(lis)
return
}
// Query second chaincode, which will inturn query the first chaincode
t.Logf("Starting chaincode query chaincode in query mode")
f = "query"
args = []string{chaincodeID1, "sum"}
spec2 = &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID2, CtorMsg: &pb.ChaincodeInput{Function: f, Args: args}}
// Invoke chaincode
_, retVal, err = invoke(ctxt, spec2, pb.Transaction_CHAINCODE_QUERY)
if err != nil {
t.Fail()
t.Logf("Error querying <%s>: %s", chaincodeID2, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
GetChain(DefaultChain).stopChaincode(ctxt, cID2)
closeListenerAndSleep(lis)
return
}
// Check the return value
result, err = strconv.Atoi(string(retVal))
if err != nil || result != 300 {
t.Fail()
t.Logf("Incorrect final value after query for <%s>: %s", chaincodeID1, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
GetChain(DefaultChain).stopChaincode(ctxt, cID2)
closeListenerAndSleep(lis)
return
}
GetChain(DefaultChain).stopChaincode(ctxt, cID1)
GetChain(DefaultChain).stopChaincode(ctxt, cID2)
closeListenerAndSleep(lis)
}
// Test the execution of a query.
func TestExecuteQuery(t *testing.T) {
var opts []grpc.ServerOption
if viper.GetBool("peer.tls.enabled") {
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...)
viper.Set("peer.fileSystemPath", "/var/openchain/test/tmpdb")
//use a different address than what we usually use for "peer"
//we override the peerAddress set in chaincode_support.go
peerAddress := "0.0.0.0:40303"
lis, err := net.Listen("tcp", peerAddress)
if err != nil {
t.Fail()
t.Logf("Error starting peer listener %s", err)
return
}
getPeerEndpoint := func() (*pb.PeerEndpoint, error) {
return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil
}
ccStartupTimeout := time.Duration(chaincodeStartupTimeoutDefault) * time.Millisecond
pb.RegisterChaincodeSupportServer(grpcServer, NewChaincodeSupport(DefaultChain, getPeerEndpoint, false, ccStartupTimeout, nil))
go grpcServer.Serve(lis)
var ctxt = context.Background()
url := "github.com/openblockchain/obc-peer/openchain/example/chaincode/chaincode_example02"
cID := &pb.ChaincodeID{Path: url}
f := "init"
args := []string{"a", "100", "b", "200"}
spec := &pb.ChaincodeSpec{Type: 1, ChaincodeID: cID, CtorMsg: &pb.ChaincodeInput{Function: f, Args: args}}
_, err = deploy(ctxt, spec)
chaincodeID := spec.ChaincodeID.Name
if err != nil {
t.Fail()
t.Logf("Error initializing chaincode %s(%s)", chaincodeID, err)
GetChain(DefaultChain).stopChaincode(ctxt, cID)
closeListenerAndSleep(lis)
return
}
time.Sleep(2 * time.Second)
//start := getNowMillis()
//fmt.Fprintf(os.Stderr, "Starting: %d\n", start)
numTrans := 2
numQueries := 10
errs := exec(ctxt, chaincodeID, numTrans, numQueries)
var numerrs int
for i := 0; i < numTrans+numQueries; i++ {
if errs[i] != nil {
t.Logf("Error doing query on %d %s", i, errs[i])
numerrs++
}
}
if numerrs == 0 {
t.Logf("Query test passed")
} else {
t.Logf("Query test failed(total errors %d)", numerrs)
t.Fail()
}
//end := getNowMillis()
//fmt.Fprintf(os.Stderr, "Ending: %d\n", end)
//fmt.Fprintf(os.Stderr, "Elapsed : %d millis\n", end-start)
GetChain(DefaultChain).stopChaincode(ctxt, cID)
closeListenerAndSleep(lis)
}
func initVP() {
var opts []grpc.ServerOption
if viper.GetBool("peer.tls.enabled") {
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...)
//lis, err := net.Listen("tcp", viper.GetString("peer.address"))
//use a different address than what we usually use for "peer"
//we override the peerAddress set in chaincode_support.go
peerAddress := "0.0.0.0:40404"
var err error
lis, err = net.Listen("tcp", peerAddress)
if err != nil {
return
}
getPeerEndpoint := func() (*pb.PeerEndpoint, error) {
return &pb.PeerEndpoint{ID: &pb.PeerID{Name: "testpeer"}, Address: peerAddress}, nil
}
ccStartupTimeout := time.Duration(chaincodeStartupTimeoutDefault) * time.Millisecond
userRunsCC := true
// Install security object for peer
var secHelper crypto.Peer
if viper.GetBool("security.enabled") {
enrollID := viper.GetString("security.enrollID")
enrollSecret := viper.GetString("security.enrollSecret")
var err error
if viper.GetBool("peer.validator.enabled") {
testLogger.Debug("Registering validator with enroll ID: %s", enrollID)
if err = crypto.RegisterValidator(enrollID, nil, enrollID, enrollSecret); nil != err {
panic(err)
}
testLogger.Debug("Initializing validator with enroll ID: %s", enrollID)
secHelper, err = crypto.InitValidator(enrollID, nil)
if nil != err {
panic(err)
}
} else {
testLogger.Debug("Registering non-validator with enroll ID: %s", enrollID)
if err = crypto.RegisterPeer(enrollID, nil, enrollID, enrollSecret); nil != err {
panic(err)
}
testLogger.Debug("Initializing non-validator with enroll ID: %s", enrollID)
secHelper, err = crypto.InitPeer(enrollID, nil)
if nil != err {
panic(err)
}
}
}
pb.RegisterChaincodeSupportServer(grpcServer,
chaincode.NewChaincodeSupport(chaincode.DefaultChain, getPeerEndpoint, userRunsCC,
ccStartupTimeout, secHelper))
grpcServer.Serve(lis)
}