From 811bc62d65b5bc8e7d991391d97fb10f0cd040ab Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Tue, 8 Feb 2022 17:15:45 +0100
Subject: [PATCH 01/19] test: cli test setup & test chain head

CLI actions lack unit tests. I decided to use the approach similar to
what I found in `send_test.go` using gomock, but I don't rely on custom
"service" implementations but mock the whole FullNode API.
This first commit validates the test setup by testing the simplest method
of the chain category, e.g. `chain head`.

This requires a minor refactor of the CLI action code:
- The constructor (`GetFullNodeAPI`) checks if there's an injected mock
API in the app Metadata and uses that in unit tests.
- Actions shouldn't use raw `fmt.*` but instead write to the `app.Writer`
so the CLI output is testable
---
 cli/chain.go      |  4 +++-
 cli/chain_test.go | 54 +++++++++++++++++++++++++++++++++++++++++++++++
 cli/util/api.go   |  5 +++++
 3 files changed, 62 insertions(+), 1 deletion(-)
 create mode 100644 cli/chain_test.go

diff --git a/cli/chain.go b/cli/chain.go
index 0cbdaa0f7..e782d2ca9 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -67,6 +67,8 @@ var ChainHeadCmd = &cli.Command{
 	Name:  "head",
 	Usage: "Print chain head",
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -80,7 +82,7 @@ var ChainHeadCmd = &cli.Command{
 		}
 
 		for _, c := range head.Cids() {
-			fmt.Println(c)
+			afmt.Println(c)
 		}
 		return nil
 	},
diff --git a/cli/chain_test.go b/cli/chain_test.go
new file mode 100644
index 000000000..c8c491e4d
--- /dev/null
+++ b/cli/chain_test.go
@@ -0,0 +1,54 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"regexp"
+	"testing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/mocks"
+	"github.com/filecoin-project/lotus/chain/types/mock"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+	ucli "github.com/urfave/cli/v2"
+)
+
+// newMockAppWithFullAPI returns a gomock-ed CLI app used for unit tests
+// see cli/util/api.go:GetFullNodeAPI for mock API injection
+func newMockAppWithFullAPI(t *testing.T, cmd *ucli.Command) (*ucli.App, *mocks.MockFullNode, *bytes.Buffer, func()) {
+	app := ucli.NewApp()
+	app.Commands = ucli.Commands{cmd}
+	app.Setup()
+
+	// create and inject the mock API into app Metadata
+	ctrl := gomock.NewController(t)
+	mockFullNode := mocks.NewMockFullNode(ctrl)
+	var fullNode api.FullNode = mockFullNode
+	app.Metadata["test-full-api"] = fullNode
+
+	// this will only work if the implementation uses the app.Writer,
+	// if it uses fmt.*, it has to be refactored
+	buf := &bytes.Buffer{}
+	app.Writer = buf
+
+	return app, mockFullNode, buf, ctrl.Finish
+}
+
+func TestChainHead(t *testing.T) {
+	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainHeadCmd))
+	defer done()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	ts := mock.TipSet(mock.MkBlock(nil, 0, 0))
+	gomock.InOrder(
+		mockApi.EXPECT().ChainHead(ctx).Return(ts, nil),
+	)
+
+	err := app.Run([]string{"chain", "head"})
+	assert.NoError(t, err)
+
+	assert.Regexp(t, regexp.MustCompile(ts.Cids()[0].String()), buf.String())
+}
diff --git a/cli/util/api.go b/cli/util/api.go
index 4a7247b32..97e4f2cb8 100644
--- a/cli/util/api.go
+++ b/cli/util/api.go
@@ -223,6 +223,11 @@ func GetCommonAPI(ctx *cli.Context) (api.CommonNet, jsonrpc.ClientCloser, error)
 }
 
 func GetFullNodeAPI(ctx *cli.Context) (v0api.FullNode, jsonrpc.ClientCloser, error) {
+	// use the mocked API in CLI unit tests, see cli/chain_test.go for mock definition
+	if mock, ok := ctx.App.Metadata["test-full-api"]; ok {
+		return &v0api.WrapperV1Full{FullNode: mock.(v1api.FullNode)}, func() {}, nil
+	}
+
 	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
 		return &v0api.WrapperV1Full{FullNode: tn.(v1api.FullNode)}, func() {}, nil
 	}

From 78649d45b90576411e9821bc7a86f065e9b79165 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Tue, 8 Feb 2022 18:24:45 +0100
Subject: [PATCH 02/19] test: cli chain getblock command

Unit test for the cli `chain getblock` command.
Tests if output is JSON  in the expected format.
---
 cli/chain.go      |  7 ++++---
 cli/chain_test.go | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index e782d2ca9..4d03ac4f7 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -99,6 +99,8 @@ var ChainGetBlock = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -126,7 +128,7 @@ var ChainGetBlock = &cli.Command{
 				return err
 			}
 
-			fmt.Println(string(out))
+			afmt.Println(string(out))
 			return nil
 		}
 
@@ -165,9 +167,8 @@ var ChainGetBlock = &cli.Command{
 			return err
 		}
 
-		fmt.Println(string(out))
+		afmt.Println(string(out))
 		return nil
-
 	},
 }
 
diff --git a/cli/chain_test.go b/cli/chain_test.go
index c8c491e4d..eb98110f0 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -3,13 +3,16 @@ package cli
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"regexp"
 	"testing"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/mocks"
+	types "github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/golang/mock/gomock"
+	cid "github.com/ipfs/go-cid"
 	"github.com/stretchr/testify/assert"
 	ucli "github.com/urfave/cli/v2"
 )
@@ -52,3 +55,38 @@ func TestChainHead(t *testing.T) {
 
 	assert.Regexp(t, regexp.MustCompile(ts.Cids()[0].String()), buf.String())
 }
+
+// TestGetBlock checks if "lotus chain getblock" returns the block information in the expected format
+func TestGetBlock(t *testing.T) {
+	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainGetBlock))
+	defer done()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	block := mock.MkBlock(nil, 0, 0)
+	blockMsgs := api.BlockMessages{}
+
+	gomock.InOrder(
+		mockApi.EXPECT().ChainGetBlock(ctx, block.Cid()).Return(block, nil),
+		mockApi.EXPECT().ChainGetBlockMessages(ctx, block.Cid()).Return(&blockMsgs, nil),
+		mockApi.EXPECT().ChainGetParentMessages(ctx, block.Cid()).Return([]api.Message{}, nil),
+		mockApi.EXPECT().ChainGetParentReceipts(ctx, block.Cid()).Return([]*types.MessageReceipt{}, nil),
+	)
+
+	err := app.Run([]string{"chain", "getblock", block.Cid().String()})
+	assert.NoError(t, err)
+
+	out := struct {
+		types.BlockHeader
+		BlsMessages    []*types.Message
+		SecpkMessages  []*types.SignedMessage
+		ParentReceipts []*types.MessageReceipt
+		ParentMessages []cid.Cid
+	}{}
+
+	err = json.Unmarshal(buf.Bytes(), &out)
+	assert.NoError(t, err)
+
+	assert.True(t, block.Cid().Equals(out.Cid()))
+}

From 1cd590ace93d627fee4d8d8d92ae130dd125f45e Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Wed, 9 Feb 2022 15:29:10 +0100
Subject: [PATCH 03/19] test: chain read-obj

Simple test that checks if this CLI method prints the IPLD node referenced
by the given CID encoded in hexadecimal.
---
 cli/chain.go      |  4 +++-
 cli/chain_test.go | 27 ++++++++++++++++++++++++++-
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index 4d03ac4f7..43d5ffb1f 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -185,6 +185,8 @@ var ChainReadObjCmd = &cli.Command{
 	Usage:     "Read the raw bytes of an object",
 	ArgsUsage: "[objectCid]",
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -202,7 +204,7 @@ var ChainReadObjCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Printf("%x\n", obj)
+		afmt.Printf("%x\n", obj)
 		return nil
 	},
 }
diff --git a/cli/chain_test.go b/cli/chain_test.go
index eb98110f0..4a961d022 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"regexp"
 	"testing"
 
@@ -56,7 +57,7 @@ func TestChainHead(t *testing.T) {
 	assert.Regexp(t, regexp.MustCompile(ts.Cids()[0].String()), buf.String())
 }
 
-// TestGetBlock checks if "lotus chain getblock" returns the block information in the expected format
+// TestGetBlock checks if "chain getblock" returns the block information in the expected format
 func TestGetBlock(t *testing.T) {
 	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainGetBlock))
 	defer done()
@@ -77,6 +78,7 @@ func TestGetBlock(t *testing.T) {
 	err := app.Run([]string{"chain", "getblock", block.Cid().String()})
 	assert.NoError(t, err)
 
+	// expected output format
 	out := struct {
 		types.BlockHeader
 		BlsMessages    []*types.Message
@@ -90,3 +92,26 @@ func TestGetBlock(t *testing.T) {
 
 	assert.True(t, block.Cid().Equals(out.Cid()))
 }
+
+// TestChainReadObj checks if "chain read-obj" prints the referenced IPLD node as hex, if exists
+func TestReadOjb(t *testing.T) {
+	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainReadObjCmd))
+	defer done()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	block := mock.MkBlock(nil, 0, 0)
+	obj := new(bytes.Buffer)
+	err := block.MarshalCBOR(obj)
+	assert.NoError(t, err)
+
+	gomock.InOrder(
+		mockApi.EXPECT().ChainReadObj(ctx, block.Cid()).Return(obj.Bytes(), nil),
+	)
+
+	err = app.Run([]string{"chain", "read-obj", block.Cid().String()})
+	assert.NoError(t, err)
+
+	assert.Equal(t, buf.String(), fmt.Sprintf("%x\n", obj.Bytes()))
+}

