Tutorial Chaincode Unit Testing on Hyperledger Fabric

Published in

Coinmonks

5 min readJan 14, 2019

Hi everyone! Are you looking for how incorporate a unit test suite to improve the chaincode development in Hyperledger Fabric? I’m here to explain to you how I accomplished to create the testing environment, in golang, that enabled me to really speed up the development of the chaincode because in this way you won’t even need to setup the dev environment anymore (if you design a good test suite, of course).

I organized the tutorial in this way:

MockStub — Shim package that provides APIs for the chaincode to access its state variables, transaction context and call other chaincodes (wiew source).
Go Test — Package testing provides support for automated testing of Go packages. It is intended to be used in concert with the “go test” command, which automates execution of any function (official go documentation).
Test Suite — The Kernel of the tutorial, I’ll show how I implemented my test suite.

MockStub

MockStub, as said before, is the shim package that enables the creation of test functions to directly test the chaincode functions.

Go Test

Thankfully from our point of view testing in go is very, very easy. To run the test suite you have to simply run the command in the repository where the test suite is located:

go test

Test Suite

To write a new test suite, create a file whose name ends _test.go that contains the TestXxx functions, in our case will be <chaincode_name>_test.go

<chaincodeName>_test.go

Now we go in depth to see how I developed some test functions specifically for chaincode development using MockStub functionalities.

Test Logger

First of all I set the logger to print the useful information:

var testLog = shim.NewLogger("<chaincodeName>_test")

Test Comparisons

After that I developed a little “library” composed by some functions that embed the comparisons to speed up the development of the real tests:

checkState
checkNoState
checkQuery
checkBadQuery
checkInvoke
checkBadInvoke

We will look at all these functions in detail.

checkState:

func checkState(t *testing.T, stub *shim.MockStub, name string, value string) {
   bytes := stub.State[name]
   if bytes == nil {
      testLog.Info("State", name, "failed to get value")
      t.FailNow()
   }
   if string(bytes) != value {
      testLog.Info("State value", name, "was", string(bytes), "and not", value, "as expected")
      t.FailNow()
   } else {
      testLog.Info("State value", name, "is", string(bytes), "as expected")
   }
}

checkNoState:

func checkNoState(t *testing.T, stub *shim.MockStub, name string) {
   bytes := stub.State[name]
   if bytes != nil {
      testLog.Info("State", name, "should be absent; found value")
      t.FailNow()
   } else {
      testLog.Info("State", name, "is absent as it should be")
   }
}

check Query (1,2,…,n args):

— for 1 argument:

func checkQueryOneArg(t *testing.T, stub *shim.MockStub, function string, argument string, value string) {
   res := stub.MockInvoke("1", [][]byte{[]byte(function), []byte(argument)})
   if res.Status != shim.OK {
      testLog.Info("Query", function, "failed", string(res.Message))
      t.FailNow()
   }
   if res.Payload == nil {
      testLog.Info("Query", function, "failed to get value")
      t.FailNow()
   }
   payload := string(res.Payload)
   if payload != value {
      testLog.Info("Query value", function, "was", payload, "and not", value, "as expected")
      t.FailNow()
   } else {
      testLog.Info("Query value", function, "is", payload, "as expected")
   }
}

— for 2 arguments:

func checkQueryTwoArgs(t *testing.T, stub *shim.MockStub, function string, argument1 string, argument2 string, value string) {
   res := stub.MockInvoke("1", [][]byte{[]byte(function), []byte(argument1), []byte(argument2)})
   if res.Status != shim.OK {
      testLog.Info("Query", function, "failed", string(res.Message))
      t.FailNow()
   }
   if res.Payload == nil {
      testLog.Info("Query", function, "failed to get value")
      t.FailNow()
   }
   payload := string(res.Payload)
   if payload != value {
      testLog.Info("Query value", function, "was", payload, "and not", value, "as expected")
      t.FailNow()
   } else {
      testLog.Info("Query value", function, "is", payload, "as expected")
   }
}

we can note that the difference is only on the number of arguments in the function call, so we can generalize for n easily…

checkBadQuery:

func checkBadQuery(t *testing.T, stub *shim.MockStub, function string, name string) {
   res := stub.MockInvoke("1", [][]byte{[]byte(function), []byte(name)})
   if res.Status == shim.OK {
      testLog.Info("Query", function, "unexpectedly succeeded")
      t.FailNow()
   } else {
      testLog.Info("Query", function, "failed as espected, with message: ", res.Message)

   }
}

checkInvoke:

func checkInvoke(t *testing.T, stub *shim.MockStub, functionAndArgs []string) {
   functionAndArgsAsBytes := lib.ParseStringSliceToByteSlice(functionAndArgs)
   res := stub.MockInvoke("1", functionAndArgsAsBytes)
   if res.Status != shim.OK {
      testLog.Info("Invoke", functionAndArgs, "failed", string(res.Message))
      t.FailNow()
   } else {
      testLog.Info("Invoke", functionAndArgs, "successful", string(res.Message))
   }
}

checkBadInvoke:

func checkBadInvoke(t *testing.T, stub *shim.MockStub, functionAndArgs []string) {
   functionAndArgsAsBytes := lib.ParseStringSliceToByteSlice(functionAndArgs)
   res := stub.MockInvoke("1", functionAndArgsAsBytes)
   if res.Status == shim.OK {
      testLog.Info("Invoke", functionAndArgs, "unexpectedly succeeded")
      t.FailNow()
   } else {
      testLog.Info("Invoke", functionAndArgs, "failed as espected, with message: "+res.Message)
   }
}

Test Chaincode Functions (an example)

Now let’s go on the real testing of chaincode’s functionalities, for example let’s take as an example a general ‘CreateFeature’ functionality of the chaincode:

//==================================================================
// TestFeatureCreation - Test the 'CreateFeature' function
// =================================================================
func TestFeatureCreation(t *testing.T) {
   simpleChaincode := new(SimpleChaincode)
   simpleChaincode.testMode = true
   mockStub := shim.NewMockStub("Test Feature Creation", simpleChaincode)

   var functionAndArgs []string
   functionName := CreateFeature

   // Invoke 'CreateFeature'
   featureId := NewFeatureId
   featureName := NewFeatureName

   args := []string{featureId, featureName}
   functionAndArgs = append(functionAndArgs, functionName)
   functionAndArgs = append(functionAndArgs, args...)

   checkInvoke(t, mockStub, functionAndArgs)

   feature := &a.Feature{FeatureId: featureId, Name: featureName}
   featureAsBytes, _ := json.Marshal(feature)

   checkState(t, mockStub, featureId, string(featureAsBytes))

   expectedResponse := "{\"FeatureId\":\"" + featureId + "\",\"Name\":\"" + featureName + "\",\"FeatureComposition\":null}"   checkQueryOneArg(t, mockStub, "GetFeature", featureId, expectedResponse)
}

We check 2 things in this test function:

Invoke — Directly calling the checkInvoke passing it the functionAndArgs.
Query — we call “GetFeature” and we put our expectedResponse JSON String.

If everything went good we will se the output with the embedded logs and closing with a:

- - - PASS: TestFeatureCreation (0.00s)

if everything went as espected.

Or a:

- - - FAIL: TestFeatureCreation (0.00s)

if there is something that differs from our expectations. In this case, if we properly set the logs we can se where is the source of the fail, likewise:

2019–01–14 15:48:26.198 CET [innMind_test] Info -> INFO 013 Query value GetFeatureNotFoundError was {“FeatureId”:”idfeature1",”Name”:”Color"} and not {“FeatureId”:”idfeature1",”Name”:”Shape"} as expected

We can easily spot that the expected feature’s name was “Shape” but we got “Color”.

At the end I show how can look a test suite:

You can easily understand how this can speed up the development, if you also think that you can take advantage of the Init function to populate the Testing Ledger with all the data that you need to simulate whatever scenario you have in your mind. We will look at how to Init the Ledger in another article.

I hope this tutorial gave you a brief introduction to start testing your chaincode! If yes don’t hesitate and gimme a loud clap! ;)

See you!

— Valerio

Get Best Software Deals Directly In Your Inbox