Add test suite for client TxBuilder (#6460)

* Add tests

* Fix gofmt

* typecast tests

* Fix review comments

* typecast SigVerificableTx

* cleanup

* Refactor

* Linting and move encode/decode tests to suite

* Fix lint

* Move test suite

* godoc

* Refactor

* Refactor

Co-authored-by: Aaron Craelius <aaronc@users.noreply.github.com>
Co-authored-by: Aaron Craelius <aaron@regen.network>

client/testutil/suite.go

@@ -0,0 +1,110 @@
+package testutil
+
+import (
+	"github.com/stretchr/testify/suite"
+	"github.com/tendermint/tendermint/crypto"
+	"github.com/tendermint/tendermint/crypto/secp256k1"
+
+	"github.com/cosmos/cosmos-sdk/client"
+
+	signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// TxGeneratorTestSuite provides a test suite that can be used to test that a TxGenerator implementation is correct
+//nolint:golint  // type name will be used as tx.TxGeneratorTestSuite by other packages, and that stutters; consider calling this GeneratorTestSuite
+type TxGeneratorTestSuite struct {
+	suite.Suite
+	TxGenerator client.TxGenerator
+}
+
+// NewTxGeneratorTestSuite returns a new TxGeneratorTestSuite with the provided TxGenerator implementation
+func NewTxGeneratorTestSuite(txGenerator client.TxGenerator) *TxGeneratorTestSuite {
+	return &TxGeneratorTestSuite{TxGenerator: txGenerator}
+}
+
+func (s *TxGeneratorTestSuite) TestTxBuilderGetTx() {
+	stdTxBuilder := s.TxGenerator.NewTxBuilder()
+	tx := stdTxBuilder.GetTx()
+	s.Require().NotNil(tx)
+	s.Require().Equal(len(tx.GetMsgs()), 0)
+}
+
+func (s *TxGeneratorTestSuite) TestTxBuilderSetFeeAmount() {
+	stdTxBuilder := s.TxGenerator.NewTxBuilder()
+	feeAmount := sdk.Coins{
+		sdk.NewInt64Coin("atom", 20000000),
+	}
+	stdTxBuilder.SetFeeAmount(feeAmount)
+	feeTx := stdTxBuilder.GetTx().(sdk.FeeTx)
+	s.Require().Equal(feeAmount, feeTx.GetFee())
+}
+
+func (s *TxGeneratorTestSuite) TestTxBuilderSetGasLimit() {
+	const newGas uint64 = 300000
+	stdTxBuilder := s.TxGenerator.NewTxBuilder()
+	stdTxBuilder.SetGasLimit(newGas)
+	feeTx := stdTxBuilder.GetTx().(sdk.FeeTx)
+	s.Require().Equal(newGas, feeTx.GetGas())
+}
+
+func (s *TxGeneratorTestSuite) TestTxBuilderSetMemo() {
+	const newMemo string = "newfoomemo"
+	stdTxBuilder := s.TxGenerator.NewTxBuilder()
+	stdTxBuilder.SetMemo(newMemo)
+	txWithMemo := stdTxBuilder.GetTx().(sdk.TxWithMemo)
+	s.Require().Equal(txWithMemo.GetMemo(), newMemo)
+}
+
+func (s *TxGeneratorTestSuite) TestTxBuilderSetMsgs() {
+	stdTxBuilder := s.TxGenerator.NewTxBuilder()
+	tx := stdTxBuilder.GetTx()
+	err := stdTxBuilder.SetMsgs(sdk.NewTestMsg(), sdk.NewTestMsg())
+	s.Require().NoError(err)
+	s.Require().NotEqual(tx, stdTxBuilder.GetTx())
+	s.Require().Equal(len(stdTxBuilder.GetTx().GetMsgs()), 2)
+}
+
+type HasSignaturesTx interface {
+	GetSignatures() [][]byte
+	GetSigners() []sdk.AccAddress
+	GetPubKeys() []crypto.PubKey // If signer already has pubkey in context, this list will have nil in its place
+}
+
+func (s *TxGeneratorTestSuite) TestTxBuilderSetSignatures() {
+	priv := secp256k1.GenPrivKey()
+
+	stdTxBuilder := s.TxGenerator.NewTxBuilder()
+	tx := stdTxBuilder.GetTx()
+	singleSignatureData := signingtypes.SingleSignatureData{
+		Signature: priv.PubKey().Bytes(),
+		SignMode:  signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON,
+	}
+
+	err := stdTxBuilder.SetSignatures(signingtypes.SignatureV2{
+		PubKey: priv.PubKey(),
+		Data:   &singleSignatureData,
+	})
+	sigTx := stdTxBuilder.GetTx().(HasSignaturesTx)
+	s.Require().NoError(err)
+	s.Require().NotEqual(tx, stdTxBuilder.GetTx())
+	s.Require().Equal(sigTx.GetSignatures()[0], priv.PubKey().Bytes())
+}
+
+func (s *TxGeneratorTestSuite) TestTxEncodeDecode() {
+	txBuilder := s.TxGenerator.NewTxBuilder()
+	txBuilder.SetFeeAmount(sdk.Coins{sdk.NewInt64Coin("atom", 150)})
+	txBuilder.SetGasLimit(50000)
+	txBuilder.SetMemo("foomemo")
+	tx := txBuilder.GetTx()
+
+	// Encode transaction
+	txBytes, err := s.TxGenerator.TxEncoder()(tx)
+	s.Require().NoError(err)
+	s.Require().NotNil(txBytes)
+
+	tx2, err := s.TxGenerator.TxDecoder()(txBytes)
+	s.Require().NoError(err)
+	s.Require().Equal(tx, tx2)
+}

x/auth/client/cli/encode_test.go

@@ -4,12 +4,13 @@ import (
 	"encoding/base64"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"github.com/cosmos/cosmos-sdk/client"
 	simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
 	"github.com/cosmos/cosmos-sdk/tests"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
-	"github.com/stretchr/testify/require"
 )
 
 func TestGetCommandEncode(t *testing.T) {

x/auth/types/client_tx_test.go

@@ -1,34 +1,26 @@
 package types_test
 
 import (
-	"github.com/cosmos/cosmos-sdk/client"
-	simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
-	sdk "github.com/cosmos/cosmos-sdk/types"
-	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
-	"github.com/stretchr/testify/require"
 	"testing"
+
+	"github.com/cosmos/cosmos-sdk/client/testutil"
+
+	"github.com/stretchr/testify/suite"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
-func TestTxEncoder(t *testing.T) {
-	clientCtx := client.Context{}
-	clientCtx = clientCtx.WithTxGenerator(simappparams.MakeEncodingConfig().TxGenerator)
-
-	encodingConfig := simappparams.MakeEncodingConfig()
-	sdk.RegisterCodec(encodingConfig.Amino)
-
-	txGen := encodingConfig.TxGenerator
-	clientCtx = clientCtx.WithTxGenerator(txGen)
-
-	// Build a test transaction
-	fee := authtypes.NewStdFee(50000, sdk.Coins{sdk.NewInt64Coin("atom", 150)})
-	stdTx := authtypes.NewStdTx([]sdk.Msg{nil}, fee, []authtypes.StdSignature{}, "foomemo")
-
-	// Encode transaction
-	txBytes, err := clientCtx.TxGenerator.TxEncoder()(stdTx)
-	require.NoError(t, err)
-	require.NotNil(t, txBytes)
-
-	tx, err := clientCtx.TxGenerator.TxDecoder()(txBytes)
-	require.NoError(t, err)
-	require.Equal(t, []sdk.Msg{nil}, tx.GetMsgs())
+func testCodec() *codec.Codec {
+	cdc := codec.New()
+	sdk.RegisterCodec(cdc)
+	cdc.RegisterConcrete(sdk.TestMsg{}, "cosmos-sdk/Test", nil)
+	return cdc
+}
+
+func TestStdTxGenerator(t *testing.T) {
+	cdc := testCodec()
+	txGen := types.StdTxGenerator{Cdc: cdc}
+	suite.Run(t, testutil.NewTxGeneratorTestSuite(txGen))
 }