From c0f47e5eed5e6e83aa289d0455e075ef9d8f3d17 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Wed, 9 Feb 2022 15:56:13 +0100
Subject: [PATCH 04/19] test: chain delete-obj cli command

Contains two subtests, that check if the --really-do-it flag (force)
is respected, since removing wrong objects may lead to sync issues.
---
 cli/chain.go      |  4 +++-
 cli/chain_test.go | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/cli/chain.go b/cli/chain.go
index 43d5ffb1f..26524badb 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -220,6 +220,8 @@ var ChainDeleteObjCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -241,7 +243,7 @@ var ChainDeleteObjCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Printf("Obj %s deleted\n", c.String())
+		afmt.Printf("Obj %s deleted\n", c.String())
 		return nil
 	},
 }
diff --git a/cli/chain_test.go b/cli/chain_test.go
index 4a961d022..b20ecbf31 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -115,3 +115,36 @@ func TestReadOjb(t *testing.T) {
 
 	assert.Equal(t, buf.String(), fmt.Sprintf("%x\n", obj.Bytes()))
 }
+
+// TestChainDeleteObj checks if "chain delete-obj" deletes an object from the chain blockstore, respecting the --really-do-it flag
+func TestChainDeleteObj(t *testing.T) {
+	cmd := WithCategory("chain", ChainDeleteObjCmd)
+	block := mock.MkBlock(nil, 0, 0)
+
+	// given no force flag, it should return an error and no API calls should be made
+	t.Run("no-really-do-it", func(t *testing.T) {
+		app, _, _, done := newMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		err := app.Run([]string{"chain", "delete-obj", block.Cid().String()})
+		assert.Error(t, err)
+	})
+
+	// given a force flag, API delete should be called
+	t.Run("really-do-it", func(t *testing.T) {
+		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainDeleteObj(ctx, block.Cid()).Return(nil),
+		)
+
+		err := app.Run([]string{"chain", "delete-obj", "--really-do-it=true", block.Cid().String()})
+		assert.NoError(t, err)
+
+		assert.Contains(t, buf.String(), block.Cid().String())
+	})
+}

From a923d7c884d155d7fb83811b320878205b1592fa Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Wed, 9 Feb 2022 16:22:52 +0100
Subject: [PATCH 05/19] test: chain stat-obj cli command

Test expected output with respect to the --base flag
---
 cli/chain.go      |  5 +++--
 cli/chain_test.go | 53 ++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 55 insertions(+), 3 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index 26524badb..10fa9900f 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -264,6 +264,7 @@ var ChainStatObjCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -289,8 +290,8 @@ var ChainStatObjCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Printf("Links: %d\n", stats.Links)
-		fmt.Printf("Size: %s (%d)\n", types.SizeStr(types.NewInt(stats.Size)), stats.Size)
+		afmt.Printf("Links: %d\n", stats.Links)
+		afmt.Printf("Size: %s (%d)\n", types.SizeStr(types.NewInt(stats.Size)), stats.Size)
 		return nil
 	},
 }
diff --git a/cli/chain_test.go b/cli/chain_test.go
index b20ecbf31..fd43644d1 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"regexp"
+	"strings"
 	"testing"
 
 	"github.com/filecoin-project/lotus/api"
@@ -130,7 +131,7 @@ func TestChainDeleteObj(t *testing.T) {
 		assert.Error(t, err)
 	})
 
-	// given a force flag, API delete should be called
+	// given a force flag, it calls API delete
 	t.Run("really-do-it", func(t *testing.T) {
 		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
 		defer done()
@@ -148,3 +149,53 @@ func TestChainDeleteObj(t *testing.T) {
 		assert.Contains(t, buf.String(), block.Cid().String())
 	})
 }
+
+func TestChainStatObj(t *testing.T) {
+	cmd := WithCategory("chain", ChainStatObjCmd)
+	block := mock.MkBlock(nil, 0, 0)
+	stat := api.ObjStat{Size: 123, Links: 321}
+
+	checkOutput := func(buf *bytes.Buffer) {
+		out := buf.String()
+		outSplit := strings.Split(out, "\n")
+
+		assert.Contains(t, outSplit[0], fmt.Sprintf("%d", stat.Links))
+		assert.Contains(t, outSplit[1], fmt.Sprintf("%d", stat.Size))
+	}
+
+	// given no --base flag, it calls ChainStatObj with base=cid.Undef
+	t.Run("no-base", func(t *testing.T) {
+		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainStatObj(ctx, block.Cid(), cid.Undef).Return(stat, nil),
+		)
+
+		err := app.Run([]string{"chain", "stat-obj", block.Cid().String()})
+		assert.NoError(t, err)
+
+		checkOutput(buf)
+	})
+
+	// given a --base flag, it calls ChainStatObj with that base
+	t.Run("base", func(t *testing.T) {
+		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainStatObj(ctx, block.Cid(), block.Cid()).Return(stat, nil),
+		)
+
+		err := app.Run([]string{"chain", "stat-obj", fmt.Sprintf("-base=%s", block.Cid().String()), block.Cid().String()})
+		assert.NoError(t, err)
+
+		checkOutput(buf)
+	})
+}

From e797ec138d32b5840af6c52deb0e1d4c323b3b2b Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Wed, 9 Feb 2022 17:29:29 +0100
Subject: [PATCH 06/19] test: chain getmessage cli command

I also added some helper functions for mocking in the types/mock pkg
---
 chain/types/mock/chain.go | 38 +++++++++++++++++++++++++++++---------
 cli/chain.go              |  4 +++-
 cli/chain_test.go         | 35 +++++++++++++++++++++++++++++++++++
 3 files changed, 67 insertions(+), 10 deletions(-)

diff --git a/chain/types/mock/chain.go b/chain/types/mock/chain.go
index e4bb2fcee..c69f7f56f 100644
--- a/chain/types/mock/chain.go
+++ b/chain/types/mock/chain.go
@@ -2,6 +2,7 @@ package mock
 
 import (
 	"context"
+	"crypto/rand"
 	"fmt"
 
 	"github.com/filecoin-project/go-address"
@@ -24,15 +25,7 @@ func Address(i uint64) address.Address {
 }
 
 func MkMessage(from, to address.Address, nonce uint64, w *wallet.LocalWallet) *types.SignedMessage {
-	msg := &types.Message{
-		To:         to,
-		From:       from,
-		Value:      types.NewInt(1),
-		Nonce:      nonce,
-		GasLimit:   1000000,
-		GasFeeCap:  types.NewInt(100),
-		GasPremium: types.NewInt(1),
-	}
+	msg := UnsignedMessage(from, to, nonce)
 
 	sig, err := w.WalletSign(context.TODO(), from, msg.Cid().Bytes(), api.MsgMeta{})
 	if err != nil {
@@ -96,3 +89,30 @@ func TipSet(blks ...*types.BlockHeader) *types.TipSet {
 	}
 	return ts
 }
+
+func RandomActorAddress() (*address.Address, error) {
+	bytes := make([]byte, 32)
+	_, err := rand.Read(bytes)
+	if err != nil {
+		return nil, err
+	}
+
+	addr, err := address.NewActorAddress(bytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return &addr, nil
+}
+
+func UnsignedMessage(from, to address.Address, nonce uint64) *types.Message {
+	return &types.Message{
+		To:         to,
+		From:       from,
+		Value:      types.NewInt(1),
+		Nonce:      nonce,
+		GasLimit:   1000000,
+		GasFeeCap:  types.NewInt(100),
+		GasPremium: types.NewInt(1),
+	}
+}
diff --git a/cli/chain.go b/cli/chain.go
index 10fa9900f..d3259c6c8 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -301,6 +301,8 @@ var ChainGetMsgCmd = &cli.Command{
 	Usage:     "Get and print a message by its cid",
 	ArgsUsage: "[messageCid]",
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		if !cctx.Args().Present() {
 			return fmt.Errorf("must pass a cid of a message to get")
 		}
@@ -339,7 +341,7 @@ var ChainGetMsgCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Println(string(enc))
+		afmt.Println(string(enc))
 		return nil
 	},
 }
diff --git a/cli/chain_test.go b/cli/chain_test.go
index fd43644d1..064393f3a 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -150,6 +150,7 @@ func TestChainDeleteObj(t *testing.T) {
 	})
 }
 
+// TestChainStatObj checks if "chain delete-obj" prints size and IPLD link counts for object, respecting the --base flag
 func TestChainStatObj(t *testing.T) {
 	cmd := WithCategory("chain", ChainStatObjCmd)
 	block := mock.MkBlock(nil, 0, 0)
@@ -199,3 +200,37 @@ func TestChainStatObj(t *testing.T) {
 		checkOutput(buf)
 	})
 }
