Add test for txDecoderMiddleware

cosmos · Dec 1, 2021 · 51cbf76 · 51cbf76
1 parent 963e5b6
commit 51cbf76
Show file tree

Hide file tree

Showing 11 changed files with 108 additions and 51 deletions.
diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go
@@ -132,6 +132,7 @@ func setupBaseApp(t *testing.T, options ...func(*baseapp.BaseApp)) *baseapp.Base
 func testTxHandler(options middleware.TxHandlerOptions, customTxHandlerMiddleware handlerFun) tx.Handler {
 	return middleware.ComposeMiddlewares(
 		middleware.NewRunMsgsTxHandler(options.MsgServiceRouter, options.LegacyRouter),
+		middleware.NewTxDecoderMiddleware(options.TxDecoder),
 		middleware.GasTxMiddleware,
 		middleware.RecoveryTxMiddleware,
 		middleware.NewIndexEventsTxMiddleware(options.IndexEvents),

diff --git a/server/mock/app.go b/server/mock/app.go
@@ -59,6 +59,7 @@ func NewApp(rootDir string, logger log.Logger) (abci.Application, error) {
 		middleware.TxHandlerOptions{
 			LegacyRouter:     legacyRouter,
 			MsgServiceRouter: middleware.NewMsgServiceRouter(encCfg.InterfaceRegistry),
+			TxDecoder:        encCfg.TxConfig.TxDecoder(),
 		},
 	)
 	baseApp.SetTxHandler(txHandler)

diff --git a/x/auth/middleware/basic_test.go b/x/auth/middleware/basic_test.go
@@ -16,7 +16,7 @@ func (s *MWTestSuite) TestValidateBasic() {
 	ctx := s.SetupTest(true) // setup
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
 
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.ValidateBasicMiddleware)
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.ValidateBasicMiddleware)
 
 	// keys and addresses
 	priv1, _, addr1 := testdata.KeyTestPubAddr()
@@ -54,7 +54,7 @@ func (s *MWTestSuite) TestValidateBasic() {
 func (s *MWTestSuite) TestValidateMemo() {
 	ctx := s.SetupTest(true) // setup
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.ValidateMemoMiddleware(s.app.AccountKeeper))
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.ValidateMemoMiddleware(s.app.AccountKeeper))
 
 	// keys and addresses
 	priv1, _, addr1 := testdata.KeyTestPubAddr()
@@ -90,7 +90,7 @@ func (s *MWTestSuite) TestConsumeGasForTxSize() {
 	ctx := s.SetupTest(true) // setup
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
 
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.ConsumeTxSizeGasMiddleware(s.app.AccountKeeper))
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.ConsumeTxSizeGasMiddleware(s.app.AccountKeeper))
 
 	// keys and addresses
 	priv1, _, addr1 := testdata.KeyTestPubAddr()
@@ -174,7 +174,7 @@ func (s *MWTestSuite) TestConsumeGasForTxSize() {
 func (s *MWTestSuite) TestTxHeightTimeoutMiddleware() {
 	ctx := s.SetupTest(true)
 
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.TxTimeoutHeightMiddleware)
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.TxTimeoutHeightMiddleware)
 
 	// keys and addresses
 	priv1, _, addr1 := testdata.KeyTestPubAddr()

diff --git a/x/auth/middleware/ext_test.go b/x/auth/middleware/ext_test.go
@@ -13,7 +13,7 @@ func (s *MWTestSuite) TestRejectExtensionOptionsMiddleware() {
 	ctx := s.SetupTest(true) // setup
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
 
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.RejectExtensionOptionsMiddleware)
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.RejectExtensionOptionsMiddleware)
 
 	// no extension options should not trigger an error
 	theTx := txBuilder.GetTx()

diff --git a/x/auth/middleware/fee_test.go b/x/auth/middleware/fee_test.go
@@ -13,7 +13,7 @@ func (s *MWTestSuite) TestEnsureMempoolFees() {
 	ctx := s.SetupTest(true) // setup
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
 
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.MempoolFeeMiddleware)
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.MempoolFeeMiddleware)
 
 	// keys and addresses
 	priv1, _, addr1 := testdata.KeyTestPubAddr()
