cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

refactor: share code between CLI tests

Browse Source
This commit is contained in:
Dirk McCormick 2020-10-26 12:01:33 +01:00
parent d4cdc6d334
commit b097a5fb0c
5 changed files with 188 additions and 249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

295
cli/paych_test.go
View File

@ -1,9 +1,7 @@
package cli package cli
import ( import (
"bytes"
"context" "context"
"flag"
"fmt" "fmt"
"os" "os"
"regexp" "regexp"
@ -12,24 +10,21 @@ import (
"testing" "testing"
"time" "time"
"github.com/stretchr/testify/require" clitest "github.com/filecoin-project/lotus/cli/test"
"github.com/urfave/cli/v2"
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi" "github.com/filecoin-project/go-state-types/abi"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/multiformats/go-multiaddr"
"github.com/filecoin-project/lotus/chain/actors/adt" "github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin/paych" "github.com/filecoin-project/lotus/chain/actors/builtin/paych"
"github.com/filecoin-project/lotus/chain/actors/policy" "github.com/filecoin-project/lotus/chain/actors/policy"
cbor "github.com/ipfs/go-ipld-cbor"
"github.com/stretchr/testify/require"
"github.com/filecoin-project/lotus/api/apibstore" "github.com/filecoin-project/lotus/api/apibstore"
"github.com/filecoin-project/lotus/api/test" "github.com/filecoin-project/lotus/api/test"
"github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/events" "github.com/filecoin-project/lotus/chain/events"
"github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types"
builder "github.com/filecoin-project/lotus/node/test"
) )
func init() { func init() {
@ -45,21 +40,21 @@ func TestPaymentChannels(t *testing.T) {
blocktime := 5 * time.Millisecond blocktime := 5 * time.Millisecond
ctx := context.Background() ctx := context.Background()
nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime) nodes, addrs := clitest.StartTwoNodesOneMiner(ctx, t, blocktime)
paymentCreator := nodes[0] paymentCreator := nodes[0]
paymentReceiver := nodes[1] paymentReceiver := nodes[1]
creatorAddr := addrs[0] creatorAddr := addrs[0]
receiverAddr := addrs[1] receiverAddr := addrs[1]
// Create mock CLI // Create mock CLI
mockCLI := newMockCLI(t) mockCLI := clitest.NewMockCLI(t, Commands)
creatorCLI := mockCLI.client(paymentCreator.ListenAddr) creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
receiverCLI := mockCLI.client(paymentReceiver.ListenAddr) receiverCLI := mockCLI.Client(paymentReceiver.ListenAddr)
// creator: paych add-funds <creator> <receiver> <amount> // creator: paych add-funds <creator> <receiver> <amount>
channelAmt := "100000" channelAmt := "100000"
cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt} cmd := []string{"paych", "add-funds", creatorAddr.String(), receiverAddr.String(), channelAmt}
chstr := creatorCLI.runCmd(paychAddFundsCmd, cmd) chstr := creatorCLI.RunCmd(cmd)
chAddr, err := address.NewFromString(chstr) chAddr, err := address.NewFromString(chstr)
require.NoError(t, err) require.NoError(t, err)
@ -67,16 +62,16 @@ func TestPaymentChannels(t *testing.T) {
// creator: paych voucher create <channel> <amount> // creator: paych voucher create <channel> <amount>
voucherAmt := 100 voucherAmt := 100
vamt := strconv.Itoa(voucherAmt) vamt := strconv.Itoa(voucherAmt)
cmd = []string{chAddr.String(), vamt} cmd = []string{"paych", "voucher", "create", chAddr.String(), vamt}
voucher := creatorCLI.runCmd(paychVoucherCreateCmd, cmd) voucher := creatorCLI.RunCmd(cmd)
// receiver: paych voucher add <channel> <voucher> // receiver: paych voucher add <channel> <voucher>
cmd = []string{chAddr.String(), voucher} cmd = []string{"paych", "voucher", "add", chAddr.String(), voucher}
receiverCLI.runCmd(paychVoucherAddCmd, cmd) receiverCLI.RunCmd(cmd)
// creator: paych settle <channel> // creator: paych settle <channel>
cmd = []string{chAddr.String()} cmd = []string{"paych", "settle", chAddr.String()}
creatorCLI.runCmd(paychSettleCmd, cmd) creatorCLI.RunCmd(cmd)
// Wait for the chain to reach the settle height // Wait for the chain to reach the settle height
chState := getPaychState(ctx, t, paymentReceiver, chAddr) chState := getPaychState(ctx, t, paymentReceiver, chAddr)
@ -85,8 +80,8 @@ func TestPaymentChannels(t *testing.T) {
waitForHeight(ctx, t, paymentReceiver, sa) waitForHeight(ctx, t, paymentReceiver, sa)
// receiver: paych collect <channel> // receiver: paych collect <channel>
cmd = []string{chAddr.String()} cmd = []string{"paych", "collect", chAddr.String()}
receiverCLI.runCmd(paychCloseCmd, cmd) receiverCLI.RunCmd(cmd)
} }
type voucherSpec struct { type voucherSpec struct {
@ -101,17 +96,18 @@ func TestPaymentChannelStatus(t *testing.T) {
blocktime := 5 * time.Millisecond blocktime := 5 * time.Millisecond
ctx := context.Background() ctx := context.Background()
nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime) nodes, addrs := clitest.StartTwoNodesOneMiner(ctx, t, blocktime)
paymentCreator := nodes[0] paymentCreator := nodes[0]
creatorAddr := addrs[0] creatorAddr := addrs[0]
receiverAddr := addrs[1] receiverAddr := addrs[1]
// Create mock CLI // Create mock CLI
mockCLI := newMockCLI(t) mockCLI := clitest.NewMockCLI(t, Commands)
creatorCLI := mockCLI.client(paymentCreator.ListenAddr) creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
cmd := []string{creatorAddr.String(), receiverAddr.String()} // creator: paych status-by-from-to <creator> <receiver>
out := creatorCLI.runCmd(paychStatusByFromToCmd, cmd) cmd := []string{"paych", "status-by-from-to", creatorAddr.String(), receiverAddr.String()}
out := creatorCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
noChannelState := "Channel does not exist" noChannelState := "Channel does not exist"
require.Regexp(t, regexp.MustCompile(noChannelState), out) require.Regexp(t, regexp.MustCompile(noChannelState), out)
@ -120,14 +116,14 @@ func TestPaymentChannelStatus(t *testing.T) {
create := make(chan string) create := make(chan string)
go func() { go func() {
// creator: paych add-funds <creator> <receiver> <amount> // creator: paych add-funds <creator> <receiver> <amount>
cmd := []string{creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)} cmd := []string{"paych", "add-funds", creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)}
create <- creatorCLI.runCmd(paychAddFundsCmd, cmd) create <- creatorCLI.RunCmd(cmd)
}() }()
// Wait for the output to stop being "Channel does not exist" // Wait for the output to stop being "Channel does not exist"
for regexp.MustCompile(noChannelState).MatchString(out) { for regexp.MustCompile(noChannelState).MatchString(out) {
cmd := []string{creatorAddr.String(), receiverAddr.String()} cmd := []string{"paych", "status-by-from-to", creatorAddr.String(), receiverAddr.String()}
out = creatorCLI.runCmd(paychStatusByFromToCmd, cmd) out = creatorCLI.RunCmd(cmd)
} }
fmt.Println(out) fmt.Println(out)
@ -147,8 +143,8 @@ func TestPaymentChannelStatus(t *testing.T) {
// Wait for create channel to complete // Wait for create channel to complete
chstr := <-create chstr := <-create
cmd = []string{chstr} cmd = []string{"paych", "status", chstr}
out = creatorCLI.runCmd(paychStatusCmd, cmd) out = creatorCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
// Output should have the channel address // Output should have the channel address
require.Regexp(t, regexp.MustCompile("Channel.*"+chstr), out) require.Regexp(t, regexp.MustCompile("Channel.*"+chstr), out)
@ -160,11 +156,11 @@ func TestPaymentChannelStatus(t *testing.T) {
// creator: paych voucher create <channel> <amount> // creator: paych voucher create <channel> <amount>
voucherAmt := uint64(10) voucherAmt := uint64(10)
cmd = []string{chAddr.String(), fmt.Sprintf("%d", voucherAmt)} cmd = []string{"paych", "voucher", "create", chAddr.String(), fmt.Sprintf("%d", voucherAmt)}
creatorCLI.runCmd(paychVoucherCreateCmd, cmd) creatorCLI.RunCmd(cmd)
cmd = []string{chstr} cmd = []string{"paych", "status", chstr}
out = creatorCLI.runCmd(paychStatusCmd, cmd) out = creatorCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
voucherAmtAtto := types.BigMul(types.NewInt(voucherAmt), types.NewInt(build.FilecoinPrecision)) voucherAmtAtto := types.BigMul(types.NewInt(voucherAmt), types.NewInt(build.FilecoinPrecision))
voucherAmtStr := fmt.Sprintf("%d", voucherAmtAtto) voucherAmtStr := fmt.Sprintf("%d", voucherAmtAtto)
@ -179,21 +175,21 @@ func TestPaymentChannelVouchers(t *testing.T) {
blocktime := 5 * time.Millisecond blocktime := 5 * time.Millisecond
ctx := context.Background() ctx := context.Background()
nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime) nodes, addrs := clitest.StartTwoNodesOneMiner(ctx, t, blocktime)
paymentCreator := nodes[0] paymentCreator := nodes[0]
paymentReceiver := nodes[1] paymentReceiver := nodes[1]
creatorAddr := addrs[0] creatorAddr := addrs[0]
receiverAddr := addrs[1] receiverAddr := addrs[1]
// Create mock CLI // Create mock CLI
mockCLI := newMockCLI(t) mockCLI := clitest.NewMockCLI(t, Commands)
creatorCLI := mockCLI.client(paymentCreator.ListenAddr) creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
receiverCLI := mockCLI.client(paymentReceiver.ListenAddr) receiverCLI := mockCLI.Client(paymentReceiver.ListenAddr)
// creator: paych add-funds <creator> <receiver> <amount> // creator: paych add-funds <creator> <receiver> <amount>
channelAmt := "100000" channelAmt := "100000"
cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt} cmd := []string{"paych", "add-funds", creatorAddr.String(), receiverAddr.String(), channelAmt}
chstr := creatorCLI.runCmd(paychAddFundsCmd, cmd) chstr := creatorCLI.RunCmd(cmd)
chAddr, err := address.NewFromString(chstr) chAddr, err := address.NewFromString(chstr)
require.NoError(t, err) require.NoError(t, err)
@ -203,39 +199,39 @@ func TestPaymentChannelVouchers(t *testing.T) {
// creator: paych voucher create <channel> <amount> // creator: paych voucher create <channel> <amount>
// Note: implied --lane=0 // Note: implied --lane=0
voucherAmt1 := 100 voucherAmt1 := 100
cmd = []string{chAddr.String(), strconv.Itoa(voucherAmt1)} cmd = []string{"paych", "voucher", "create", chAddr.String(), strconv.Itoa(voucherAmt1)}
voucher1 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd) voucher1 := creatorCLI.RunCmd(cmd)
vouchers = append(vouchers, voucherSpec{serialized: voucher1, lane: 0, amt: voucherAmt1}) vouchers = append(vouchers, voucherSpec{serialized: voucher1, lane: 0, amt: voucherAmt1})
// creator: paych voucher create <channel> <amount> --lane=5 // creator: paych voucher create <channel> <amount> --lane=5
lane5 := "--lane=5" lane5 := "--lane=5"
voucherAmt2 := 50 voucherAmt2 := 50
cmd = []string{lane5, chAddr.String(), strconv.Itoa(voucherAmt2)} cmd = []string{"paych", "voucher", "create", lane5, chAddr.String(), strconv.Itoa(voucherAmt2)}
voucher2 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd) voucher2 := creatorCLI.RunCmd(cmd)
vouchers = append(vouchers, voucherSpec{serialized: voucher2, lane: 5, amt: voucherAmt2}) vouchers = append(vouchers, voucherSpec{serialized: voucher2, lane: 5, amt: voucherAmt2})
// creator: paych voucher create <channel> <amount> --lane=5 // creator: paych voucher create <channel> <amount> --lane=5
voucherAmt3 := 70 voucherAmt3 := 70
cmd = []string{lane5, chAddr.String(), strconv.Itoa(voucherAmt3)} cmd = []string{"paych", "voucher", "create", lane5, chAddr.String(), strconv.Itoa(voucherAmt3)}
voucher3 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd) voucher3 := creatorCLI.RunCmd(cmd)
vouchers = append(vouchers, voucherSpec{serialized: voucher3, lane: 5, amt: voucherAmt3}) vouchers = append(vouchers, voucherSpec{serialized: voucher3, lane: 5, amt: voucherAmt3})
// creator: paych voucher create <channel> <amount> --lane=5 // creator: paych voucher create <channel> <amount> --lane=5
voucherAmt4 := 80 voucherAmt4 := 80
cmd = []string{lane5, chAddr.String(), strconv.Itoa(voucherAmt4)} cmd = []string{"paych", "voucher", "create", lane5, chAddr.String(), strconv.Itoa(voucherAmt4)}
voucher4 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd) voucher4 := creatorCLI.RunCmd(cmd)
vouchers = append(vouchers, voucherSpec{serialized: voucher4, lane: 5, amt: voucherAmt4}) vouchers = append(vouchers, voucherSpec{serialized: voucher4, lane: 5, amt: voucherAmt4})
// creator: paych voucher list <channel> --export // creator: paych voucher list <channel> --export
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "list", "--export", chAddr.String()}
list := creatorCLI.runCmd(paychVoucherListCmd, cmd) list := creatorCLI.RunCmd(cmd)
// Check that voucher list output is correct on creator // Check that voucher list output is correct on creator
checkVoucherOutput(t, list, vouchers) checkVoucherOutput(t, list, vouchers)
// creator: paych voucher best-spendable <channel> // creator: paych voucher best-spendable <channel>
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "best-spendable", "--export", chAddr.String()}
bestSpendable := creatorCLI.runCmd(paychVoucherBestSpendableCmd, cmd) bestSpendable := creatorCLI.RunCmd(cmd)
// Check that best spendable output is correct on creator // Check that best spendable output is correct on creator
bestVouchers := []voucherSpec{ bestVouchers := []voucherSpec{
@ -245,31 +241,31 @@ func TestPaymentChannelVouchers(t *testing.T) {
checkVoucherOutput(t, bestSpendable, bestVouchers) checkVoucherOutput(t, bestSpendable, bestVouchers)
// receiver: paych voucher add <voucher> // receiver: paych voucher add <voucher>
cmd = []string{chAddr.String(), voucher1} cmd = []string{"paych", "voucher", "add", chAddr.String(), voucher1}
receiverCLI.runCmd(paychVoucherAddCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher add <voucher> // receiver: paych voucher add <voucher>
cmd = []string{chAddr.String(), voucher2} cmd = []string{"paych", "voucher", "add", chAddr.String(), voucher2}
receiverCLI.runCmd(paychVoucherAddCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher add <voucher> // receiver: paych voucher add <voucher>
cmd = []string{chAddr.String(), voucher3} cmd = []string{"paych", "voucher", "add", chAddr.String(), voucher3}
receiverCLI.runCmd(paychVoucherAddCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher add <voucher> // receiver: paych voucher add <voucher>
cmd = []string{chAddr.String(), voucher4} cmd = []string{"paych", "voucher", "add", chAddr.String(), voucher4}
receiverCLI.runCmd(paychVoucherAddCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher list <channel> --export // receiver: paych voucher list <channel> --export
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "list", "--export", chAddr.String()}
list = receiverCLI.runCmd(paychVoucherListCmd, cmd) list = receiverCLI.RunCmd(cmd)
// Check that voucher list output is correct on receiver // Check that voucher list output is correct on receiver
checkVoucherOutput(t, list, vouchers) checkVoucherOutput(t, list, vouchers)
// receiver: paych voucher best-spendable <channel> // receiver: paych voucher best-spendable <channel>
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "best-spendable", "--export", chAddr.String()}
bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd) bestSpendable = receiverCLI.RunCmd(cmd)
// Check that best spendable output is correct on receiver // Check that best spendable output is correct on receiver
bestVouchers = []voucherSpec{ bestVouchers = []voucherSpec{
@ -279,12 +275,12 @@ func TestPaymentChannelVouchers(t *testing.T) {
checkVoucherOutput(t, bestSpendable, bestVouchers) checkVoucherOutput(t, bestSpendable, bestVouchers)
// receiver: paych voucher submit <channel> <voucher> // receiver: paych voucher submit <channel> <voucher>
cmd = []string{chAddr.String(), voucher1} cmd = []string{"paych", "voucher", "submit", chAddr.String(), voucher1}
receiverCLI.runCmd(paychVoucherSubmitCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher best-spendable <channel> // receiver: paych voucher best-spendable <channel>
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "best-spendable", "--export", chAddr.String()}
bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd) bestSpendable = receiverCLI.RunCmd(cmd)
// Check that best spendable output no longer includes submitted voucher // Check that best spendable output no longer includes submitted voucher
bestVouchers = []voucherSpec{ bestVouchers = []voucherSpec{
@ -295,12 +291,12 @@ func TestPaymentChannelVouchers(t *testing.T) {
// There are three vouchers in lane 5: 50, 70, 80 // There are three vouchers in lane 5: 50, 70, 80
// Submit the voucher for 50. Best spendable should still be 80. // Submit the voucher for 50. Best spendable should still be 80.
// receiver: paych voucher submit <channel> <voucher> // receiver: paych voucher submit <channel> <voucher>
cmd = []string{chAddr.String(), voucher2} cmd = []string{"paych", "voucher", "submit", chAddr.String(), voucher2}
receiverCLI.runCmd(paychVoucherSubmitCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher best-spendable <channel> // receiver: paych voucher best-spendable <channel>
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "best-spendable", "--export", chAddr.String()}
bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd) bestSpendable = receiverCLI.RunCmd(cmd)
// Check that best spendable output still includes the voucher for 80 // Check that best spendable output still includes the voucher for 80
bestVouchers = []voucherSpec{ bestVouchers = []voucherSpec{
@ -310,12 +306,12 @@ func TestPaymentChannelVouchers(t *testing.T) {
// Submit the voucher for 80 // Submit the voucher for 80
// receiver: paych voucher submit <channel> <voucher> // receiver: paych voucher submit <channel> <voucher>
cmd = []string{chAddr.String(), voucher4} cmd = []string{"paych", "voucher", "submit", chAddr.String(), voucher4}
receiverCLI.runCmd(paychVoucherSubmitCmd, cmd) receiverCLI.RunCmd(cmd)
// receiver: paych voucher best-spendable <channel> // receiver: paych voucher best-spendable <channel>
cmd = []string{"--export", chAddr.String()} cmd = []string{"paych", "voucher", "best-spendable", "--export", chAddr.String()}
bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd) bestSpendable = receiverCLI.RunCmd(cmd)
// Check that best spendable output no longer includes submitted voucher // Check that best spendable output no longer includes submitted voucher
bestVouchers = []voucherSpec{} bestVouchers = []voucherSpec{}
@ -329,19 +325,19 @@ func TestPaymentChannelVoucherCreateShortfall(t *testing.T) {
blocktime := 5 * time.Millisecond blocktime := 5 * time.Millisecond
ctx := context.Background() ctx := context.Background()
nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime) nodes, addrs := clitest.StartTwoNodesOneMiner(ctx, t, blocktime)
paymentCreator := nodes[0] paymentCreator := nodes[0]
creatorAddr := addrs[0] creatorAddr := addrs[0]
receiverAddr := addrs[1] receiverAddr := addrs[1]
// Create mock CLI // Create mock CLI
mockCLI := newMockCLI(t) mockCLI := clitest.NewMockCLI(t, Commands)
creatorCLI := mockCLI.client(paymentCreator.ListenAddr) creatorCLI := mockCLI.Client(paymentCreator.ListenAddr)
// creator: paych add-funds <creator> <receiver> <amount> // creator: paych add-funds <creator> <receiver> <amount>
channelAmt := 100 channelAmt := 100
cmd := []string{creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)} cmd := []string{"paych", "add-funds", creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)}
chstr := creatorCLI.runCmd(paychAddFundsCmd, cmd) chstr := creatorCLI.RunCmd(cmd)
chAddr, err := address.NewFromString(chstr) chAddr, err := address.NewFromString(chstr)
require.NoError(t, err) require.NoError(t, err)
@ -349,15 +345,15 @@ func TestPaymentChannelVoucherCreateShortfall(t *testing.T) {
// creator: paych voucher create <channel> <amount> --lane=1 // creator: paych voucher create <channel> <amount> --lane=1
voucherAmt1 := 60 voucherAmt1 := 60
lane1 := "--lane=1" lane1 := "--lane=1"
cmd = []string{lane1, chAddr.String(), strconv.Itoa(voucherAmt1)} cmd = []string{"paych", "voucher", "create", lane1, chAddr.String(), strconv.Itoa(voucherAmt1)}
voucher1 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd) voucher1 := creatorCLI.RunCmd(cmd)
fmt.Println(voucher1) fmt.Println(voucher1)
// creator: paych voucher create <channel> <amount> --lane=2 // creator: paych voucher create <channel> <amount> --lane=2
lane2 := "--lane=2" lane2 := "--lane=2"
voucherAmt2 := 70 voucherAmt2 := 70
cmd = []string{lane2, chAddr.String(), strconv.Itoa(voucherAmt2)} cmd = []string{"paych", "voucher", "create", lane2, chAddr.String(), strconv.Itoa(voucherAmt2)}
_, err = creatorCLI.runCmdRaw(paychVoucherCreateCmd, cmd) _, err = creatorCLI.RunCmdRaw(cmd)
// Should fail because channel doesn't have required amount // Should fail because channel doesn't have required amount
require.Error(t, err) require.Error(t, err)
@ -388,129 +384,6 @@ func checkVoucherOutput(t *testing.T, list string, vouchers []voucherSpec) {
} }
} }
func startTwoNodesOneMiner(ctx context.Context, t *testing.T, blocktime time.Duration) ([]test.TestNode, []address.Address) {
n, sn := builder.RPCMockSbBuilder(t, test.TwoFull, test.OneMiner)
paymentCreator := n[0]
paymentReceiver := n[1]
miner := sn[0]
// Get everyone connected
addrs, err := paymentCreator.NetAddrsListen(ctx)
if err != nil {
t.Fatal(err)
}
if err := paymentReceiver.NetConnect(ctx, addrs); err != nil {
t.Fatal(err)
}
if err := miner.NetConnect(ctx, addrs); err != nil {
t.Fatal(err)
}
// Start mining blocks
bm := test.NewBlockMiner(ctx, t, miner, blocktime)
bm.MineBlocks()
// Send some funds to register the receiver
receiverAddr, err := paymentReceiver.WalletNew(ctx, types.KTSecp256k1)
if err != nil {
t.Fatal(err)
}
test.SendFunds(ctx, t, paymentCreator, receiverAddr, abi.NewTokenAmount(1e18))
// Get the creator's address
creatorAddr, err := paymentCreator.WalletDefaultAddress(ctx)
if err != nil {
t.Fatal(err)
}
// Create mock CLI
return n, []address.Address{creatorAddr, receiverAddr}
}
type mockCLI struct {
t *testing.T
cctx *cli.Context
out *bytes.Buffer
}
// TODO: refactor to use the methods in cli/test/mockcli.go
func newMockCLI(t *testing.T) *mockCLI {
// Create a CLI App with an --api-url flag so that we can specify which node
// the command should be executed against
app := cli.NewApp()
app.Flags = []cli.Flag{
&cli.StringFlag{
Name: "api-url",
Hidden: true,
},
}
var out bytes.Buffer
app.Writer = &out
app.Setup()
cctx := cli.NewContext(app, &flag.FlagSet{}, nil)
return &mockCLI{t: t, cctx: cctx, out: &out}
}
func (c *mockCLI) client(addr multiaddr.Multiaddr) *mockCLIClient {
return &mockCLIClient{t: c.t, addr: addr, cctx: c.cctx, out: c.out}
}
// mockCLIClient runs commands against a particular node
type mockCLIClient struct {
t *testing.T
addr multiaddr.Multiaddr
cctx *cli.Context
out *bytes.Buffer
}
func (c *mockCLIClient) runCmd(cmd *cli.Command, input []string) string {
out, err := c.runCmdRaw(cmd, input)
require.NoError(c.t, err)
return out
}
func (c *mockCLIClient) runCmdRaw(cmd *cli.Command, input []string) (string, error) {
// prepend --api-url=<node api listener address>
apiFlag := "--api-url=" + c.addr.String()
input = append([]string{apiFlag}, input...)
fs := c.flagSet(cmd)
err := fs.Parse(input)
require.NoError(c.t, err)
err = cmd.Action(cli.NewContext(c.cctx.App, fs, c.cctx))
// Get the output
str := strings.TrimSpace(c.out.String())
c.out.Reset()
return str, err
}
func (c *mockCLIClient) flagSet(cmd *cli.Command) *flag.FlagSet {
// Apply app level flags (so we can process --api-url flag)
fs := &flag.FlagSet{}
for _, f := range c.cctx.App.Flags {
err := f.Apply(fs)
if err != nil {
c.t.Fatal(err)
}
}
// Apply command level flags
for _, f := range cmd.Flags {
err := f.Apply(fs)
if err != nil {
c.t.Fatal(err)
}
}
return fs
}
// waitForHeight waits for the node to reach the given chain epoch // waitForHeight waits for the node to reach the given chain epoch
func waitForHeight(ctx context.Context, t *testing.T, node test.TestNode, height abi.ChainEpoch) { func waitForHeight(ctx context.Context, t *testing.T, node test.TestNode, height abi.ChainEpoch) {
atHeight := make(chan struct{}) atHeight := make(chan struct{})

14
cli/test/client.go
View File

@ -25,8 +25,8 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
defer cancel() defer cancel()
// Create mock CLI // Create mock CLI
mockCLI := newMockCLI(t, cmds) mockCLI := NewMockCLI(t, cmds)
clientCLI := mockCLI.client(clientNode.ListenAddr) clientCLI := mockCLI.Client(clientNode.ListenAddr)
// Get the miner address // Get the miner address
addrs, err := clientNode.StateListMiners(ctx, types.EmptyTSK) addrs, err := clientNode.StateListMiners(ctx, types.EmptyTSK)
@ -40,7 +40,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
cmd := []string{ cmd := []string{
"client", "query-ask", minerAddr.String(), "client", "query-ask", minerAddr.String(),
} }
out := clientCLI.runCmd(cmd) out := clientCLI.RunCmd(cmd)
require.Regexp(t, regexp.MustCompile("Ask:"), out) require.Regexp(t, regexp.MustCompile("Ask:"), out)
// Create a deal (non-interactive) // Create a deal (non-interactive)
@ -53,7 +53,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
cmd = []string{ cmd = []string{
"client", "deal", dataCid.String(), minerAddr.String(), price, duration, "client", "deal", dataCid.String(), minerAddr.String(), price, duration,
} }
out = clientCLI.runCmd(cmd) out = clientCLI.RunCmd(cmd)
fmt.Println("client deal", out) fmt.Println("client deal", out)
// Create a deal (interactive) // Create a deal (interactive)
@ -77,7 +77,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
"no", "no",
"yes", "yes",
} }
out = clientCLI.runInteractiveCmd(cmd, interactiveCmds) out = clientCLI.RunInteractiveCmd(cmd, interactiveCmds)
fmt.Println("client deal:\n", out) fmt.Println("client deal:\n", out)
// Wait for provider to start sealing deal // Wait for provider to start sealing deal
@ -85,7 +85,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
for dealStatus != "StorageDealSealing" { for dealStatus != "StorageDealSealing" {
// client list-deals // client list-deals
cmd = []string{"client", "list-deals"} cmd = []string{"client", "list-deals"}
out = clientCLI.runCmd(cmd) out = clientCLI.RunCmd(cmd)
fmt.Println("list-deals:\n", out) fmt.Println("list-deals:\n", out)
lines := strings.Split(out, "\n") lines := strings.Split(out, "\n")
@ -109,7 +109,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
cmd = []string{ cmd = []string{
"client", "retrieve", dataCid.String(), path, "client", "retrieve", dataCid.String(), path,
} }
out = clientCLI.runCmd(cmd) out = clientCLI.RunCmd(cmd)
fmt.Println("retrieve:\n", out) fmt.Println("retrieve:\n", out)
require.Regexp(t, regexp.MustCompile("Success"), out) require.Regexp(t, regexp.MustCompile("Success"), out)
} }

70
cli/test/mockcli.go
View File

@ -11,14 +11,14 @@ import (
lcli "github.com/urfave/cli/v2" lcli "github.com/urfave/cli/v2"
) )
type mockCLI struct { type MockCLI struct {
t *testing.T t *testing.T
cmds []*lcli.Command cmds []*lcli.Command
cctx *lcli.Context cctx *lcli.Context
out *bytes.Buffer out *bytes.Buffer
} }
func newMockCLI(t *testing.T, cmds []*lcli.Command) *mockCLI { func NewMockCLI(t *testing.T, cmds []*lcli.Command) *MockCLI {
// Create a CLI App with an --api-url flag so that we can specify which node // Create a CLI App with an --api-url flag so that we can specify which node
// the command should be executed against // the command should be executed against
app := &lcli.App{ app := &lcli.App{
@ -36,15 +36,15 @@ func newMockCLI(t *testing.T, cmds []*lcli.Command) *mockCLI {
app.Setup() app.Setup()
cctx := lcli.NewContext(app, &flag.FlagSet{}, nil) cctx := lcli.NewContext(app, &flag.FlagSet{}, nil)
return &mockCLI{t: t, cmds: cmds, cctx: cctx, out: &out} return &MockCLI{t: t, cmds: cmds, cctx: cctx, out: &out}
} }
func (c *mockCLI) client(addr multiaddr.Multiaddr) *mockCLIClient { func (c *MockCLI) Client(addr multiaddr.Multiaddr) *MockCLIClient {
return &mockCLIClient{t: c.t, cmds: c.cmds, addr: addr, cctx: c.cctx, out: c.out} return &MockCLIClient{t: c.t, cmds: c.cmds, addr: addr, cctx: c.cctx, out: c.out}
} }
// mockCLIClient runs commands against a particular node // MockCLIClient runs commands against a particular node
type mockCLIClient struct { type MockCLIClient struct {
t *testing.T t *testing.T
cmds []*lcli.Command cmds []*lcli.Command
addr multiaddr.Multiaddr addr multiaddr.Multiaddr
@ -52,7 +52,7 @@ type mockCLIClient struct {
out *bytes.Buffer out *bytes.Buffer
} }
func (c *mockCLIClient) run(cmd []string, params []string, args []string) string { func (c *MockCLIClient) run(cmd []string, params []string, args []string) string {
// Add parameter --api-url=<node api listener address> // Add parameter --api-url=<node api listener address>
apiFlag := "--api-url=" + c.addr.String() apiFlag := "--api-url=" + c.addr.String()
params = append([]string{apiFlag}, params...) params = append([]string{apiFlag}, params...)
@ -66,28 +66,48 @@ func (c *mockCLIClient) run(cmd []string, params []string, args []string) string
return str return str
} }
func (c *mockCLIClient) runCmd(input []string) string { func (c *MockCLIClient) RunCmd(input []string) string {
cmd := c.cmdByNameSub(input[0], input[1]) out, err := c.RunCmdRaw(input)
out, err := c.runCmdRaw(cmd, input[2:])
require.NoError(c.t, err) require.NoError(c.t, err)
return out return out
} }
func (c *mockCLIClient) cmdByNameSub(name string, sub string) *lcli.Command { // Given an input, find the corresponding command or sub-command.
for _, c := range c.cmds { // eg "paych add-funds"
if c.Name == name { func (c *MockCLIClient) cmdByNameSub(input []string) (*lcli.Command, []string) {
for _, s := range c.Subcommands { name := input[0]
if s.Name == sub { for _, cmd := range c.cmds {
return s if cmd.Name == name {
return c.findSubcommand(cmd, input[1:])
} }
} }
} return nil, []string{}
}
return nil
} }
func (c *mockCLIClient) runCmdRaw(cmd *lcli.Command, input []string) (string, error) { func (c *MockCLIClient) findSubcommand(cmd *lcli.Command, input []string) (*lcli.Command, []string) {
// If there are no sub-commands, return the current command
if len(cmd.Subcommands) == 0 {
return cmd, input
}
// Check each sub-command for a match against the name
subName := input[0]
for _, subCmd := range cmd.Subcommands {
if subCmd.Name == subName {
// Found a match, recursively search for sub-commands
return c.findSubcommand(subCmd, input[1:])
}
}
return nil, []string{}
}
func (c *MockCLIClient) RunCmdRaw(input []string) (string, error) {
cmd, input := c.cmdByNameSub(input)
if cmd == nil {
panic("Could not find command " + input[0] + " " + input[1])
}
// prepend --api-url=<node api listener address> // prepend --api-url=<node api listener address>
apiFlag := "--api-url=" + c.addr.String() apiFlag := "--api-url=" + c.addr.String()
input = append([]string{apiFlag}, input...) input = append([]string{apiFlag}, input...)
@ -104,7 +124,7 @@ func (c *mockCLIClient) runCmdRaw(cmd *lcli.Command, input []string) (string, er
return str, err return str, err
} }
func (c *mockCLIClient) flagSet(cmd *lcli.Command) *flag.FlagSet { func (c *MockCLIClient) flagSet(cmd *lcli.Command) *flag.FlagSet {
// Apply app level flags (so we can process --api-url flag) // Apply app level flags (so we can process --api-url flag)
fs := &flag.FlagSet{} fs := &flag.FlagSet{}
for _, f := range c.cctx.App.Flags { for _, f := range c.cctx.App.Flags {
@ -123,11 +143,11 @@ func (c *mockCLIClient) flagSet(cmd *lcli.Command) *flag.FlagSet {
return fs return fs
} }
func (c *mockCLIClient) runInteractiveCmd(cmd []string, interactive []string) string { func (c *MockCLIClient) RunInteractiveCmd(cmd []string, interactive []string) string {
c.toStdin(strings.Join(interactive, "\n") + "\n") c.toStdin(strings.Join(interactive, "\n") + "\n")
return c.runCmd(cmd) return c.RunCmd(cmd)
} }
func (c *mockCLIClient) toStdin(s string) { func (c *MockCLIClient) toStdin(s string) {
c.cctx.App.Metadata["stdin"] = bytes.NewBufferString(s) c.cctx.App.Metadata["stdin"] = bytes.NewBufferString(s)
} }

12
cli/test/multisig.go
View File

@ -18,8 +18,8 @@ func RunMultisigTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNod
ctx := context.Background() ctx := context.Background()
// Create mock CLI // Create mock CLI
mockCLI := newMockCLI(t, cmds) mockCLI := NewMockCLI(t, cmds)
clientCLI := mockCLI.client(clientNode.ListenAddr) clientCLI := mockCLI.Client(clientNode.ListenAddr)
// Create some wallets on the node to use for testing multisig // Create some wallets on the node to use for testing multisig
var walletAddrs []address.Address var walletAddrs []address.Address
@ -48,7 +48,7 @@ func RunMultisigTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNod
walletAddrs[1].String(), walletAddrs[1].String(),
walletAddrs[2].String(), walletAddrs[2].String(),
} }
out := clientCLI.runCmd(cmd) out := clientCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
// Extract msig robust address from output // Extract msig robust address from output
@ -68,12 +68,12 @@ func RunMultisigTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNod
msigRobustAddr, msigRobustAddr,
walletAddrs[3].String(), walletAddrs[3].String(),
} }
out = clientCLI.runCmd(cmd) out = clientCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
// msig inspect <msig> // msig inspect <msig>
cmd = []string{"msig", "inspect", "--vesting", "--decode-params", msigRobustAddr} cmd = []string{"msig", "inspect", "--vesting", "--decode-params", msigRobustAddr}
out = clientCLI.runCmd(cmd) out = clientCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
// Expect correct balance // Expect correct balance
@ -96,6 +96,6 @@ func RunMultisigTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNod
walletAddrs[3].String(), walletAddrs[3].String(),
"false", "false",
} }
out = clientCLI.runCmd(cmd) out = clientCLI.RunCmd(cmd)
fmt.Println(out) fmt.Println(out)
} }

46
cli/test/net.go
View File

@ -5,6 +5,9 @@ import (
"testing" "testing"
"time" "time"
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/go-address" "github.com/filecoin-project/go-address"
"github.com/filecoin-project/lotus/api/test" "github.com/filecoin-project/lotus/api/test"
test2 "github.com/filecoin-project/lotus/node/test" test2 "github.com/filecoin-project/lotus/node/test"
@ -39,3 +42,46 @@ func StartOneNodeOneMiner(ctx context.Context, t *testing.T, blocktime time.Dura
// Create mock CLI // Create mock CLI
return full, fullAddr return full, fullAddr
} }
func StartTwoNodesOneMiner(ctx context.Context, t *testing.T, blocktime time.Duration) ([]test.TestNode, []address.Address) {
n, sn := test2.RPCMockSbBuilder(t, test.TwoFull, test.OneMiner)
fullNode1 := n[0]
fullNode2 := n[1]
miner := sn[0]
// Get everyone connected
addrs, err := fullNode1.NetAddrsListen(ctx)
if err != nil {
t.Fatal(err)
}
if err := fullNode2.NetConnect(ctx, addrs); err != nil {
t.Fatal(err)
}
if err := miner.NetConnect(ctx, addrs); err != nil {
t.Fatal(err)
}
// Start mining blocks
bm := test.NewBlockMiner(ctx, t, miner, blocktime)
bm.MineBlocks()
// Send some funds to register the second node
fullNodeAddr2, err := fullNode2.WalletNew(ctx, types.KTSecp256k1)
if err != nil {
t.Fatal(err)
}
test.SendFunds(ctx, t, fullNode1, fullNodeAddr2, abi.NewTokenAmount(1e18))
// Get the first node's address
fullNodeAddr1, err := fullNode1.WalletDefaultAddress(ctx)
if err != nil {
t.Fatal(err)
}
// Create mock CLI
return n, []address.Address{fullNodeAddr1, fullNodeAddr2}
}