+
+// TestChainGetMsg checks if "chain getmessage" properly decodes and serializes as JSON a Message fetched from the IPLD store
+func TestChainGetMsg(t *testing.T) {
+	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainGetMsgCmd))
+	defer done()
+
+	from, err := mock.RandomActorAddress()
+	assert.NoError(t, err)
+
+	to, err := mock.RandomActorAddress()
+	assert.NoError(t, err)
+
+	msg := mock.UnsignedMessage(*from, *to, 0)
+
+	obj := new(bytes.Buffer)
+	err = msg.MarshalCBOR(obj)
+	assert.NoError(t, err)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	gomock.InOrder(
+		mockApi.EXPECT().ChainReadObj(ctx, msg.Cid()).Return(obj.Bytes(), nil),
+	)
+
+	err = app.Run([]string{"chain", "getmessage", msg.Cid().String()})
+	assert.NoError(t, err)
+
+	var out types.Message
+	err = json.Unmarshal(buf.Bytes(), &out)
+	assert.NoError(t, err)
+
+	assert.Equal(t, *msg, out)
+}

From ae49729afb5699a85fba7707dc798e0d9822ecb5 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Wed, 9 Feb 2022 20:46:51 +0100
Subject: [PATCH 07/19] test: chain sethead cli command

Also moved the mock definition to a separate file (mocks_test.go)
because it's gonna be used in other test files, and it didn't make sense
for it to stay inside chain_test.go.
---
 cli/chain_test.go | 100 ++++++++++++++++++++++++++++++++--------------
 cli/mocks_test.go |  32 +++++++++++++++
 cli/util/api.go   |   2 +-
 3 files changed, 102 insertions(+), 32 deletions(-)
 create mode 100644 cli/mocks_test.go

diff --git a/cli/chain_test.go b/cli/chain_test.go
index 064393f3a..7607ea08d 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -9,39 +9,17 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/mocks"
 	types "github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/golang/mock/gomock"
 	cid "github.com/ipfs/go-cid"
 	"github.com/stretchr/testify/assert"
-	ucli "github.com/urfave/cli/v2"
 )
 
-// newMockAppWithFullAPI returns a gomock-ed CLI app used for unit tests
-// see cli/util/api.go:GetFullNodeAPI for mock API injection
-func newMockAppWithFullAPI(t *testing.T, cmd *ucli.Command) (*ucli.App, *mocks.MockFullNode, *bytes.Buffer, func()) {
-	app := ucli.NewApp()
-	app.Commands = ucli.Commands{cmd}
-	app.Setup()
-
-	// create and inject the mock API into app Metadata
-	ctrl := gomock.NewController(t)
-	mockFullNode := mocks.NewMockFullNode(ctrl)
-	var fullNode api.FullNode = mockFullNode
-	app.Metadata["test-full-api"] = fullNode
-
-	// this will only work if the implementation uses the app.Writer,
-	// if it uses fmt.*, it has to be refactored
-	buf := &bytes.Buffer{}
-	app.Writer = buf
-
-	return app, mockFullNode, buf, ctrl.Finish
-}
-
 func TestChainHead(t *testing.T) {
-	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainHeadCmd))
+	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainHeadCmd))
 	defer done()
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -60,7 +38,7 @@ func TestChainHead(t *testing.T) {
 
 // TestGetBlock checks if "chain getblock" returns the block information in the expected format
 func TestGetBlock(t *testing.T) {
-	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainGetBlock))
+	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainGetBlock))
 	defer done()
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -96,7 +74,7 @@ func TestGetBlock(t *testing.T) {
 
 // TestChainReadObj checks if "chain read-obj" prints the referenced IPLD node as hex, if exists
 func TestReadOjb(t *testing.T) {
-	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainReadObjCmd))
+	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainReadObjCmd))
 	defer done()
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -124,7 +102,7 @@ func TestChainDeleteObj(t *testing.T) {
 
 	// given no force flag, it should return an error and no API calls should be made
 	t.Run("no-really-do-it", func(t *testing.T) {
-		app, _, _, done := newMockAppWithFullAPI(t, cmd)
+		app, _, _, done := NewMockAppWithFullAPI(t, cmd)
 		defer done()
 
 		err := app.Run([]string{"chain", "delete-obj", block.Cid().String()})
@@ -133,7 +111,7 @@ func TestChainDeleteObj(t *testing.T) {
 
 	// given a force flag, it calls API delete
 	t.Run("really-do-it", func(t *testing.T) {
-		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
 		defer done()
 
 		ctx, cancel := context.WithCancel(context.Background())
@@ -166,7 +144,7 @@ func TestChainStatObj(t *testing.T) {
 
 	// given no --base flag, it calls ChainStatObj with base=cid.Undef
 	t.Run("no-base", func(t *testing.T) {
-		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
 		defer done()
 
 		ctx, cancel := context.WithCancel(context.Background())
@@ -184,7 +162,7 @@ func TestChainStatObj(t *testing.T) {
 
 	// given a --base flag, it calls ChainStatObj with that base
 	t.Run("base", func(t *testing.T) {
-		app, mockApi, buf, done := newMockAppWithFullAPI(t, cmd)
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
 		defer done()
 
 		ctx, cancel := context.WithCancel(context.Background())
@@ -203,7 +181,7 @@ func TestChainStatObj(t *testing.T) {
 
 // TestChainGetMsg checks if "chain getmessage" properly decodes and serializes as JSON a Message fetched from the IPLD store
 func TestChainGetMsg(t *testing.T) {
-	app, mockApi, buf, done := newMockAppWithFullAPI(t, WithCategory("chain", ChainGetMsgCmd))
+	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainGetMsgCmd))
 	defer done()
 
 	from, err := mock.RandomActorAddress()
@@ -234,3 +212,63 @@ func TestChainGetMsg(t *testing.T) {
 
 	assert.Equal(t, *msg, out)
 }
+
+func TestSetHead(t *testing.T) {
+	cmd := WithCategory("chain", ChainSetHeadCmd)
+	genesis := mock.TipSet(mock.MkBlock(nil, 0, 0))
+	ts := mock.TipSet(mock.MkBlock(genesis, 1, 0))
+	epoch := abi.ChainEpoch(uint64(0))
+
+	// given the -genesis flag, resets head to genesis ignoring the provided ts positional argument
+	t.Run("genesis", func(t *testing.T) {
+		app, mockApi, _, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainGetGenesis(ctx).Return(genesis, nil),
+			mockApi.EXPECT().ChainSetHead(ctx, genesis.Key()).Return(nil),
+		)
+
+		err := app.Run([]string{"chain", "sethead", "-genesis=true", ts.Key().String()})
+		assert.NoError(t, err)
+	})
+
+	// given the -epoch flag, resets head to given epoch, ignoring the provided ts positional argument
+	t.Run("epoch", func(t *testing.T) {
+		app, mockApi, _, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainGetTipSetByHeight(ctx, epoch, types.EmptyTSK).Return(genesis, nil),
+			mockApi.EXPECT().ChainSetHead(ctx, genesis.Key()).Return(nil),
+		)
+
+		err := app.Run([]string{"chain", "sethead", fmt.Sprintf("-epoch=%s", epoch), ts.Key().String()})
+		assert.NoError(t, err)
+	})
+
+	// given no flag, resets the head to given tipset key
+	t.Run("default", func(t *testing.T) {
+		app, mockApi, _, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainGetBlock(ctx, ts.Key().Cids()[0]).Return(ts.Blocks()[0], nil),
+			mockApi.EXPECT().ChainSetHead(ctx, ts.Key()).Return(nil),
+		)
+
+		// ts.Key should be passed as an array of arguments (CIDs)
+		// since we have only one CID in the key, this is ok
+		err := app.Run([]string{"chain", "sethead", ts.Key().Cids()[0].String()})
+		assert.NoError(t, err)
+	})
+}
diff --git a/cli/mocks_test.go b/cli/mocks_test.go
new file mode 100644
index 000000000..c9cccac08
--- /dev/null
+++ b/cli/mocks_test.go
@@ -0,0 +1,32 @@
+package cli
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/mocks"
+	"github.com/golang/mock/gomock"
+	ucli "github.com/urfave/cli/v2"
+)
+
+// newMockAppWithFullAPI returns a gomock-ed CLI app used for unit tests
+// see cli/util/api.go:GetFullNodeAPI for mock API injection
+func NewMockAppWithFullAPI(t *testing.T, cmd *ucli.Command) (*ucli.App, *mocks.MockFullNode, *bytes.Buffer, func()) {
+	app := ucli.NewApp()
+	app.Commands = ucli.Commands{cmd}
+	app.Setup()
+
+	// create and inject the mock API into app Metadata
+	ctrl := gomock.NewController(t)
+	mockFullNode := mocks.NewMockFullNode(ctrl)
+	var fullNode api.FullNode = mockFullNode
+	app.Metadata["test-full-api"] = fullNode
+
+	// this will only work if the implementation uses the app.Writer,
+	// if it uses fmt.*, it has to be refactored
+	buf := &bytes.Buffer{}
+	app.Writer = buf
+
+	return app, mockFullNode, buf, ctrl.Finish
+}
diff --git a/cli/util/api.go b/cli/util/api.go
index 97e4f2cb8..d87817bb3 100644
--- a/cli/util/api.go
+++ b/cli/util/api.go
@@ -223,7 +223,7 @@ func GetCommonAPI(ctx *cli.Context) (api.CommonNet, jsonrpc.ClientCloser, error)
 }
 
 func GetFullNodeAPI(ctx *cli.Context) (v0api.FullNode, jsonrpc.ClientCloser, error) {
-	// use the mocked API in CLI unit tests, see cli/chain_test.go for mock definition
+	// use the mocked API in CLI unit tests, see cli/mocks_test.go for mock definition
 	if mock, ok := ctx.App.Metadata["test-full-api"]; ok {
 		return &v0api.WrapperV1Full{FullNode: mock.(v1api.FullNode)}, func() {}, nil
 	}

From 4e37131602c30e2734d4c7a20a1908cc311499be Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Wed, 9 Feb 2022 23:47:40 +0100
Subject: [PATCH 08/19] test: chain inspect-usage cli command

---
 cli/chain.go      | 19 ++++++++--------
 cli/chain_test.go | 57 ++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 62 insertions(+), 14 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index d3259c6c8..03dc309e0 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -416,6 +416,7 @@ var ChainInspectUsage = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -517,23 +518,23 @@ var ChainInspectUsage = &cli.Command{
 
 		numRes := cctx.Int("num-results")
 
-		fmt.Printf("Total Gas Limit: %d\n", sum)
-		fmt.Printf("By Sender:\n")
+		afmt.Printf("Total Gas Limit: %d\n", sum)
+		afmt.Printf("By Sender:\n")
 		for i := 0; i < numRes && i < len(senderVals); i++ {
 			sv := senderVals[i]
-			fmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, bySenderC[sv.Key])
+			afmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, bySenderC[sv.Key])
 		}
-		fmt.Println()
-		fmt.Printf("By Receiver:\n")
+		afmt.Println()
+		afmt.Printf("By Receiver:\n")
 		for i := 0; i < numRes && i < len(destVals); i++ {
 			sv := destVals[i]
-			fmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, byDestC[sv.Key])
+			afmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, byDestC[sv.Key])
 		}
-		fmt.Println()
-		fmt.Printf("By Method:\n")
+		afmt.Println()
+		afmt.Printf("By Method:\n")
 		for i := 0; i < numRes && i < len(methodVals); i++ {
 			sv := methodVals[i]
-			fmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, byMethodC[sv.Key])
+			afmt.Printf("%s\t%0.2f%%\t(total: %d, count: %d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas, byMethodC[sv.Key])
 		}
 
 		return nil
diff --git a/cli/chain_test.go b/cli/chain_test.go
index 7607ea08d..105d9d550 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -10,9 +10,11 @@ import (
 	"testing"
 
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/api"
 	types "github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
+	"github.com/filecoin-project/specs-actors/v7/actors/builtin"
 	"github.com/golang/mock/gomock"
 	cid "github.com/ipfs/go-cid"
 	"github.com/stretchr/testify/assert"
@@ -36,7 +38,6 @@ func TestChainHead(t *testing.T) {
 	assert.Regexp(t, regexp.MustCompile(ts.Cids()[0].String()), buf.String())
 }
 
-// TestGetBlock checks if "chain getblock" returns the block information in the expected format
 func TestGetBlock(t *testing.T) {
 	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainGetBlock))
 	defer done()
@@ -72,7 +73,6 @@ func TestGetBlock(t *testing.T) {
 	assert.True(t, block.Cid().Equals(out.Cid()))
 }
 
-// TestChainReadObj checks if "chain read-obj" prints the referenced IPLD node as hex, if exists
 func TestReadOjb(t *testing.T) {
 	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainReadObjCmd))
 	defer done()
@@ -95,7 +95,6 @@ func TestReadOjb(t *testing.T) {
 	assert.Equal(t, buf.String(), fmt.Sprintf("%x\n", obj.Bytes()))
 }
 
-// TestChainDeleteObj checks if "chain delete-obj" deletes an object from the chain blockstore, respecting the --really-do-it flag
 func TestChainDeleteObj(t *testing.T) {
 	cmd := WithCategory("chain", ChainDeleteObjCmd)
 	block := mock.MkBlock(nil, 0, 0)
@@ -128,7 +127,6 @@ func TestChainDeleteObj(t *testing.T) {
 	})
 }
 
-// TestChainStatObj checks if "chain delete-obj" prints size and IPLD link counts for object, respecting the --base flag
 func TestChainStatObj(t *testing.T) {
 	cmd := WithCategory("chain", ChainStatObjCmd)
 	block := mock.MkBlock(nil, 0, 0)
@@ -179,7 +177,6 @@ func TestChainStatObj(t *testing.T) {
 	})
 }
 
-// TestChainGetMsg checks if "chain getmessage" properly decodes and serializes as JSON a Message fetched from the IPLD store
 func TestChainGetMsg(t *testing.T) {
 	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainGetMsgCmd))
 	defer done()
@@ -272,3 +269,53 @@ func TestSetHead(t *testing.T) {
 		assert.NoError(t, err)
 	})
 }
