0g-chain/x/swap/keeper/keeper_test.go
drklee3 3375484f79
Update deprecated Cosmos methods (#1530)
* 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
2023-04-05 16:21:59 -07:00

197 lines
5.6 KiB
Go

package keeper_test
import (
"os"
"testing"
"github.com/kava-labs/kava/app"
"github.com/kava-labs/kava/x/swap/testutil"
"github.com/kava-labs/kava/x/swap/types"
"github.com/kava-labs/kava/x/swap/types/mocks"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/suite"
)
func TestMain(m *testing.M) {
config := sdk.GetConfig()
app.SetBech32AddressPrefixes(config)
os.Exit(m.Run())
}
type keeperTestSuite struct {
testutil.Suite
}
func (suite *keeperTestSuite) SetupTest() {
suite.Suite.SetupTest()
suite.Keeper.SetParams(suite.Ctx, types.DefaultParams())
}
func TestKeeperTestSuite(t *testing.T) {
suite.Run(t, new(keeperTestSuite))
}
func (suite *keeperTestSuite) setupPool(reserves sdk.Coins, totalShares sdkmath.Int, depositor sdk.AccAddress) string {
poolID := types.PoolIDFromCoins(reserves)
suite.AddCoinsToModule(reserves)
poolRecord := types.PoolRecord{
PoolID: poolID,
ReservesA: reserves[0],
ReservesB: reserves[1],
TotalShares: totalShares,
}
suite.Keeper.SetPool(suite.Ctx, poolRecord)
shareRecord := types.ShareRecord{
Depositor: depositor,
PoolID: poolID,
SharesOwned: totalShares,
}
suite.Keeper.SetDepositorShares(suite.Ctx, shareRecord)
return poolID
}
func (suite keeperTestSuite) TestParams_Persistance() {
keeper := suite.Keeper
params := types.Params{
AllowedPools: types.AllowedPools{
types.NewAllowedPool("ukava", "usdx"),
},
SwapFee: sdk.MustNewDecFromStr("0.03"),
}
keeper.SetParams(suite.Ctx, params)
suite.Equal(keeper.GetParams(suite.Ctx), params)
oldParams := params
params = types.Params{
AllowedPools: types.AllowedPools{
types.NewAllowedPool("hard", "ukava"),
},
SwapFee: sdk.MustNewDecFromStr("0.01"),
}
keeper.SetParams(suite.Ctx, params)
suite.NotEqual(keeper.GetParams(suite.Ctx), oldParams)
suite.Equal(keeper.GetParams(suite.Ctx), params)
}
func (suite keeperTestSuite) TestParams_GetSwapFee() {
keeper := suite.Keeper
params := types.Params{
SwapFee: sdk.MustNewDecFromStr("0.00333"),
}
keeper.SetParams(suite.Ctx, params)
suite.Equal(keeper.GetSwapFee(suite.Ctx), params.SwapFee)
}
func (suite *keeperTestSuite) TestPool_Persistance() {
reserves := sdk.NewCoins(
sdk.NewCoin("ukava", sdkmath.NewInt(10e6)),
sdk.NewCoin("usdx", sdkmath.NewInt(50e6)),
)
pool, err := types.NewDenominatedPool(reserves)
suite.Nil(err)
record := types.NewPoolRecordFromPool(pool)
suite.Keeper.SetPool(suite.Ctx, record)
savedRecord, ok := suite.Keeper.GetPool(suite.Ctx, record.PoolID)
suite.True(ok)
suite.Equal(record, savedRecord)
savedShares, ok := suite.Keeper.GetPoolShares(suite.Ctx, record.PoolID)
suite.True(ok)
suite.Equal(record.TotalShares, savedShares)
suite.Keeper.DeletePool(suite.Ctx, record.PoolID)
deletedPool, ok := suite.Keeper.GetPool(suite.Ctx, record.PoolID)
suite.False(ok)
suite.Equal(deletedPool, types.PoolRecord{})
}
func (suite *keeperTestSuite) TestPool_PanicsWhenInvalid() {
invalidRecord := types.NewPoolRecord(
sdk.NewCoins(sdk.NewCoin("ukava", sdkmath.NewInt(100e6)), sdk.NewCoin("usdx", sdkmath.NewInt(100e6))),
i(-1),
)
suite.Panics(func() {
suite.Keeper.SetPool(suite.Ctx, invalidRecord)
}, "expected set pool to panic with invalid record")
}
func (suite *keeperTestSuite) TestShare_Persistance() {
poolID := types.PoolID("ukava", "usdx")
depositor, err := sdk.AccAddressFromBech32("kava1skpsgk5cnrarn69ql2tfun47fyjssataz0g07l")
suite.NoError(err)
shares := sdkmath.NewInt(3126432331)
record := types.NewShareRecord(depositor, poolID, shares)
suite.Keeper.SetDepositorShares(suite.Ctx, record)
savedRecord, ok := suite.Keeper.GetDepositorShares(suite.Ctx, depositor, poolID)
suite.True(ok)
suite.Equal(record, savedRecord)
savedShares, ok := suite.Keeper.GetDepositorSharesAmount(suite.Ctx, depositor, poolID)
suite.True(ok)
suite.Equal(record.SharesOwned, savedShares)
suite.Keeper.DeleteDepositorShares(suite.Ctx, depositor, poolID)
deletedShares, ok := suite.Keeper.GetDepositorShares(suite.Ctx, depositor, poolID)
suite.False(ok)
suite.Equal(deletedShares, types.ShareRecord{})
}
func (suite *keeperTestSuite) TestShare_PanicsWhenInvalid() {
depositor, err := sdk.AccAddressFromBech32("kava1mq9qxlhze029lm0frzw2xr6hem8c3k9ts54w0w")
suite.Require().NoError(err)
invalidRecord := types.NewShareRecord(
depositor,
"hard/usdx",
i(-1),
)
suite.Panics(func() {
suite.Keeper.SetDepositorShares(suite.Ctx, invalidRecord)
}, "expected set depositor shares to panic with invalid record")
}
func (suite *keeperTestSuite) TestHooks() {
// ensure no hooks are set
suite.Keeper.ClearHooks()
// data
depositor, err := sdk.AccAddressFromBech32("kava1mq9qxlhze029lm0frzw2xr6hem8c3k9ts54w0w")
suite.Require().NoError(err)
// hooks can be called when not set
suite.Keeper.AfterPoolDepositCreated(suite.Ctx, "ukava/usdx", depositor, sdkmath.NewInt(1e6))
suite.Keeper.BeforePoolDepositModified(suite.Ctx, "ukava/usdx", depositor, sdkmath.NewInt(1e6))
// set hooks
swapHooks := &mocks.SwapHooks{}
suite.Keeper.SetHooks(swapHooks)
// test hook calls are correct
swapHooks.On("AfterPoolDepositCreated", suite.Ctx, "ukava/usdx", depositor, sdkmath.NewInt(1e6)).Once()
suite.Keeper.AfterPoolDepositCreated(suite.Ctx, "ukava/usdx", depositor, sdkmath.NewInt(1e6))
swapHooks.On("BeforePoolDepositModified", suite.Ctx, "ukava/usdx", depositor, sdkmath.NewInt(1e6)).Once()
suite.Keeper.BeforePoolDepositModified(suite.Ctx, "ukava/usdx", depositor, sdkmath.NewInt(1e6))
swapHooks.AssertExpectations(suite.T())
// test second set panics
suite.PanicsWithValue("cannot set swap hooks twice", func() {
suite.Keeper.SetHooks(swapHooks)
}, "expected hooks to panic on second set")
}