0g-chain/x/cdp/keeper/querier_test.go
Derrick Lee f84a8b0be0
Add /cdp/totalPrincipal and /cdp/totalCollateral Endpoints (#1027)
* Add cdp/totals rest endpoint for aggregated principal and fees

* Add total collateral to aggregated cdp

* Add pagination

* Update totalPrincipal endpoint to use keeper GetTotalPrincipal

* Update documentation for queryGetTotalPrincipal

Co-authored-by: Kevin Davis <karzak@users.noreply.github.com>

* Remove unused AggregatedCDP types

* Make CDP type optional, return all if not provided

* add total collateral endpoint that efficient fetches collateral
for a types, only iterating cdps for types b, etc

* correctly and efficienlty filter for a single collateral type

Co-authored-by: Kevin Davis <karzak@users.noreply.github.com>
Co-authored-by: Nick DeLuca <nickdeluca08@gmail.com>
2021-10-23 13:09:59 -05:00

471 lines
15 KiB
Go

package keeper_test
import (
"fmt"
"math/rand"
"sort"
"strings"
"testing"
"time"
"github.com/stretchr/testify/suite"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/simulation"
supply "github.com/cosmos/cosmos-sdk/x/supply"
abci "github.com/tendermint/tendermint/abci/types"
tmtime "github.com/tendermint/tendermint/types/time"
"github.com/kava-labs/kava/app"
"github.com/kava-labs/kava/x/cdp/keeper"
"github.com/kava-labs/kava/x/cdp/types"
pfkeeper "github.com/kava-labs/kava/x/pricefeed/keeper"
pftypes "github.com/kava-labs/kava/x/pricefeed/types"
)
const (
custom = "custom"
)
type QuerierTestSuite struct {
suite.Suite
keeper keeper.Keeper
pricefeedKeeper pfkeeper.Keeper
addrs []sdk.AccAddress
app app.TestApp
cdps types.CDPs
augmentedCDPs types.AugmentedCDPs
ctx sdk.Context
querier sdk.Querier
}
func (suite *QuerierTestSuite) SetupTest() {
tApp := app.NewTestApp()
ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: tmtime.Now()})
cdps := make(types.CDPs, 100)
augmentedCDPs := make(types.AugmentedCDPs, 100)
_, addrs := app.GeneratePrivKeyAddressPairs(100)
coins := []sdk.Coins{}
for j := 0; j < 100; j++ {
coins = append(coins, cs(c("btc", 10000000000), c("xrp", 10000000000)))
}
authGS := app.NewAuthGenState(
addrs, coins)
tApp.InitializeFromGenesisStates(
authGS,
NewPricefeedGenStateMulti(),
NewCDPGenStateHighDebtLimit(),
)
suite.ctx = ctx
suite.app = tApp
suite.keeper = tApp.GetCDPKeeper()
suite.pricefeedKeeper = tApp.GetPriceFeedKeeper()
// Set up markets
oracle := addrs[9]
marketParams := pftypes.Params{
Markets: pftypes.Markets{
pftypes.Market{MarketID: "xrp-usd", BaseAsset: "xrp", QuoteAsset: "usd", Oracles: []sdk.AccAddress{oracle}, Active: true},
pftypes.Market{MarketID: "btc-usd", BaseAsset: "btc", QuoteAsset: "usd", Oracles: []sdk.AccAddress{oracle}, Active: true},
},
}
suite.pricefeedKeeper.SetParams(ctx, marketParams)
// Set collateral prices for use in collateralization calculations
_, err := suite.pricefeedKeeper.SetPrice(
ctx, oracle, "xrp-usd",
sdk.MustNewDecFromStr("0.75"),
time.Now().Add(1*time.Hour))
suite.Nil(err)
_, err = suite.pricefeedKeeper.SetPrice(
ctx, oracle, "btc-usd",
sdk.MustNewDecFromStr("5000"),
time.Now().Add(1*time.Hour))
suite.Nil(err)
for j := 0; j < 100; j++ {
collateral := "xrp"
amount := simulation.RandIntBetween(rand.New(rand.NewSource(int64(j))), 2500000000, 9000000000)
debt := simulation.RandIntBetween(rand.New(rand.NewSource(int64(j))), 50000000, 250000000)
if j%2 == 0 {
collateral = "btc"
amount = simulation.RandIntBetween(rand.New(rand.NewSource(int64(j))), 500000000, 5000000000)
debt = simulation.RandIntBetween(rand.New(rand.NewSource(int64(j))), 1000000000, 25000000000)
}
err = suite.keeper.AddCdp(suite.ctx, addrs[j], c(collateral, int64(amount)), c("usdx", int64(debt)), collateral+"-a")
suite.NoError(err)
c, f := suite.keeper.GetCDP(suite.ctx, collateral+"-a", uint64(j+1))
suite.True(f)
cdps[j] = c
aCDP := suite.keeper.LoadAugmentedCDP(suite.ctx, c)
augmentedCDPs[j] = aCDP
}
suite.cdps = cdps
suite.augmentedCDPs = augmentedCDPs
suite.querier = keeper.NewQuerier(suite.keeper)
suite.addrs = addrs
}
func (suite *QuerierTestSuite) TestQueryCdp() {
ctx := suite.ctx.WithIsCheckTx(false)
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdp}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpParams(suite.cdps[0].Owner, suite.cdps[0].Type)),
}
bz, err := suite.querier(ctx, []string{types.QueryGetCdp}, query)
suite.Nil(err)
suite.NotNil(bz)
var c types.AugmentedCDP
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &c))
suite.Equal(suite.augmentedCDPs[0], c)
query = abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdp}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpParams(suite.cdps[0].Owner, "lol-a")),
}
_, err = suite.querier(ctx, []string{types.QueryGetCdp}, query)
suite.Error(err)
query = abci.RequestQuery{
Path: strings.Join([]string{custom, "nonsense"}, "/"),
Data: []byte("nonsense"),
}
_, err = suite.querier(ctx, []string{query.Path}, query)
suite.Error(err)
_, err = suite.querier(ctx, []string{types.QueryGetCdp}, query)
suite.Error(err)
query = abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdp}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpParams(suite.cdps[0].Owner, "xrp-a")),
}
_, err = suite.querier(ctx, []string{types.QueryGetCdp}, query)
suite.Error(err)
}
func (suite *QuerierTestSuite) TestQueryCdpsByCollateralType() {
ctx := suite.ctx.WithIsCheckTx(false)
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdpsByCollateralType}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpsByCollateralTypeParams(suite.cdps[0].Type)),
}
bz, err := suite.querier(ctx, []string{types.QueryGetCdpsByCollateralType}, query)
suite.Nil(err)
suite.NotNil(bz)
var c types.AugmentedCDPs
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &c))
suite.Equal(50, len(c))
query = abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdpsByCollateralType}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpsByCollateralTypeParams("lol-a")),
}
_, err = suite.querier(ctx, []string{types.QueryGetCdpsByCollateralType}, query)
suite.Error(err)
}
func (suite *QuerierTestSuite) TestQueryCdpsByRatio() {
ratioCountBtc := 0
ratioCountXrp := 0
xrpRatio := d("2.0")
btcRatio := d("2500")
expectedXrpIds := []int{}
expectedBtcIds := []int{}
for _, cdp := range suite.cdps {
absoluteRatio := suite.keeper.CalculateCollateralToDebtRatio(suite.ctx, cdp.Collateral, cdp.Type, cdp.Principal)
collateralizationRatio, err := suite.keeper.CalculateCollateralizationRatioFromAbsoluteRatio(suite.ctx, cdp.Type, absoluteRatio, "liquidation")
suite.Nil(err)
if cdp.Collateral.Denom == "xrp" {
if collateralizationRatio.LT(xrpRatio) {
ratioCountXrp += 1
expectedXrpIds = append(expectedXrpIds, int(cdp.ID))
}
} else {
if collateralizationRatio.LT(btcRatio) {
ratioCountBtc += 1
expectedBtcIds = append(expectedBtcIds, int(cdp.ID))
}
}
}
ctx := suite.ctx.WithIsCheckTx(false)
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdpsByCollateralization}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpsByRatioParams("xrp-a", xrpRatio)),
}
bz, err := suite.querier(ctx, []string{types.QueryGetCdpsByCollateralization}, query)
suite.Nil(err)
suite.NotNil(bz)
var c types.AugmentedCDPs
actualXrpIds := []int{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &c))
for _, k := range c {
actualXrpIds = append(actualXrpIds, int(k.ID))
}
sort.Ints(actualXrpIds)
suite.Equal(expectedXrpIds, actualXrpIds)
query = abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdpsByCollateralization}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpsByRatioParams("btc-a", btcRatio)),
}
bz, err = suite.querier(ctx, []string{types.QueryGetCdpsByCollateralization}, query)
suite.Nil(err)
suite.NotNil(bz)
c = types.AugmentedCDPs{}
actualBtcIds := []int{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &c))
for _, k := range c {
actualBtcIds = append(actualBtcIds, int(k.ID))
}
sort.Ints(actualBtcIds)
suite.Equal(expectedBtcIds, actualBtcIds)
query = abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdpsByCollateralization}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpsByRatioParams("xrp-a", d("0.003"))),
}
bz, err = suite.querier(ctx, []string{types.QueryGetCdpsByCollateralization}, query)
suite.Nil(err)
suite.NotNil(bz)
c = types.AugmentedCDPs{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &c))
suite.Equal(0, len(c))
}
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))
cdpGS := NewCDPGenStateHighDebtLimit()
gs := types.GenesisState{}
types.ModuleCdc.UnmarshalJSON(cdpGS["cdp"], &gs)
suite.Equal(gs.Params, p)
}
func (suite *QuerierTestSuite) TestQueryDeposits() {
ctx := suite.ctx.WithIsCheckTx(false)
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdpDeposits}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(types.NewQueryCdpDeposits(suite.cdps[0].Owner, suite.cdps[0].Type)),
}
bz, err := suite.querier(ctx, []string{types.QueryGetCdpDeposits}, query)
suite.Nil(err)
suite.NotNil(bz)
deposits := suite.keeper.GetDeposits(ctx, suite.cdps[0].ID)
var d types.Deposits
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &d))
suite.Equal(deposits, d)
}
func (suite *QuerierTestSuite) TestQueryAccounts() {
bz, err := suite.querier(suite.ctx, []string{types.QueryGetAccounts}, abci.RequestQuery{})
suite.Require().NoError(err)
suite.Require().NotNil(bz)
var accounts []supply.ModuleAccount
suite.Require().Nil(supply.ModuleCdc.UnmarshalJSON(bz, &accounts))
suite.Require().Equal(2, len(accounts))
findByName := func(name string) bool {
for _, account := range accounts {
if account.GetName() == name {
return true
}
}
return false
}
suite.Require().True(findByName("cdp"))
suite.Require().True(findByName("liquidator"))
}
func (suite *QuerierTestSuite) TestFindIntersection() {
a := types.CDPs{suite.cdps[0], suite.cdps[1], suite.cdps[2], suite.cdps[3], suite.cdps[4]}
b := types.CDPs{suite.cdps[3], suite.cdps[4], suite.cdps[5], suite.cdps[6], suite.cdps[7]}
expectedIntersection1 := types.CDPs{suite.cdps[3], suite.cdps[4]}
intersection1 := keeper.FindIntersection(a, b)
suite.Require().Equal(intersection1, expectedIntersection1)
c := types.CDPs{suite.cdps[0], suite.cdps[1], suite.cdps[2], suite.cdps[3], suite.cdps[4]}
d := types.CDPs{suite.cdps[5], suite.cdps[6], suite.cdps[7], suite.cdps[8], suite.cdps[9]}
expectedIntersection2 := types.CDPs{}
intersection2 := keeper.FindIntersection(c, d)
suite.Require().Equal(intersection2, expectedIntersection2)
e := types.CDPs{suite.cdps[0]}
f := types.CDPs{}
expectedIntersection3 := types.CDPs{}
intersection3 := keeper.FindIntersection(e, f)
suite.Require().Equal(intersection3, expectedIntersection3)
}
func (suite *QuerierTestSuite) TestFilterCDPs() {
paramsType := types.NewQueryCdpsParams(1, 100, "btc-a", sdk.AccAddress{}, 0, sdk.ZeroDec())
filteredCDPs1 := keeper.FilterCDPs(suite.ctx, suite.keeper, paramsType)
suite.Require().Equal(len(filteredCDPs1), 50)
paramsOwner := types.NewQueryCdpsParams(1, 100, "", suite.cdps[10].Owner, 0, sdk.ZeroDec())
filteredCDPs2 := keeper.FilterCDPs(suite.ctx, suite.keeper, paramsOwner)
suite.Require().Equal(len(filteredCDPs2), 1)
suite.Require().Equal(filteredCDPs2[0].Owner, suite.cdps[10].Owner)
paramsID := types.NewQueryCdpsParams(1, 100, "", sdk.AccAddress{}, 68, sdk.ZeroDec())
filteredCDPs3 := keeper.FilterCDPs(suite.ctx, suite.keeper, paramsID)
suite.Require().Equal(len(filteredCDPs3), 1)
suite.Require().Equal(filteredCDPs3[0].ID, suite.cdps[68-1].ID)
ratioCountBtc := 0
btcRatio := d("2500")
for _, cdp := range suite.cdps {
if cdp.Type == "btc-a" {
absoluteRatio := suite.keeper.CalculateCollateralToDebtRatio(suite.ctx, cdp.Collateral, cdp.Type, cdp.Principal)
collateralizationRatio, _ := suite.keeper.CalculateCollateralizationRatioFromAbsoluteRatio(suite.ctx, cdp.Type, absoluteRatio, "liquidation")
if collateralizationRatio.LT(btcRatio) {
ratioCountBtc += 1
}
}
}
paramsTypeAndRatio := types.NewQueryCdpsParams(1, 100, "btc-a", sdk.AccAddress{}, 0, sdk.NewDec(2500))
filteredCDPs4 := keeper.FilterCDPs(suite.ctx, suite.keeper, paramsTypeAndRatio)
suite.Require().Equal(len(filteredCDPs4), ratioCountBtc)
}
func (suite *QuerierTestSuite) TestQueryCdps() {
ctx := suite.ctx.WithIsCheckTx(false)
params := types.NewQueryCdpsParams(1, 100, "btc-a", sdk.AccAddress{}, 0, sdk.ZeroDec())
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetCdps}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(params),
}
bz, err := suite.querier(ctx, []string{types.QueryGetCdps}, query)
suite.Nil(err)
suite.NotNil(bz)
output := types.AugmentedCDPs{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &output))
suite.Equal(50, len(output))
}
func (suite *QuerierTestSuite) TestQueryTotalPrincipal() {
ctx := suite.ctx.WithIsCheckTx(false)
params := types.NewQueryGetTotalPrincipalParams("btc-a")
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetTotalPrincipal}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(params),
}
bz, err := suite.querier(ctx, []string{types.QueryGetTotalPrincipal}, query)
suite.Nil(err)
suite.NotNil(bz)
output := []types.TotalCDPPrincipal{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &output))
fmt.Printf("%s", output)
suite.Equal(1, len(output))
suite.Equal("btc-a", output[0].CollateralType)
}
func (suite *QuerierTestSuite) TestQueryTotalPrincipalAll() {
ctx := suite.ctx.WithIsCheckTx(false)
params := types.NewQueryGetTotalPrincipalParams("")
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetTotalPrincipal}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(params),
}
bz, err := suite.querier(ctx, []string{types.QueryGetTotalPrincipal}, query)
suite.Nil(err)
suite.NotNil(bz)
output := []types.TotalCDPPrincipal{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &output))
var outputTypes []string
for _, c := range output {
outputTypes = append(outputTypes, c.CollateralType)
}
suite.Greater(len(output), 0)
suite.Subset(outputTypes, []string{"btc-a", "xrp-a"})
}
func (suite *QuerierTestSuite) TestQueryTotalCollateral() {
ctx := suite.ctx.WithIsCheckTx(false)
params := types.NewQueryGetTotalCollateralParams("btc-a")
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetTotalCollateral}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(params),
}
bz, err := suite.querier(ctx, []string{types.QueryGetTotalCollateral}, query)
suite.Nil(err)
suite.NotNil(bz)
output := []types.TotalCDPCollateral{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &output))
fmt.Printf("%s", output)
suite.Equal(1, len(output))
suite.Equal("btc-a", output[0].CollateralType)
}
func (suite *QuerierTestSuite) TestQueryTotalCollateralAll() {
ctx := suite.ctx.WithIsCheckTx(false)
params := types.NewQueryGetTotalCollateralParams("")
query := abci.RequestQuery{
Path: strings.Join([]string{custom, types.QuerierRoute, types.QueryGetTotalCollateral}, "/"),
Data: types.ModuleCdc.MustMarshalJSON(params),
}
bz, err := suite.querier(ctx, []string{types.QueryGetTotalCollateral}, query)
suite.Nil(err)
suite.NotNil(bz)
output := []types.TotalCDPCollateral{}
suite.Nil(types.ModuleCdc.UnmarshalJSON(bz, &output))
var outputTypes []string
for _, c := range output {
outputTypes = append(outputTypes, c.CollateralType)
}
suite.Greater(len(output), 0)
suite.Subset(outputTypes, []string{"btc-a", "xrp-a"})
}
func TestQuerierTestSuite(t *testing.T) {
suite.Run(t, new(QuerierTestSuite))
}