+
+func TestInspectUsage(t *testing.T) {
+	cmd := WithCategory("chain", ChainInspectUsage)
+	ts := mock.TipSet(mock.MkBlock(nil, 0, 0))
+
+	from, err := mock.RandomActorAddress()
+	assert.NoError(t, err)
+
+	to, err := mock.RandomActorAddress()
+	assert.NoError(t, err)
+
+	msg := mock.UnsignedMessage(*from, *to, 0)
+	msgs := []api.Message{{Cid: msg.Cid(), Message: msg}}
+
+	actor := &types.Actor{
+		Code:    builtin.StorageMarketActorCodeID,
+		Nonce:   0,
+		Balance: big.NewInt(1000000000),
+	}
+
+	t.Run("default", func(t *testing.T) {
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainHead(ctx).Return(ts, nil),
+			mockApi.EXPECT().ChainGetParentMessages(ctx, ts.Blocks()[0].Cid()).Return(msgs, nil),
+			mockApi.EXPECT().ChainGetTipSet(ctx, ts.Parents()).Return(nil, nil),
+			mockApi.EXPECT().StateGetActor(ctx, *to, ts.Key()).Return(actor, nil),
+		)
+
+		err := app.Run([]string{"chain", "inspect-usage"})
+		assert.NoError(t, err)
+
+		out := buf.String()
+
+		fmt.Println("🔥: ", out)
+
+		// output is plaintext, had to do string matching
+		assert.Contains(t, out, "By Sender")
+		assert.Contains(t, out, from.String())
+		assert.Contains(t, out, "By Receiver")
+		assert.Contains(t, out, to.String())
+		assert.Contains(t, out, "By Method")
+		assert.Contains(t, out, "Send")
+	})
+}

From b3f7db7a15dbf1219b0cd419f45eec2bc963ffd3 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Thu, 10 Feb 2022 00:36:38 +0100
Subject: [PATCH 09/19] test: chain list (love) cli command
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Some "funky" string matching in this one, but I think that's ok.

Chain is love. ❤️
---
 cli/chain.go      | 15 +++++++-------
 cli/chain_test.go | 53 ++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 56 insertions(+), 12 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index 03dc309e0..cc024dbd3 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -559,6 +559,7 @@ var ChainListCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -606,7 +607,7 @@ var ChainListCmd = &cli.Command{
 			tss = otss
 			for i, ts := range tss {
 				pbf := ts.Blocks()[0].ParentBaseFee
-				fmt.Printf("%d: %d blocks (baseFee: %s -> maxFee: %s)\n", ts.Height(), len(ts.Blocks()), ts.Blocks()[0].ParentBaseFee, types.FIL(types.BigMul(pbf, types.NewInt(uint64(build.BlockGasLimit)))))
+				afmt.Printf("%d: %d blocks (baseFee: %s -> maxFee: %s)\n", ts.Height(), len(ts.Blocks()), ts.Blocks()[0].ParentBaseFee, types.FIL(types.BigMul(pbf, types.NewInt(uint64(build.BlockGasLimit)))))
 
 				for _, b := range ts.Blocks() {
 					msgs, err := api.ChainGetBlockMessages(ctx, b.Cid())
@@ -632,7 +633,7 @@ var ChainListCmd = &cli.Command{
 						avgpremium = big.Div(psum, big.NewInt(int64(lenmsgs)))
 					}
 
-					fmt.Printf("\t%s: \t%d msgs, gasLimit: %d / %d (%0.2f%%), avgPremium: %s\n", b.Miner, len(msgs.BlsMessages)+len(msgs.SecpkMessages), limitSum, build.BlockGasLimit, 100*float64(limitSum)/float64(build.BlockGasLimit), avgpremium)
+					afmt.Printf("\t%s: \t%d msgs, gasLimit: %d / %d (%0.2f%%), avgPremium: %s\n", b.Miner, len(msgs.BlsMessages)+len(msgs.SecpkMessages), limitSum, build.BlockGasLimit, 100*float64(limitSum)/float64(build.BlockGasLimit), avgpremium)
 				}
 				if i < len(tss)-1 {
 					msgs, err := api.ChainGetParentMessages(ctx, tss[i+1].Blocks()[0].Cid())
@@ -657,13 +658,13 @@ var ChainListCmd = &cli.Command{
 					gasEfficiency := 100 * float64(gasUsed) / float64(limitSum)
 					gasCapacity := 100 * float64(limitSum) / float64(build.BlockGasLimit)
 
-					fmt.Printf("\ttipset: \t%d msgs, %d (%0.2f%%) / %d (%0.2f%%)\n", len(msgs), gasUsed, gasEfficiency, limitSum, gasCapacity)
+					afmt.Printf("\ttipset: \t%d msgs, %d (%0.2f%%) / %d (%0.2f%%)\n", len(msgs), gasUsed, gasEfficiency, limitSum, gasCapacity)
 				}
-				fmt.Println()
+				afmt.Println()
 			}
 		} else {
 			for i := len(tss) - 1; i >= 0; i-- {
-				printTipSet(cctx.String("format"), tss[i])
+				printTipSet(cctx.String("format"), tss[i], afmt)
 			}
 		}
 		return nil
@@ -889,7 +890,7 @@ func handleHamtAddress(ctx context.Context, api v0api.FullNode, r cid.Cid) error
 	})
 }
 
