mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-12-29 01:35:18 +00:00
3375484f79
* Use cosmossdk.io/errors for deprecated error methods * Update error registration with cosmossdk.io/errors * Use cosmossdk.io/math for deprecated sdk.Int alias * Fix modified proto file * Update sdk.Int usage in swap hooks * Update e2e test deprecated method usage
174 lines
5.7 KiB
Go
174 lines
5.7 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", sdkmath.NewInt(10))
|
|
// coinB := sdk.NewCoin("usdx", sdkmath.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", sdkmath.NewInt(10))
|
|
// coinB := sdk.NewCoin("usdx", sdkmath.NewInt(200))
|
|
// coinC := sdk.NewCoin("usdx", sdkmath.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.PoolRecords{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", sdkmath.NewInt(10))
|
|
// coinB := sdk.NewCoin("usdx", sdkmath.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))
|
|
// }
|