@@ -55,7 +55,7 @@ func (s *MWTestSuite) TestDeductFees() {
 	ctx := s.SetupTest(false) // setup
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.DeductFeeMiddleware(
 			s.app.AccountKeeper,
 			s.app.BankKeeper,

diff --git a/x/auth/middleware/feegrant_test.go b/x/auth/middleware/feegrant_test.go
@@ -31,7 +31,7 @@ func (s *MWTestSuite) TestDeductFeesNoDelegation() {
 	protoTxCfg := tx.NewTxConfig(codec.NewProtoCodec(app.InterfaceRegistry()), tx.DefaultSignModes)
 
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.DeductFeeMiddleware(
 			s.app.AccountKeeper,
 			s.app.BankKeeper,

diff --git a/x/auth/middleware/gas_test.go b/x/auth/middleware/gas_test.go
@@ -50,7 +50,7 @@ func (s *MWTestSuite) setupGasTx() (signing.Tx, []byte, sdk.Context, uint64) {
 
 func (s *MWTestSuite) TestSetup() {
 	testTx, _, ctx, gasLimit := s.setupGasTx()
-	txHandler := middleware.ComposeMiddlewares(noopTxHandler{}, middleware.GasTxMiddleware)
+	txHandler := middleware.ComposeMiddlewares(noopTxHandler, middleware.GasTxMiddleware)
 
 	testcases := []struct {
 		name        string
@@ -77,62 +77,48 @@ func (s *MWTestSuite) TestSetup() {
 
 func (s *MWTestSuite) TestRecoverPanic() {
 	testTx, txBytes, ctx, gasLimit := s.setupGasTx()
-	txHandler := middleware.ComposeMiddlewares(outOfGasTxHandler{}, middleware.GasTxMiddleware, middleware.RecoveryTxMiddleware)
+	txHandler := middleware.ComposeMiddlewares(outOfGasTxHandler, middleware.GasTxMiddleware, middleware.RecoveryTxMiddleware)
 	res, _, err := txHandler.CheckTx(sdk.WrapSDKContext(ctx), tx.Request{Tx: testTx, TxBytes: txBytes}, tx.RequestCheckTx{})
 	s.Require().Error(err, "Did not return error on OutOfGas panic")
 	s.Require().True(errors.Is(sdkerrors.ErrOutOfGas, err), "Returned error is not an out of gas error")
 	s.Require().Equal(gasLimit, uint64(res.GasWanted))
 
-	txHandler = middleware.ComposeMiddlewares(outOfGasTxHandler{}, middleware.GasTxMiddleware)
+	txHandler = middleware.ComposeMiddlewares(outOfGasTxHandler, middleware.GasTxMiddleware)
 	s.Require().Panics(func() {
 		txHandler.CheckTx(sdk.WrapSDKContext(ctx), tx.Request{Tx: testTx, TxBytes: txBytes}, tx.RequestCheckTx{})
 	}, "Recovered from non-Out-of-Gas panic")
 }
 
-// outOfGasTxHandler is a test middleware that will throw OutOfGas panic.
-type outOfGasTxHandler struct{}
-
-var _ tx.Handler = outOfGasTxHandler{}
-
-func (txh outOfGasTxHandler) DeliverTx(ctx context.Context, _ tx.Request) (tx.Response, error) {
-	sdkCtx := sdk.UnwrapSDKContext(ctx)
-	overLimit := sdkCtx.GasMeter().Limit() + 1
+// customTxHandler is a test middleware that will run a custom function.
+type customTxHandler struct {
+	fn func(context.Context, tx.Request) (tx.Response, error)
+}
 
-	// Should panic with outofgas error
-	sdkCtx.GasMeter().ConsumeGas(overLimit, "test panic")
+var _ tx.Handler = customTxHandler{}
 
-	panic("not reached")
+func (h customTxHandler) DeliverTx(ctx context.Context, req tx.Request) (tx.Response, error) {
+	return h.fn(ctx, req)
+}
+func (h customTxHandler) CheckTx(ctx context.Context, req tx.Request, _ tx.RequestCheckTx) (tx.Response, tx.ResponseCheckTx, error) {
+	res, err := h.fn(ctx, req)
+	return res, tx.ResponseCheckTx{}, err
+}
+func (h customTxHandler) SimulateTx(ctx context.Context, req tx.Request) (tx.Response, error) {
+	return h.fn(ctx, req)
 }
-func (txh outOfGasTxHandler) CheckTx(ctx context.Context, _ tx.Request, _ tx.RequestCheckTx) (tx.Response, tx.ResponseCheckTx, error) {
-	sdkCtx := sdk.UnwrapSDKContext(ctx)
-	overLimit := sdkCtx.GasMeter().Limit() + 1
 
-	// Should panic with outofgas error
-	sdkCtx.GasMeter().ConsumeGas(overLimit, "test panic")
+// noopTxHandler is a test middleware that returns an empty response.
+var noopTxHandler = customTxHandler{func(_ context.Context, _ tx.Request) (tx.Response, error) {
+	return tx.Response{}, nil
+}}
 
-	panic("not reached")
-}
-func (txh outOfGasTxHandler) SimulateTx(ctx context.Context, _ tx.Request) (tx.Response, error) {
+// outOfGasTxHandler is a test middleware that panics with an outOfGas error.
+var outOfGasTxHandler = customTxHandler{func(ctx context.Context, _ tx.Request) (tx.Response, error) {
 	sdkCtx := sdk.UnwrapSDKContext(ctx)
 	overLimit := sdkCtx.GasMeter().Limit() + 1
 
 	// Should panic with outofgas error
 	sdkCtx.GasMeter().ConsumeGas(overLimit, "test panic")
 
 	panic("not reached")
-}
-
-// noopTxHandler is a test middleware that does nothing.
-type noopTxHandler struct{}
-
-var _ tx.Handler = noopTxHandler{}
-
-func (txh noopTxHandler) CheckTx(_ context.Context, _ tx.Request, _ tx.RequestCheckTx) (tx.Response, tx.ResponseCheckTx, error) {
-	return tx.Response{}, tx.ResponseCheckTx{}, nil
-}
-func (txh noopTxHandler) SimulateTx(_ context.Context, _ tx.Request) (tx.Response, error) {
-	return tx.Response{}, nil
-}
-func (txh noopTxHandler) DeliverTx(ctx context.Context, _ tx.Request) (tx.Response, error) {
-	return tx.Response{}, nil
-}
+}}
diff --git a/x/auth/middleware/middleware_test.go b/x/auth/middleware/middleware_test.go
@@ -1025,6 +1025,7 @@ func (s *MWTestSuite) TestCustomSignatureVerificationGasConsumer() {
 					return sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey)
 				}
 			},
+			TxDecoder: s.clientCtx.TxConfig.TxDecoder(),
 		},
 	)
 	s.Require().NoError(err)

diff --git a/x/auth/middleware/sigverify_test.go b/x/auth/middleware/sigverify_test.go
@@ -27,7 +27,7 @@ func (s *MWTestSuite) TestSetPubKey() {
 	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
 	require := s.Require()
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.SetPubKeyMiddleware(s.app.AccountKeeper),
 	)
 
@@ -127,7 +127,7 @@ func (s *MWTestSuite) TestSigVerification() {
 	// make block height non-zero to ensure account numbers part of signBytes
 	ctx = ctx.WithBlockHeight(1)
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.SetPubKeyMiddleware(s.app.AccountKeeper),
 		middleware.SigVerificationMiddleware(
 			s.app.AccountKeeper,
@@ -239,7 +239,7 @@ func (s *MWTestSuite) TestSigVerification_ExplicitAmino() {
 	gasLimit := testdata.NewTestGasLimit()
 
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.SetPubKeyMiddleware(s.app.AccountKeeper),
 		middleware.SigVerificationMiddleware(
 			s.app.AccountKeeper,
@@ -342,7 +342,7 @@ func (s *MWTestSuite) runSigMiddlewares(params types.Params, _ bool, privs ...cr
 	s.Require().NoError(err)
 
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.SetPubKeyMiddleware(s.app.AccountKeeper),
 		middleware.SigGasConsumeMiddleware(s.app.AccountKeeper, middleware.DefaultSigVerificationGasConsumer),
 		middleware.SigVerificationMiddleware(
@@ -382,7 +382,7 @@ func (s *MWTestSuite) TestIncrementSequenceMiddleware() {
 	s.Require().NoError(err)
 
 	txHandler := middleware.ComposeMiddlewares(
-		noopTxHandler{},
+		noopTxHandler,
 		middleware.IncrementSequenceMiddleware(s.app.AccountKeeper),
 	)
 

diff --git a/x/auth/middleware/testutil_test.go b/x/auth/middleware/testutil_test.go
@@ -89,6 +89,7 @@ func (s *MWTestSuite) SetupTest(isCheckTx bool) sdk.Context {
 		FeegrantKeeper:   s.app.FeeGrantKeeper,
 		SignModeHandler:  encodingConfig.TxConfig.SignModeHandler(),
 		SigGasConsumer:   middleware.DefaultSigVerificationGasConsumer,
+		TxDecoder:        s.clientCtx.TxConfig.TxDecoder(),
 	})
 	s.Require().NoError(err)
 	s.txHandler = txHandler

diff --git a/x/auth/middleware/tx_test.go b/x/auth/middleware/tx_test.go
@@ -0,0 +1,67 @@
+package middleware_test
+
+import (
+	"context"
+
+	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
+	"github.com/cosmos/cosmos-sdk/testutil/testdata"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/tx"
+	"github.com/cosmos/cosmos-sdk/x/auth/middleware"
+)
+
+func (s *MWTestSuite) TestTxDecoderMiddleware() {
+	ctx := s.SetupTest(true) // setup
+	require := s.Require()
+
+	// Create a tx.
+	priv1, _, addr1 := testdata.KeyTestPubAddr()
+	txBuilder := s.clientCtx.TxConfig.NewTxBuilder()
+	err := txBuilder.SetMsgs(testdata.NewTestMsg(addr1))
+	require.NoError(err)
+	sdkTx, txBz, err := s.createTestTx(txBuilder, []cryptotypes.PrivKey{priv1}, []uint64{1}, []uint64{0}, ctx.ChainID())
+	require.NoError(err)
+
+	testcases := []struct {
+		name      string
+		txHandler tx.Handler
+		req       tx.Request
+		expErr    bool
+	}{
+		{"empty tx bz", noopTxHandler, tx.Request{}, true},
+		{
+			"tx bz and tx populated",
+			customTxHandler{func(c context.Context, r tx.Request) (tx.Response, error) {
+				require.NotNil(r.Tx)
+				require.Equal(sdkTx.GetMsgs()[0], r.Tx.GetMsgs()[0])
+				return tx.Response{}, nil
+			}},
+			tx.Request{Tx: sdkTx, TxBytes: txBz},
+			false,
+		},
+		{
+			"tx bz populated only",
+			customTxHandler{func(c context.Context, r tx.Request) (tx.Response, error) {
+				require.NotNil(r.Tx)
+				require.Equal(sdkTx.GetMsgs()[0], r.Tx.GetMsgs()[0])
+				return tx.Response{}, nil
+			}},
+			tx.Request{TxBytes: txBz},
+			false,
+		},
+	}
+	for _, tc := range testcases {
+		s.Run(tc.name, func() {
+			txHandler := middleware.ComposeMiddlewares(
+				tc.txHandler,
+				middleware.NewTxDecoderMiddleware(s.clientCtx.TxConfig.TxDecoder()),
+			)
+			_, err := txHandler.DeliverTx(sdk.WrapSDKContext(ctx), tc.req)
+			if tc.expErr {
+				require.Error(err)
+			} else {
+				require.NoError(err)
+			}
+		})
+	}
+}