-func printTipSet(format string, ts *types.TipSet) {
+func printTipSet(format string, ts *types.TipSet, afmt *AppFmt) {
 	format = strings.ReplaceAll(format, "<height>", fmt.Sprint(ts.Height()))
 	format = strings.ReplaceAll(format, "<time>", time.Unix(int64(ts.MinTimestamp()), 0).Format(time.Stamp))
 	blks := "[ "
@@ -908,7 +909,7 @@ func printTipSet(format string, ts *types.TipSet) {
 	format = strings.ReplaceAll(format, "<blocks>", blks)
 	format = strings.ReplaceAll(format, "<weight>", fmt.Sprint(ts.Blocks()[0].ParentWeight))
 
-	fmt.Println(format)
+	afmt.Println(format)
 }
 
 var ChainBisectCmd = &cli.Command{
diff --git a/cli/chain_test.go b/cli/chain_test.go
index 105d9d550..dd704def0 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -308,14 +308,57 @@ func TestInspectUsage(t *testing.T) {
 
 		out := buf.String()
 
-		fmt.Println("🔥: ", out)
-
 		// output is plaintext, had to do string matching
-		assert.Contains(t, out, "By Sender")
 		assert.Contains(t, out, from.String())
-		assert.Contains(t, out, "By Receiver")
 		assert.Contains(t, out, to.String())
-		assert.Contains(t, out, "By Method")
 		assert.Contains(t, out, "Send")
 	})
 }
+
+func TestChainList(t *testing.T) {
+	cmd := WithCategory("chain", ChainListCmd)
+	genesis := mock.TipSet(mock.MkBlock(nil, 0, 0))
+	blk := mock.MkBlock(genesis, 0, 0)
+	blk.Height = 1
+	head := mock.TipSet(blk)
+
+	head.Height()
+
+	from, err := mock.RandomActorAddress()
+	assert.NoError(t, err)
+
+	to, err := mock.RandomActorAddress()
+	assert.NoError(t, err)
+
+	msg := mock.UnsignedMessage(*from, *to, 0)
+	msgs := []api.Message{{Cid: msg.Cid(), Message: msg}}
+	blockMsgs := &api.BlockMessages{}
+	receipts := []*types.MessageReceipt{}
+
+	t.Run("default", func(t *testing.T) {
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		// same method gets called mocked multiple times bcs it's called in a for loop for all tipsets (2 in this case)
+		gomock.InOrder(
+			mockApi.EXPECT().ChainHead(ctx).Return(head, nil),
+			mockApi.EXPECT().ChainGetTipSet(ctx, head.Parents()).Return(genesis, nil),
+			mockApi.EXPECT().ChainGetBlockMessages(ctx, genesis.Blocks()[0].Cid()).Return(blockMsgs, nil),
+			mockApi.EXPECT().ChainGetParentMessages(ctx, head.Blocks()[0].Cid()).Return(msgs, nil),
+			mockApi.EXPECT().ChainGetParentReceipts(ctx, head.Blocks()[0].Cid()).Return(receipts, nil),
+			mockApi.EXPECT().ChainGetBlockMessages(ctx, head.Blocks()[0].Cid()).Return(blockMsgs, nil),
+		)
+
+		err := app.Run([]string{"chain", "love", "--gas-stats=true"}) // chain is love ❤️
+		assert.NoError(t, err)
+
+		out := buf.String()
+
+		// should print out 2 blocks, indexed with 0: and 1:
+		assert.Contains(t, out, "0:")
+		assert.Contains(t, out, "1:")
+	})
+}

From 6bc2ee27358a03e555852a49636d6065886462f6 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Thu, 10 Feb 2022 14:49:38 +0100
Subject: [PATCH 10/19] test: chain get cli command

Cover the essential function execution paths, no time for every -as-type
combination.
---
 cli/chain.go      | 10 +++---
 cli/chain_test.go | 86 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+), 4 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index cc024dbd3..6e774e0e7 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -719,6 +719,8 @@ var ChainGetCmd = &cli.Command{
    - account-state
 `,
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -737,7 +739,7 @@ var ChainGetCmd = &cli.Command{
 
 			p = "/ipfs/" + ts.ParentState().String() + p
 			if cctx.Bool("verbose") {
-				fmt.Println(p)
+				afmt.Println(p)
 			}
 		}
 
@@ -752,7 +754,7 @@ var ChainGetCmd = &cli.Command{
 			if err != nil {
 				return err
 			}
-			fmt.Println(string(b))
+			afmt.Println(string(b))
 			return nil
 		}
 
@@ -794,7 +796,7 @@ var ChainGetCmd = &cli.Command{
 		}
 
 		if cbu == nil {
-			fmt.Printf("%x", raw)
+			afmt.Printf("%x", raw)
 			return nil
 		}
 
@@ -806,7 +808,7 @@ var ChainGetCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		fmt.Println(string(b))
+		afmt.Println(string(b))
 		return nil
 	},
 }
diff --git a/cli/chain_test.go b/cli/chain_test.go
index dd704def0..be75ebd05 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -362,3 +362,89 @@ func TestChainList(t *testing.T) {
 		assert.Contains(t, out, "1:")
 	})
 }
+
+func TestChainGet(t *testing.T) {
+	blk := mock.MkBlock(nil, 0, 0)
+	ts := mock.TipSet(blk)
+	cmd := WithCategory("chain", ChainGetCmd)
+
+	// lotus chain get /ipfs/[cid]/some/path
+
+	// given no -as-type flag & ipfs prefix, should print object as JSON if it's marshalable
+	t.Run("ipfs", func(t *testing.T) {
+		path := fmt.Sprintf("/ipfs/%s", blk.Cid().String())
+
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainGetNode(ctx, path).Return(&api.IpldObject{Cid: blk.Cid(), Obj: blk}, nil),
+		)
+
+		err := app.Run([]string{"chain", "get", path})
+		assert.NoError(t, err)
+
+		var out types.BlockHeader
+		err = json.Unmarshal(buf.Bytes(), &out)
+		assert.NoError(t, err)
+		assert.Equal(t, *blk, out)
+	})
+
+	// given no -as-type flag & ipfs prefix, should traverse from head.ParentStateRoot and print JSON if it's marshalable
+	t.Run("pstate", func(t *testing.T) {
+		p1 := "/pstate"
+		p2 := fmt.Sprintf("/ipfs/%s", ts.ParentState().String())
+
+		app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainHead(ctx).Return(ts, nil),
+			mockApi.EXPECT().ChainGetNode(ctx, p2).Return(&api.IpldObject{Cid: blk.Cid(), Obj: blk}, nil),
+		)
+
+		err := app.Run([]string{"chain", "get", p1})
+		assert.NoError(t, err)
+
+		var out types.BlockHeader
+		err = json.Unmarshal(buf.Bytes(), &out)
+		assert.NoError(t, err)
+		assert.Equal(t, *blk, out)
+	})
+
+	// given an unknown -as-type value, return an error
+	t.Run("unknown-type", func(t *testing.T) {
+		app, mockApi, _, done := NewMockAppWithFullAPI(t, cmd)
+		defer done()
+
+		path := fmt.Sprintf("/ipfs/%s", blk.Cid().String())
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		gomock.InOrder(
+			mockApi.EXPECT().ChainGetNode(ctx, path).Return(&api.IpldObject{Cid: blk.Cid(), Obj: blk}, nil),
+		)
+
+		err := app.Run([]string{"chain", "get", "-as-type=foo", path})
+		assert.Error(t, err)
+	})
+}
+
+func TestChainBisect(t *testing.T) {}
+
+func TestChainExport(t *testing.T) {}
+
+func TestSlashConsensusFault(t *testing.T) {}
+
+func TestChainGasPrice(t *testing.T) {}
+
+func TestChainDecode(t *testing.T) {}
+
+func TestChainEncode(t *testing.T) {}

From b536dfa552493d2b11f4ea3f832d1a0f3dc9fcc5 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Thu, 10 Feb 2022 15:46:06 +0100
Subject: [PATCH 11/19] test: chain bisect cli command

---
 cli/chain.go      | 22 ++++++++++++----------
 cli/chain_test.go | 39 ++++++++++++++++++++++++++++++++++++---
 2 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index 6e774e0e7..1e41a759c 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -932,6 +932,8 @@ var ChainBisectCmd = &cli.Command{
    For special path elements see 'chain get' help
 `,
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -975,7 +977,7 @@ var ChainBisectCmd = &cli.Command{
 			}
 
 			path := "/ipld/" + midTs.ParentState().String() + "/" + subPath
-			fmt.Printf("* Testing %d (%d - %d) (%s): ", mid, start, end, path)
+			afmt.Printf("* Testing %d (%d - %d) (%s): ", mid, start, end, path)
 
 			nd, err := api.ChainGetNode(ctx, path)
 			if err != nil {
@@ -1002,32 +1004,32 @@ var ChainBisectCmd = &cli.Command{
 				if strings.TrimSpace(out.String()) != "false" {
 					end = mid
 					highest = midTs
-					fmt.Println("true")
+					afmt.Println("true")
 				} else {
 					start = mid
-					fmt.Printf("false (cli)\n")
+					afmt.Printf("false (cli)\n")
 				}
 			case *exec.ExitError:
 				if len(serr.String()) > 0 {
-					fmt.Println("error")
+					afmt.Println("error")
 
-					fmt.Printf("> Command: %s\n---->\n", strings.Join(cctx.Args().Slice()[3:], " "))
-					fmt.Println(string(b))
-					fmt.Println("<----")
+					afmt.Printf("> Command: %s\n---->\n", strings.Join(cctx.Args().Slice()[3:], " "))
+					afmt.Println(string(b))
+					afmt.Println("<----")
 					return xerrors.Errorf("error running bisect check: %s", serr.String())
 				}
 
 				start = mid
-				fmt.Println("false")
+				afmt.Println("false")
 			default:
 				return err
 			}
 
 			if start == end {
 				if strings.TrimSpace(out.String()) == "true" {
-					fmt.Println(midTs.Height())
+					afmt.Println(midTs.Height())
 				} else {
-					fmt.Println(prev)
+					afmt.Println(prev)
 				}
 				return nil
 			}
diff --git a/cli/chain_test.go b/cli/chain_test.go
index be75ebd05..70a4a4953 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -368,8 +368,6 @@ func TestChainGet(t *testing.T) {
 	ts := mock.TipSet(blk)
 	cmd := WithCategory("chain", ChainGetCmd)
 
-	// lotus chain get /ipfs/[cid]/some/path
-
 	// given no -as-type flag & ipfs prefix, should print object as JSON if it's marshalable
 	t.Run("ipfs", func(t *testing.T) {
 		path := fmt.Sprintf("/ipfs/%s", blk.Cid().String())
@@ -437,7 +435,42 @@ func TestChainGet(t *testing.T) {
 	})
 }
 
-func TestChainBisect(t *testing.T) {}
+func TestChainBisect(t *testing.T) {
+	blk1 := mock.MkBlock(nil, 0, 0)
+	blk1.Height = 0
+	ts1 := mock.TipSet(blk1)
+
+	blk2 := mock.MkBlock(ts1, 0, 0)
+	blk2.Height = 1
+	ts2 := mock.TipSet(blk2)
+
+	subpath := "whatever/its/mocked"
+	minHeight := uint64(0)
+	maxHeight := uint64(1)
+	shell := "echo"
+
+	path := fmt.Sprintf("/ipld/%s/%s", ts2.ParentState(), subpath)
+
+	cmd := WithCategory("chain", ChainBisectCmd)
+
+	app, mockApi, buf, done := NewMockAppWithFullAPI(t, cmd)
+	defer done()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	gomock.InOrder(
+		mockApi.EXPECT().ChainGetTipSetByHeight(ctx, abi.ChainEpoch(maxHeight), types.EmptyTSK).Return(ts2, nil),
+		mockApi.EXPECT().ChainGetTipSetByHeight(ctx, abi.ChainEpoch(maxHeight), ts2.Key()).Return(ts2, nil),
+		mockApi.EXPECT().ChainGetNode(ctx, path).Return(&api.IpldObject{Cid: blk2.Cid(), Obj: blk2}, nil),
+	)
+
+	err := app.Run([]string{"chain", "bisect", fmt.Sprintf("%d", minHeight), fmt.Sprintf("%d", maxHeight), subpath, shell})
+	assert.NoError(t, err)
+
+	out := buf.String()
+	assert.Contains(t, out, path)
+}
 
 func TestChainExport(t *testing.T) {}
 

From c0f89e5b2d2080d5c311581c8b4f238ca4954a96 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Thu, 10 Feb 2022 18:18:31 +0100
Subject: [PATCH 12/19] test: chain export cli command

Modified ChainExportCmd to use io.WriterCloser instead of os.File so
it the file can be mocked in unit tests, without side effects to the FS.
---
 cli/chain.go      | 16 +++++++++++++++-
 cli/chain_test.go | 38 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 52 insertions(+), 2 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index 1e41a759c..fe073776a 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -7,6 +7,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"os/exec"
 	"path"
@@ -1074,7 +1075,7 @@ var ChainExportCmd = &cli.Command{
 			return fmt.Errorf("\"recent-stateroots\" has to be greater than %d", build.Finality)
 		}
 
-		fi, err := os.Create(cctx.Args().First())
+		fi, err := createExportFile(cctx.App, cctx.Args().First())
 		if err != nil {
 			return err
 		}
@@ -1436,3 +1437,16 @@ var chainEncodeParamsCmd = &cli.Command{
 		return nil
 	},
 }
+
+// createExportFile returns the export file from the app metadata, or creates a new file if it doesn't exist
+func createExportFile(app *cli.App, path string) (io.WriteCloser, error) {
+	if wc, ok := app.Metadata["export-file"]; ok {
+		return wc.(io.WriteCloser), nil
+	}
+
+	fi, err := os.Create(path)
+	if err != nil {
+		return nil, err
+	}
+	return fi, nil
+}
diff --git a/cli/chain_test.go b/cli/chain_test.go
index 70a4a4953..4a553f88a 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -472,7 +472,35 @@ func TestChainBisect(t *testing.T) {
 	assert.Contains(t, out, path)
 }
 
-func TestChainExport(t *testing.T) {}
+func TestChainExport(t *testing.T) {
+	app, mockApi, _, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainExportCmd))
+	defer done()
+
+	mockFile := mockExportFile{new(bytes.Buffer)}
+	app.Metadata["export-file"] = mockFile
+
+	blk := mock.MkBlock(nil, 0, 0)
+	ts := mock.TipSet(blk)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	export := make(chan []byte, 2)
+	expBytes := []byte("whatever")
+	export <- expBytes
+	export <- []byte{} // empty slice means export is complete
+	close(export)
+
+	gomock.InOrder(
+		mockApi.EXPECT().ChainHead(ctx).Return(ts, nil),
+		mockApi.EXPECT().ChainExport(ctx, abi.ChainEpoch(0), false, ts.Key()).Return(export, nil),
+	)
+
+	err := app.Run([]string{"chain", "export", "whatever.car"})
+	assert.NoError(t, err)
+
+	assert.Equal(t, expBytes, mockFile.Bytes())
+}
 
 func TestSlashConsensusFault(t *testing.T) {}
 
