github.com/Finschia/finschia-sdk@v0.49.1/x/auth/client/tx_test.go (about)

     1  package client_test
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/require"
     9  
    10  	"github.com/Finschia/finschia-sdk/client"
    11  	"github.com/Finschia/finschia-sdk/codec"
    12  	cryptocodec "github.com/Finschia/finschia-sdk/crypto/codec"
    13  	"github.com/Finschia/finschia-sdk/crypto/keys/ed25519"
    14  	"github.com/Finschia/finschia-sdk/simapp"
    15  	"github.com/Finschia/finschia-sdk/testutil"
    16  	"github.com/Finschia/finschia-sdk/testutil/testdata"
    17  	sdk "github.com/Finschia/finschia-sdk/types"
    18  	authclient "github.com/Finschia/finschia-sdk/x/auth/client"
    19  	"github.com/Finschia/finschia-sdk/x/auth/legacy/legacytx"
    20  	authtypes "github.com/Finschia/finschia-sdk/x/auth/types"
    21  )
    22  
    23  var (
    24  	priv = ed25519.GenPrivKey()
    25  	addr = sdk.AccAddress(priv.PubKey().Address())
    26  )
    27  
    28  func TestParseQueryResponse(t *testing.T) {
    29  	simRes := &sdk.SimulationResponse{
    30  		GasInfo: sdk.GasInfo{GasUsed: 10, GasWanted: 20},
    31  		Result:  &sdk.Result{Data: []byte("tx data"), Log: "log"},
    32  	}
    33  
    34  	bz, err := codec.ProtoMarshalJSON(simRes, nil)
    35  	require.NoError(t, err)
    36  
    37  	res, err := authclient.ParseQueryResponse(bz)
    38  	require.NoError(t, err)
    39  	require.Equal(t, 10, int(res.GasInfo.GasUsed))
    40  	require.NotNil(t, res.Result)
    41  
    42  	_, err = authclient.ParseQueryResponse([]byte("fuzzy"))
    43  	require.Error(t, err)
    44  }
    45  
    46  // TODO: remove this and authclient.GetTxEncoder after the proto tx migration is complete
    47  func TestDefaultTxEncoder(t *testing.T) {
    48  	cdc := makeCodec()
    49  
    50  	defaultEncoder := legacytx.DefaultTxEncoder(cdc)
    51  	encoder := authclient.GetTxEncoder(cdc)
    52  
    53  	compareEncoders(t, defaultEncoder, encoder)
    54  }
    55  
    56  func TestReadTxFromFile(t *testing.T) {
    57  	t.Parallel()
    58  	encodingConfig := simapp.MakeTestEncodingConfig()
    59  
    60  	txCfg := encodingConfig.TxConfig
    61  	clientCtx := client.Context{}
    62  	clientCtx = clientCtx.WithInterfaceRegistry(encodingConfig.InterfaceRegistry)
    63  	clientCtx = clientCtx.WithTxConfig(txCfg)
    64  
    65  	feeAmount := sdk.Coins{sdk.NewInt64Coin("atom", 150)}
    66  	gasLimit := uint64(50000)
    67  	memo := "foomemo"
    68  
    69  	txBuilder := txCfg.NewTxBuilder()
    70  	txBuilder.SetFeeAmount(feeAmount)
    71  	txBuilder.SetGasLimit(gasLimit)
    72  	txBuilder.SetMemo(memo)
    73  
    74  	// Write it to the file
    75  	encodedTx, err := txCfg.TxJSONEncoder()(txBuilder.GetTx())
    76  	require.NoError(t, err)
    77  
    78  	jsonTxFile := testutil.WriteToNewTempFile(t, string(encodedTx))
    79  	// Read it back
    80  	decodedTx, err := authclient.ReadTxFromFile(clientCtx, jsonTxFile.Name())
    81  	require.NoError(t, err)
    82  	txBldr, err := txCfg.WrapTxBuilder(decodedTx)
    83  	require.NoError(t, err)
    84  	t.Log(txBuilder.GetTx())
    85  	t.Log(txBldr.GetTx())
    86  	require.Equal(t, txBuilder.GetTx().GetMemo(), txBldr.GetTx().GetMemo())
    87  	require.Equal(t, txBuilder.GetTx().GetFee(), txBldr.GetTx().GetFee())
    88  }
    89  
    90  func TestBatchScanner_Scan(t *testing.T) {
    91  	t.Parallel()
    92  	encodingConfig := simapp.MakeTestEncodingConfig()
    93  
    94  	txGen := encodingConfig.TxConfig
    95  	clientCtx := client.Context{}
    96  	clientCtx = clientCtx.WithTxConfig(txGen)
    97  
    98  	// generate some tx JSON
    99  	bldr := txGen.NewTxBuilder()
   100  	bldr.SetGasLimit(50000)
   101  	bldr.SetFeeAmount(sdk.NewCoins(sdk.NewInt64Coin("atom", 150)))
   102  	bldr.SetMemo("foomemo")
   103  	txJson, err := txGen.TxJSONEncoder()(bldr.GetTx())
   104  	require.NoError(t, err)
   105  
   106  	// use the tx JSON to generate some tx batches (it doesn't matter that we use the same JSON because we don't care about the actual context)
   107  	goodBatchOf3Txs := fmt.Sprintf("%s\n%s\n%s\n", txJson, txJson, txJson)
   108  	malformedBatch := fmt.Sprintf("%s\nmalformed\n%s\n", txJson, txJson)
   109  	batchOf2TxsWithNoNewline := fmt.Sprintf("%s\n%s", txJson, txJson)
   110  	batchWithEmptyLine := fmt.Sprintf("%s\n\n%s", txJson, txJson)
   111  
   112  	tests := []struct {
   113  		name               string
   114  		batch              string
   115  		wantScannerError   bool
   116  		wantUnmarshalError bool
   117  		numTxs             int
   118  	}{
   119  		{"good batch", goodBatchOf3Txs, false, false, 3},
   120  		{"malformed", malformedBatch, false, true, 1},
   121  		{"missing trailing newline", batchOf2TxsWithNoNewline, false, false, 2},
   122  		{"empty line", batchWithEmptyLine, false, true, 1},
   123  	}
   124  
   125  	for _, tt := range tests {
   126  		t.Run(tt.name, func(t *testing.T) {
   127  			scanner, i := authclient.NewBatchScanner(clientCtx.TxConfig, strings.NewReader(tt.batch)), 0
   128  			for scanner.Scan() {
   129  				_ = scanner.Tx()
   130  				i++
   131  			}
   132  			require.Equal(t, tt.wantScannerError, scanner.Err() != nil)
   133  			require.Equal(t, tt.wantUnmarshalError, scanner.UnmarshalErr() != nil)
   134  			require.Equal(t, tt.numTxs, i)
   135  		})
   136  	}
   137  }
   138  
   139  func compareEncoders(t *testing.T, expected, actual sdk.TxEncoder) {
   140  	t.Helper()
   141  	msgs := []sdk.Msg{testdata.NewTestMsg(addr)}
   142  	tx := legacytx.NewStdTx(msgs, legacytx.StdFee{}, []legacytx.StdSignature{}, "") //nolint:staticcheck // this will be removed when proto is ready
   143  
   144  	defaultEncoderBytes, err := expected(tx)
   145  	require.NoError(t, err)
   146  	encoderBytes, err := actual(tx)
   147  	require.NoError(t, err)
   148  	require.Equal(t, defaultEncoderBytes, encoderBytes)
   149  }
   150  
   151  func makeCodec() *codec.LegacyAmino {
   152  	cdc := codec.NewLegacyAmino()
   153  	sdk.RegisterLegacyAminoCodec(cdc)
   154  	cryptocodec.RegisterCrypto(cdc)
   155  	authtypes.RegisterLegacyAminoCodec(cdc)
   156  	cdc.RegisterConcrete(testdata.TestMsg{}, "cosmos-sdk/Test", nil)
   157  	return cdc
   158  }