0g-chain/x/swap/keeper/querier_test.go
Kevin Davis d45fa58f5c
Swap Genesis State (#960)
* wip: add swap state persistent to genesis

* separate pool record constructors; add tests for json and yaml encoding
of record structs

* beef up validation checks for state records

* fix integration with master - renamed method

* add test coverage for basic state array validations

* extra test around pool record reserve and id ordering to ensure no
regressions in the future

* add validations to ensure pool records and share records are unique
within the collection types

* test genesis json and yaml encoding

* validate in genesis that the total shares owned for each pool is equal
to the total shares of each pool

* update alias

* nit lint

* test genesis init and export

* add migration todo

Co-authored-by: Nick DeLuca <nickdeluca08@gmail.com>
2021-07-15 09:42:30 -05:00

174 lines
5.3 KiB
Go

package keeper_test
import (
"strings"
"testing"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/kava-labs/kava/app"
"github.com/kava-labs/kava/x/swap/keeper"
"github.com/kava-labs/kava/x/swap/testutil"
"github.com/kava-labs/kava/x/swap/types"
)
type querierTestSuite struct {
testutil.Suite
querier sdk.Querier
addresses []sdk.AccAddress
}
func (suite *querierTestSuite) SetupTest() {
suite.Suite.SetupTest()
// Set up auth GenesisState
_, addrs := app.GeneratePrivKeyAddressPairs(5)
coins := []sdk.Coins{}
for j := 0; j < 5; j++ {
coins = append(coins, cs(c("ukava", 10000000000), c("bnb", 10000000000), c("usdx", 10000000000)))
}
suite.addresses = addrs
authGS := app.NewAuthGenState(addrs, coins)
suite.App.InitializeFromGenesisStates(
authGS,
NewSwapGenStateMulti(),
)
suite.querier = keeper.NewQuerier(suite.Keeper)
}
func (suite *querierTestSuite) TestUnkownRequest() {
ctx := suite.Ctx.WithIsCheckTx(false)
bz, err := suite.querier(ctx, []string{"invalid-path"}, abci.RequestQuery{})
suite.Nil(bz)
suite.EqualError(err, "unknown request: unknown swap query endpoint")
}
func (suite *querierTestSuite) TestQueryParams() {
ctx := suite.Ctx.WithIsCheckTx(false)
bz, err := suite.querier(ctx, []string{types.QueryGetParams}, abci.RequestQuery{})
suite.Nil(err)
suite.NotNil(bz)
var p types.Params
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &p))
swapGenesisState := NewSwapGenStateMulti()
gs := types.GenesisState{}
err = types.ModuleCdc.UnmarshalJSON(swapGenesisState["swap"], &gs)
suite.Require().NoError(err)
suite.Equal(gs.Params, p)
}
func (suite *querierTestSuite) TestQueryPool() {
// Set up pool in store
coinA := sdk.NewCoin("ukava", sdk.NewInt(10))
coinB := sdk.NewCoin("usdx", sdk.NewInt(200))
pool, err := types.NewDenominatedPool(sdk.NewCoins(coinA, coinB))
suite.Nil(err)
poolRecord := types.NewPoolRecordFromPool(pool)
suite.Keeper.SetPool(suite.Ctx, poolRecord)
ctx := suite.Ctx.WithIsCheckTx(false)
// Set up request query
query := abci.RequestQuery{
Path: strings.Join([]string{"custom", types.QuerierRoute, types.QueryGetPool}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryPoolParams(poolRecord.PoolID)),
}
bz, err := suite.querier(ctx, []string{types.QueryGetPool}, query)
suite.Nil(err)
suite.NotNil(bz)
var res types.PoolStatsQueryResult
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &res))
// Check that result matches expected result
totalCoins := pool.ShareValue(pool.TotalShares())
expectedResult := types.NewPoolStatsQueryResult(poolRecord.PoolID, totalCoins, pool.TotalShares())
suite.Equal(expectedResult, res)
}
func (suite *querierTestSuite) TestQueryPools() {
// Set up pools in store
coinA := sdk.NewCoin("ukava", sdk.NewInt(10))
coinB := sdk.NewCoin("usdx", sdk.NewInt(200))
coinC := sdk.NewCoin("usdx", sdk.NewInt(200))
poolAB, err := types.NewDenominatedPool(sdk.NewCoins(coinA, coinB))
suite.Nil(err)
poolRecordAB := types.NewPoolRecordFromPool(poolAB)
suite.Keeper.SetPool(suite.Ctx, poolRecordAB)
poolAC, err := types.NewDenominatedPool(sdk.NewCoins(coinA, coinC))
suite.Nil(err)
poolRecordAC := types.NewPoolRecordFromPool(poolAC)
suite.Keeper.SetPool(suite.Ctx, poolRecordAC)
// Build a map of pools to compare to query results
pools := []types.PoolRecord{poolRecordAB, poolRecordAC}
poolsMap := make(map[string]types.PoolRecord)
for _, pool := range pools {
poolsMap[pool.PoolID] = pool
}
ctx := suite.Ctx.WithIsCheckTx(false)
bz, err := suite.querier(ctx, []string{types.QueryGetPools}, abci.RequestQuery{})
suite.Nil(err)
suite.NotNil(bz)
var res types.PoolStatsQueryResults
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &res))
// Check that all pools are accounted for
suite.Equal(len(poolsMap), len(res))
// Check that each individual result matches the expected result
for _, pool := range res {
expectedPool, ok := poolsMap[pool.Name]
suite.True(ok)
suite.Equal(expectedPool.PoolID, pool.Name)
suite.Equal(sdk.NewCoins(expectedPool.ReservesA, expectedPool.ReservesB), pool.Coins)
suite.Equal(expectedPool.TotalShares, pool.TotalShares)
}
}
func (suite *querierTestSuite) TestQueryDeposit() {
// Set up pool in store
coinA := sdk.NewCoin("ukava", sdk.NewInt(10))
coinB := sdk.NewCoin("usdx", sdk.NewInt(200))
pool, err := types.NewDenominatedPool(sdk.NewCoins(coinA, coinB))
suite.Nil(err)
poolRecord := types.NewPoolRecordFromPool(pool)
suite.Keeper.SetPool(suite.Ctx, poolRecord)
// Deposit into pool
owner := suite.addresses[0]
err = suite.Keeper.Deposit(suite.Ctx, owner, coinA, coinB, sdk.MustNewDecFromStr("0.20"))
suite.Nil(err)
ctx := suite.Ctx.WithIsCheckTx(false)
// Set up request query
query := abci.RequestQuery{
Path: strings.Join([]string{"custom", types.QuerierRoute, types.QueryGetDeposits}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryDepositsParams(1, 100, owner, poolRecord.PoolID)),
}
bz, err := suite.querier(ctx, []string{types.QueryGetDeposits}, query)
suite.Nil(err)
suite.NotNil(bz)
var res types.DepositsQueryResults
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &res))
// As the only depositor all pool shares should belong to the owner
suite.Equal(poolRecord.TotalShares, res[0].SharesOwned)
}
func TestQuerierTestSuite(t *testing.T) {
suite.Run(t, new(querierTestSuite))
}