@@ -481,3 +509,11 @@ func TestChainGasPrice(t *testing.T) {}
 func TestChainDecode(t *testing.T) {}
 
 func TestChainEncode(t *testing.T) {}
+
+type mockExportFile struct {
+	*bytes.Buffer
+}
+
+func (mef mockExportFile) Close() error {
+	return nil
+}

From e5ac8662c88597fef3485663c29a72b2a35b3bcb Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Thu, 10 Feb 2022 21:55:09 +0100
Subject: [PATCH 13/19] test: chain gas-price cli command

Contains some funny mocking logic, because estimate gas price is called
multiple times (for various nblocks) and I wanted to make it as flexible
as possible.
---
 cli/chain.go      | 20 ++++++++++++++------
 cli/chain_test.go | 26 ++++++++++++++++++++++++--
 2 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/cli/chain.go b/cli/chain.go
index fe073776a..63aa79483 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -1135,6 +1135,8 @@ var SlashConsensusFault = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		srv, err := GetFullNodeServices(cctx)
 		if err != nil {
 			return err
@@ -1239,7 +1241,7 @@ var SlashConsensusFault = &cli.Command{
 			return err
 		}
 
-		fmt.Println(smsg.Cid())
+		afmt.Println(smsg.Cid())
 
 		return nil
 	},
@@ -1249,6 +1251,8 @@ var ChainGasPriceCmd = &cli.Command{
 	Name:  "gas-price",
 	Usage: "Estimate gas prices",
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -1265,7 +1269,7 @@ var ChainGasPriceCmd = &cli.Command{
 				return err
 			}
 
-			fmt.Printf("%d blocks: %s (%s)\n", nblocks, est, types.FIL(est))
+			afmt.Printf("%d blocks: %s (%s)\n", nblocks, est, types.FIL(est))
 		}
 
 		return nil
@@ -1295,6 +1299,8 @@ var chainDecodeParamsCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -1346,7 +1352,7 @@ var chainDecodeParamsCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Println(pstr)
+		afmt.Println(pstr)
 
 		return nil
 	},
@@ -1379,6 +1385,8 @@ var chainEncodeParamsCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		afmt := NewAppFmt(cctx.App)
+
 		if cctx.Args().Len() != 3 {
 			return ShowHelp(cctx, fmt.Errorf("incorrect number of arguments"))
 		}
