github.com/Finschia/finschia-sdk@v0.48.1/x/bank/keeper/querier_test.go (about)

     1  package keeper_test
     2  
     3  import (
     4  	"fmt"
     5  
     6  	abci "github.com/tendermint/tendermint/abci/types"
     7  
     8  	"github.com/Finschia/finschia-sdk/simapp"
     9  	"github.com/Finschia/finschia-sdk/testutil/testdata"
    10  	sdk "github.com/Finschia/finschia-sdk/types"
    11  	"github.com/Finschia/finschia-sdk/types/query"
    12  	"github.com/Finschia/finschia-sdk/x/bank/keeper"
    13  	"github.com/Finschia/finschia-sdk/x/bank/types"
    14  	minttypes "github.com/Finschia/finschia-sdk/x/mint/types"
    15  )
    16  
    17  func (suite *IntegrationTestSuite) TestQuerier_QueryBalance() {
    18  	app, ctx := suite.app, suite.ctx
    19  	legacyAmino := app.LegacyAmino()
    20  	_, _, addr := testdata.KeyTestPubAddr()
    21  	req := abci.RequestQuery{
    22  		Path: fmt.Sprintf("custom/%s/%s", types.ModuleName, types.QueryBalance),
    23  		Data: []byte{},
    24  	}
    25  
    26  	querier := keeper.NewQuerier(app.BankKeeper, legacyAmino)
    27  
    28  	res, err := querier(ctx, []string{types.QueryBalance}, req)
    29  	suite.Require().NotNil(err)
    30  	suite.Require().Nil(res)
    31  
    32  	req.Data = legacyAmino.MustMarshalJSON(types.NewQueryBalanceRequest(addr, fooDenom))
    33  	res, err = querier(ctx, []string{types.QueryBalance}, req)
    34  	suite.Require().NoError(err)
    35  	suite.Require().NotNil(res)
    36  
    37  	var balance sdk.Coin
    38  	suite.Require().NoError(legacyAmino.UnmarshalJSON(res, &balance))
    39  	suite.True(balance.IsZero())
    40  
    41  	origCoins := sdk.NewCoins(newFooCoin(50), newBarCoin(30))
    42  	acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
    43  
    44  	app.AccountKeeper.SetAccount(ctx, acc)
    45  	suite.Require().NoError(simapp.FundAccount(app, ctx, acc.GetAddress(), origCoins))
    46  
    47  	res, err = querier(ctx, []string{types.QueryBalance}, req)
    48  	suite.Require().NoError(err)
    49  	suite.Require().NotNil(res)
    50  	suite.Require().NoError(legacyAmino.UnmarshalJSON(res, &balance))
    51  	suite.True(balance.IsEqual(newFooCoin(50)))
    52  }
    53  
    54  func (suite *IntegrationTestSuite) TestQuerier_QueryAllBalances() {
    55  	app, ctx := suite.app, suite.ctx
    56  	legacyAmino := app.LegacyAmino()
    57  	_, _, addr := testdata.KeyTestPubAddr()
    58  	req := abci.RequestQuery{
    59  		Path: fmt.Sprintf("custom/%s/%s", types.ModuleName, types.QueryAllBalances),
    60  		Data: []byte{},
    61  	}
    62  
    63  	querier := keeper.NewQuerier(app.BankKeeper, legacyAmino)
    64  
    65  	res, err := querier(ctx, []string{types.QueryAllBalances}, req)
    66  	suite.Require().NotNil(err)
    67  	suite.Require().Nil(res)
    68  
    69  	req.Data = legacyAmino.MustMarshalJSON(types.NewQueryAllBalancesRequest(addr, nil))
    70  	res, err = querier(ctx, []string{types.QueryAllBalances}, req)
    71  	suite.Require().NoError(err)
    72  	suite.Require().NotNil(res)
    73  
    74  	var balances sdk.Coins
    75  	suite.Require().NoError(legacyAmino.UnmarshalJSON(res, &balances))
    76  	suite.True(balances.IsZero())
    77  
    78  	origCoins := sdk.NewCoins(newFooCoin(50), newBarCoin(30))
    79  	acc := app.AccountKeeper.NewAccountWithAddress(ctx, addr)
    80  
    81  	app.AccountKeeper.SetAccount(ctx, acc)
    82  	suite.Require().NoError(simapp.FundAccount(app, ctx, acc.GetAddress(), origCoins))
    83  	res, err = querier(ctx, []string{types.QueryAllBalances}, req)
    84  	suite.Require().NoError(err)
    85  	suite.Require().NotNil(res)
    86  	suite.Require().NoError(legacyAmino.UnmarshalJSON(res, &balances))
    87  	suite.True(balances.IsEqual(origCoins))
    88  }
    89  
    90  func (suite *IntegrationTestSuite) TestQuerier_QueryTotalSupply() {
    91  	app, ctx := suite.app, suite.ctx
    92  	legacyAmino := app.LegacyAmino()
    93  	expectedTotalSupply := sdk.NewCoins(sdk.NewInt64Coin("test", 400000000))
    94  	suite.
    95  		Require().
    96  		NoError(app.BankKeeper.MintCoins(ctx, minttypes.ModuleName, expectedTotalSupply))
    97  
    98  	req := abci.RequestQuery{
    99  		Path: fmt.Sprintf("custom/%s/%s", types.ModuleName, types.QueryTotalSupply),
   100  		Data: []byte{},
   101  	}
   102  
   103  	querier := keeper.NewQuerier(app.BankKeeper, legacyAmino)
   104  
   105  	res, err := querier(ctx, []string{types.QueryTotalSupply}, req)
   106  	suite.Require().NotNil(err)
   107  	suite.Require().Nil(res)
   108  
   109  	req.Data = legacyAmino.MustMarshalJSON(types.QueryTotalSupplyRequest{Pagination: &query.PageRequest{
   110  		Limit: 100,
   111  	}})
   112  	res, err = querier(ctx, []string{types.QueryTotalSupply}, req)
   113  	suite.Require().NoError(err)
   114  	suite.Require().NotNil(res)
   115  
   116  	var resp types.QueryTotalSupplyResponse
   117  	suite.Require().NoError(legacyAmino.UnmarshalJSON(res, &resp))
   118  	suite.Require().Equal(expectedTotalSupply, resp.Supply)
   119  }
   120  
   121  func (suite *IntegrationTestSuite) TestQuerier_QueryTotalSupplyOf() {
   122  	app, ctx := suite.app, suite.ctx
   123  	legacyAmino := app.LegacyAmino()
   124  	test1Supply := sdk.NewInt64Coin("test1", 4000000)
   125  	test2Supply := sdk.NewInt64Coin("test2", 700000000)
   126  	expectedTotalSupply := sdk.NewCoins(test1Supply, test2Supply)
   127  	suite.
   128  		Require().
   129  		NoError(app.BankKeeper.MintCoins(ctx, minttypes.ModuleName, expectedTotalSupply))
   130  
   131  	req := abci.RequestQuery{
   132  		Path: fmt.Sprintf("custom/%s/%s", types.ModuleName, types.QuerySupplyOf),
   133  		Data: []byte{},
   134  	}
   135  
   136  	querier := keeper.NewQuerier(app.BankKeeper, legacyAmino)
   137  
   138  	res, err := querier(ctx, []string{types.QuerySupplyOf}, req)
   139  	suite.Require().NotNil(err)
   140  	suite.Require().Nil(res)
   141  
   142  	req.Data = legacyAmino.MustMarshalJSON(types.NewQuerySupplyOfParams(test1Supply.Denom))
   143  	res, err = querier(ctx, []string{types.QuerySupplyOf}, req)
   144  	suite.Require().NoError(err)
   145  	suite.Require().NotNil(res)
   146  
   147  	var resp sdk.Coin
   148  	suite.Require().NoError(legacyAmino.UnmarshalJSON(res, &resp))
   149  	suite.Require().Equal(test1Supply, resp)
   150  }
   151  
   152  func (suite *IntegrationTestSuite) TestQuerierRouteNotFound() {
   153  	app, ctx := suite.app, suite.ctx
   154  	legacyAmino := app.LegacyAmino()
   155  	req := abci.RequestQuery{
   156  		Path: fmt.Sprintf("custom/%s/invalid", types.ModuleName),
   157  		Data: []byte{},
   158  	}
   159  
   160  	querier := keeper.NewQuerier(app.BankKeeper, legacyAmino)
   161  	_, err := querier(ctx, []string{"invalid"}, req)
   162  	suite.Error(err)
   163  }