@@ -1427,9 +1435,9 @@ var chainEncodeParamsCmd = &cli.Command{
 
 		switch cctx.String("encoding") {
 		case "base64", "b64":
-			fmt.Println(base64.StdEncoding.EncodeToString(p))
+			afmt.Println(base64.StdEncoding.EncodeToString(p))
 		case "hex":
-			fmt.Println(hex.EncodeToString(p))
+			afmt.Println(hex.EncodeToString(p))
 		default:
 			return xerrors.Errorf("unknown encoding")
 		}
@@ -1438,7 +1446,7 @@ var chainEncodeParamsCmd = &cli.Command{
 	},
 }
 
-// createExportFile returns the export file from the app metadata, or creates a new file if it doesn't exist
+// createExportFile returns the export file handle from the app metadata, or creates a new file if it doesn't exist
 func createExportFile(app *cli.App, path string) (io.WriteCloser, error) {
 	if wc, ok := app.Metadata["export-file"]; ok {
 		return wc.(io.WriteCloser), nil
diff --git a/cli/chain_test.go b/cli/chain_test.go
index 4a553f88a..a8949ed52 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -476,6 +476,7 @@ func TestChainExport(t *testing.T) {
 	app, mockApi, _, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainExportCmd))
 	defer done()
 
+	// export writes to a file, I mocked it so there are no side-effects
 	mockFile := mockExportFile{new(bytes.Buffer)}
 	app.Metadata["export-file"] = mockFile
 
@@ -502,9 +503,30 @@ func TestChainExport(t *testing.T) {
 	assert.Equal(t, expBytes, mockFile.Bytes())
 }
 
-func TestSlashConsensusFault(t *testing.T) {}
+func TestChainGasPrice(t *testing.T) {
+	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainGasPriceCmd))
+	defer done()
 
-func TestChainGasPrice(t *testing.T) {}
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// estimate gas is called with various num blocks in implementation,
+	// so we mock and count how many times it's called, and we expect that many results printed
+	calls := 0
+	mockApi.
+		EXPECT().
+		GasEstimateGasPremium(ctx, gomock.Any(), builtin.SystemActorAddr, int64(10000), types.EmptyTSK).
+		Return(big.NewInt(0), nil).AnyTimes().
+		Do(func(a, b, c, d, e interface{}) { // looks funny, but we don't care about args here, just counting
+			calls += 1
+		})
+
+	err := app.Run([]string{"chain", "gas-price"})
+	assert.NoError(t, err)
+
+	lines := strings.Split(strings.Trim(buf.String(), "\n"), "\n")
+	assert.Equal(t, calls, len(lines))
+}
 
 func TestChainDecode(t *testing.T) {}
 

From 107eb76b20fae7575cff07e5d0814d3c07a1443c Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Fri, 11 Feb 2022 00:09:07 +0100
Subject: [PATCH 14/19] cleanup: small cleanup before final push

---
 cli/chain_test.go | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/cli/chain_test.go b/cli/chain_test.go
index a8949ed52..f3da80197 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -516,9 +516,10 @@ func TestChainGasPrice(t *testing.T) {
 	mockApi.
 		EXPECT().
 		GasEstimateGasPremium(ctx, gomock.Any(), builtin.SystemActorAddr, int64(10000), types.EmptyTSK).
-		Return(big.NewInt(0), nil).AnyTimes().
+		Return(big.NewInt(0), nil).
+		AnyTimes().
 		Do(func(a, b, c, d, e interface{}) { // looks funny, but we don't care about args here, just counting
-			calls += 1
+			calls++
 		})
 
 	err := app.Run([]string{"chain", "gas-price"})
@@ -528,10 +529,6 @@ func TestChainGasPrice(t *testing.T) {
 	assert.Equal(t, calls, len(lines))
 }
 
-func TestChainDecode(t *testing.T) {}
-
-func TestChainEncode(t *testing.T) {}
-
 type mockExportFile struct {
 	*bytes.Buffer
 }

From e6c8c9a6ab8a8ad148a9edec3995bc1b405652b3 Mon Sep 17 00:00:00 2001
From: Nikola Divic <divicnikola@gmail.com>
Date: Sun, 13 Feb 2022 17:14:27 +0100
Subject: [PATCH 15/19] doc: add stm annotation to cli chain tests

---
 cli/chain_test.go | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/cli/chain_test.go b/cli/chain_test.go
index f3da80197..841cfb689 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -32,6 +32,7 @@ func TestChainHead(t *testing.T) {
 		mockApi.EXPECT().ChainHead(ctx).Return(ts, nil),
 	)
 
+	//stm: @CLI_CHAIN_HEAD_001
 	err := app.Run([]string{"chain", "head"})
 	assert.NoError(t, err)
 
@@ -55,6 +56,7 @@ func TestGetBlock(t *testing.T) {
 		mockApi.EXPECT().ChainGetParentReceipts(ctx, block.Cid()).Return([]*types.MessageReceipt{}, nil),
 	)
 
+	//stm: @CLI_CHAIN_GET_BLOCK_001
 	err := app.Run([]string{"chain", "getblock", block.Cid().String()})
 	assert.NoError(t, err)
 
@@ -89,6 +91,7 @@ func TestReadOjb(t *testing.T) {
 		mockApi.EXPECT().ChainReadObj(ctx, block.Cid()).Return(obj.Bytes(), nil),
 	)
 
+	//stm: @CLI_CHAIN_READ_OBJECT_001
 	err = app.Run([]string{"chain", "read-obj", block.Cid().String()})
 	assert.NoError(t, err)
 
@@ -104,6 +107,7 @@ func TestChainDeleteObj(t *testing.T) {
 		app, _, _, done := NewMockAppWithFullAPI(t, cmd)
 		defer done()
 
+		//stm: @CLI_CHAIN_DELETE_OBJECT_002
 		err := app.Run([]string{"chain", "delete-obj", block.Cid().String()})
 		assert.Error(t, err)
 	})
@@ -120,6 +124,7 @@ func TestChainDeleteObj(t *testing.T) {
 			mockApi.EXPECT().ChainDeleteObj(ctx, block.Cid()).Return(nil),
 		)
 
+		//stm: @CLI_CHAIN_DELETE_OBJECT_001
 		err := app.Run([]string{"chain", "delete-obj", "--really-do-it=true", block.Cid().String()})
 		assert.NoError(t, err)
 
@@ -152,6 +157,7 @@ func TestChainStatObj(t *testing.T) {
 			mockApi.EXPECT().ChainStatObj(ctx, block.Cid(), cid.Undef).Return(stat, nil),
 		)
 
+		//stm: @CLI_CHAIN_STAT_OBJECT_001
 		err := app.Run([]string{"chain", "stat-obj", block.Cid().String()})
 		assert.NoError(t, err)
 
@@ -170,6 +176,7 @@ func TestChainStatObj(t *testing.T) {
 			mockApi.EXPECT().ChainStatObj(ctx, block.Cid(), block.Cid()).Return(stat, nil),
 		)
 
+		//stm: @CLI_CHAIN_STAT_OBJECT_002
 		err := app.Run([]string{"chain", "stat-obj", fmt.Sprintf("-base=%s", block.Cid().String()), block.Cid().String()})
 		assert.NoError(t, err)
 
@@ -200,6 +207,7 @@ func TestChainGetMsg(t *testing.T) {
 		mockApi.EXPECT().ChainReadObj(ctx, msg.Cid()).Return(obj.Bytes(), nil),
 	)
 
+	//stm: @CLI_CHAIN_GET_MESSAGE_001
 	err = app.Run([]string{"chain", "getmessage", msg.Cid().String()})
 	assert.NoError(t, err)
 
@@ -229,6 +237,7 @@ func TestSetHead(t *testing.T) {
 			mockApi.EXPECT().ChainSetHead(ctx, genesis.Key()).Return(nil),
 		)
 
+		//stm: @CLI_CHAIN_SET_HEAD_003
 		err := app.Run([]string{"chain", "sethead", "-genesis=true", ts.Key().String()})
 		assert.NoError(t, err)
 	})
@@ -246,6 +255,7 @@ func TestSetHead(t *testing.T) {
 			mockApi.EXPECT().ChainSetHead(ctx, genesis.Key()).Return(nil),
 		)
 
+		//stm: @CLI_CHAIN_SET_HEAD_002
 		err := app.Run([]string{"chain", "sethead", fmt.Sprintf("-epoch=%s", epoch), ts.Key().String()})
 		assert.NoError(t, err)
 	})
@@ -263,8 +273,7 @@ func TestSetHead(t *testing.T) {
 			mockApi.EXPECT().ChainSetHead(ctx, ts.Key()).Return(nil),
 		)
 
-		// ts.Key should be passed as an array of arguments (CIDs)
-		// since we have only one CID in the key, this is ok
+		//stm: @CLI_CHAIN_SET_HEAD_001
 		err := app.Run([]string{"chain", "sethead", ts.Key().Cids()[0].String()})
 		assert.NoError(t, err)
 	})
@@ -303,6 +312,7 @@ func TestInspectUsage(t *testing.T) {
 			mockApi.EXPECT().StateGetActor(ctx, *to, ts.Key()).Return(actor, nil),
 		)
 
+		//stm: @CLI_CHAIN_INSPECT_USAGE_001
 		err := app.Run([]string{"chain", "inspect-usage"})
 		assert.NoError(t, err)
 
@@ -352,6 +362,7 @@ func TestChainList(t *testing.T) {
 			mockApi.EXPECT().ChainGetBlockMessages(ctx, head.Blocks()[0].Cid()).Return(blockMsgs, nil),
 		)
 
+		//stm: CLI_CHAIN_LIST_001
 		err := app.Run([]string{"chain", "love", "--gas-stats=true"}) // chain is love ❤️
 		assert.NoError(t, err)
 
@@ -382,6 +393,7 @@ func TestChainGet(t *testing.T) {
 			mockApi.EXPECT().ChainGetNode(ctx, path).Return(&api.IpldObject{Cid: blk.Cid(), Obj: blk}, nil),
 		)
 
+		//stm: @CLI_CHAIN_GET_001
 		err := app.Run([]string{"chain", "get", path})
 		assert.NoError(t, err)
 
@@ -407,6 +419,7 @@ func TestChainGet(t *testing.T) {
 			mockApi.EXPECT().ChainGetNode(ctx, p2).Return(&api.IpldObject{Cid: blk.Cid(), Obj: blk}, nil),
 		)
 
+		//stm: @CLI_CHAIN_GET_002
 		err := app.Run([]string{"chain", "get", p1})
 		assert.NoError(t, err)
 
@@ -430,6 +443,7 @@ func TestChainGet(t *testing.T) {
 			mockApi.EXPECT().ChainGetNode(ctx, path).Return(&api.IpldObject{Cid: blk.Cid(), Obj: blk}, nil),
 		)
 
+		//stm: @CLI_CHAIN_GET_004
 		err := app.Run([]string{"chain", "get", "-as-type=foo", path})
 		assert.Error(t, err)
 	})
@@ -465,6 +479,7 @@ func TestChainBisect(t *testing.T) {
 		mockApi.EXPECT().ChainGetNode(ctx, path).Return(&api.IpldObject{Cid: blk2.Cid(), Obj: blk2}, nil),
 	)
 
+	//stm: @CLI_CHAIN_BISECT_001
 	err := app.Run([]string{"chain", "bisect", fmt.Sprintf("%d", minHeight), fmt.Sprintf("%d", maxHeight), subpath, shell})
 	assert.NoError(t, err)
 
@@ -497,6 +512,7 @@ func TestChainExport(t *testing.T) {
 		mockApi.EXPECT().ChainExport(ctx, abi.ChainEpoch(0), false, ts.Key()).Return(export, nil),
 	)
 
+	//stm: @CLI_CHAIN_EXPORT_001
 	err := app.Run([]string{"chain", "export", "whatever.car"})
 	assert.NoError(t, err)
 
@@ -522,6 +538,7 @@ func TestChainGasPrice(t *testing.T) {
 			calls++
 		})
 
+	//stm: @CLI_CHAIN_GAS_PRICE_001
 	err := app.Run([]string{"chain", "gas-price"})
 	assert.NoError(t, err)
 

From 6feae1993d3ddd7e4babc2b68e30962f5ca48e7d Mon Sep 17 00:00:00 2001
From: Darko Brdareski <darko.brdareski@bloxico.com>
Date: Thu, 17 Feb 2022 14:24:42 +0100
Subject: [PATCH 16/19] Fix PR comments.

Refactor random addr generation to use a rand seed.
Remove unused lines in tests.
---
 chain/types/mock/chain.go | 29 +++++++++++++++++------------
 cli/chain_test.go         | 23 ++++++++++++-----------
 2 files changed, 29 insertions(+), 23 deletions(-)

diff --git a/chain/types/mock/chain.go b/chain/types/mock/chain.go
index c69f7f56f..9a911c987 100644
--- a/chain/types/mock/chain.go
+++ b/chain/types/mock/chain.go
@@ -2,8 +2,8 @@ package mock
 
 import (
 	"context"
-	"crypto/rand"
 	"fmt"
+	"math/rand"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
@@ -90,19 +90,24 @@ func TipSet(blks ...*types.BlockHeader) *types.TipSet {
 	return ts
 }
 
-func RandomActorAddress() (*address.Address, error) {
-	bytes := make([]byte, 32)
-	_, err := rand.Read(bytes)
-	if err != nil {
-		return nil, err
-	}
+// Generates count new addresses using the provided seed, and returns them
+func RandomActorAddresses(seed int64, count int) ([]*address.Address, error) {
+	randAddrs := make([]*address.Address, count)
+	source := rand.New(rand.NewSource(seed))
+	for i := 0; i < count; i++ {
+		bytes := make([]byte, 32)
+		_, err := source.Read(bytes)
+		if err != nil {
+			return nil, err
+		}
 
-	addr, err := address.NewActorAddress(bytes)
-	if err != nil {
-		return nil, err
+		addr, err := address.NewActorAddress(bytes)
+		if err != nil {
+			return nil, err
+		}
+		randAddrs[i] = &addr
 	}
-
-	return &addr, nil
+	return randAddrs, nil
 }
 
 func UnsignedMessage(from, to address.Address, nonce uint64) *types.Message {
diff --git a/cli/chain_test.go b/cli/chain_test.go
index 841cfb689..48c4af05d 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -188,11 +188,11 @@ func TestChainGetMsg(t *testing.T) {
 	app, mockApi, buf, done := NewMockAppWithFullAPI(t, WithCategory("chain", ChainGetMsgCmd))
 	defer done()
 
-	from, err := mock.RandomActorAddress()
+	addrs, err := mock.RandomActorAddresses(12345, 2)
 	assert.NoError(t, err)
 
-	to, err := mock.RandomActorAddress()
-	assert.NoError(t, err)
+	from := addrs[0]
+	to := addrs[1]
 
 	msg := mock.UnsignedMessage(*from, *to, 0)
 
@@ -283,11 +283,11 @@ func TestInspectUsage(t *testing.T) {
 	cmd := WithCategory("chain", ChainInspectUsage)
 	ts := mock.TipSet(mock.MkBlock(nil, 0, 0))
 
-	from, err := mock.RandomActorAddress()
+	addrs, err := mock.RandomActorAddresses(12345, 2)
 	assert.NoError(t, err)
 
-	to, err := mock.RandomActorAddress()
-	assert.NoError(t, err)
+	from := addrs[0]
+	to := addrs[1]
 
 	msg := mock.UnsignedMessage(*from, *to, 0)
 	msgs := []api.Message{{Cid: msg.Cid(), Message: msg}}
@@ -321,6 +321,9 @@ func TestInspectUsage(t *testing.T) {
 		// output is plaintext, had to do string matching
 		assert.Contains(t, out, from.String())
 		assert.Contains(t, out, to.String())
+		// check for gas by sender
+		assert.Contains(t, out, "By Sender")
+		// check for gas by method
 		assert.Contains(t, out, "Send")
 	})
 }
@@ -332,13 +335,11 @@ func TestChainList(t *testing.T) {
 	blk.Height = 1
 	head := mock.TipSet(blk)
 
-	head.Height()
-
-	from, err := mock.RandomActorAddress()
+	addrs, err := mock.RandomActorAddresses(12345, 2)
 	assert.NoError(t, err)
 
-	to, err := mock.RandomActorAddress()
-	assert.NoError(t, err)
+	from := addrs[0]
+	to := addrs[1]
 
 	msg := mock.UnsignedMessage(*from, *to, 0)
 	msgs := []api.Message{{Cid: msg.Cid(), Message: msg}}

From 87c63e2cb739207a31e9ebb53fa9b35c226304da Mon Sep 17 00:00:00 2001
From: Darko Brdareski <darko.brdareski@bloxico.com>
Date: Mon, 21 Feb 2022 12:33:07 +0100
Subject: [PATCH 17/19] Add stm file annotation

---
 cli/chain_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cli/chain_test.go b/cli/chain_test.go
index 48c4af05d..f525a0b35 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -1,3 +1,4 @@
+//stm: #integration
 package cli
 
 import (

From 675012fe1c1bfe380f77da0a43333374d65d71e1 Mon Sep 17 00:00:00 2001
From: Darko Brdareski <darko.brdareski@bloxico.com>
Date: Mon, 21 Feb 2022 16:49:07 +0100
Subject: [PATCH 18/19] Fix matching for TestInspectUsage

---
 cli/chain_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cli/chain_test.go b/cli/chain_test.go
index f525a0b35..efd1db14d 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -325,7 +325,7 @@ func TestInspectUsage(t *testing.T) {
 		// check for gas by sender
 		assert.Contains(t, out, "By Sender")
 		// check for gas by method
-		assert.Contains(t, out, "Send")
+		assert.Contains(t, out, "By Method:\nSend")
 	})
 }
 

From 580fa86ea3f173b6d8b7689f31050b16f7ffa075 Mon Sep 17 00:00:00 2001
From: Darko Brdareski <darko.brdareski@bloxico.com>
Date: Mon, 21 Feb 2022 17:57:01 +0100
Subject: [PATCH 19/19] Change annotation to #cli

---
 cli/chain_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cli/chain_test.go b/cli/chain_test.go
index efd1db14d..0b3cce728 100644
--- a/cli/chain_test.go
+++ b/cli/chain_test.go
@@ -1,4 +1,4 @@
-//stm: #integration
+//stm: #cli
 package cli
 
 import (