Mukan Erkin Törük
abb1ff956e
Some checks are pending
Build SimApp / build (amd64) (push) Waiting to run
Build SimApp / build (arm64) (push) Waiting to run
CodeQL / Analyze (push) Waiting to run
Build & Push / build (push) Waiting to run
Run Gosec / Gosec (push) Waiting to run
Lint / golangci-lint (push) Waiting to run
Checks dependencies and mocks generation / Check go mod tidy (push) Waiting to run
Checks dependencies and mocks generation / Check up to date mocks (push) Waiting to run
System Tests / setup (push) Waiting to run
System Tests / test-system (push) Blocked by required conditions
System Tests / test-system-legacy (push) Blocked by required conditions
Tests / Code Coverage / split-test-files (push) Waiting to run
Tests / Code Coverage / tests (00) (push) Blocked by required conditions
Tests / Code Coverage / tests (01) (push) Blocked by required conditions
Tests / Code Coverage / tests (02) (push) Blocked by required conditions
Tests / Code Coverage / tests (03) (push) Blocked by required conditions
Tests / Code Coverage / test-integration (push) Waiting to run
Tests / Code Coverage / test-e2e (push) Waiting to run
Tests / Code Coverage / repo-analysis (push) Blocked by required conditions
Tests / Code Coverage / test-sim-nondeterminism (push) Waiting to run
Tests / Code Coverage / test-clientv2 (push) Waiting to run
Tests / Code Coverage / test-core (push) Waiting to run
Tests / Code Coverage / test-depinject (push) Waiting to run
Tests / Code Coverage / test-errors (push) Waiting to run
Tests / Code Coverage / test-math (push) Waiting to run
Tests / Code Coverage / test-schema (push) Waiting to run
Tests / Code Coverage / test-collections (push) Waiting to run
Tests / Code Coverage / test-cosmovisor (push) Waiting to run
Tests / Code Coverage / test-confix (push) Waiting to run
Tests / Code Coverage / test-store (push) Waiting to run
Tests / Code Coverage / test-log (push) Waiting to run
Tests / Code Coverage / test-x-tx (push) Waiting to run
Tests / Code Coverage / test-x-nft (push) Waiting to run
Tests / Code Coverage / test-x-circuit (push) Waiting to run
Tests / Code Coverage / test-x-feegrant (push) Waiting to run
Tests / Code Coverage / test-x-evidence (push) Waiting to run
Tests / Code Coverage / test-x-upgrade (push) Waiting to run
Tests / Code Coverage / test-tools-benchmark (push) Waiting to run
913 lines
23 KiB
Go
913 lines
23 KiB
Go
package keeper_test
|
|
|
|
import (
|
|
gocontext "context"
|
|
"fmt"
|
|
"time"
|
|
|
|
"git.cw.tr/mukan-network/mukan-sdk/testutil/testdata"
|
|
sdk "git.cw.tr/mukan-network/mukan-sdk/types"
|
|
"git.cw.tr/mukan-network/mukan-sdk/types/query"
|
|
authtypes "git.cw.tr/mukan-network/mukan-sdk/x/auth/types"
|
|
vestingtypes "git.cw.tr/mukan-network/mukan-sdk/x/auth/vesting/types"
|
|
"git.cw.tr/mukan-network/mukan-sdk/x/bank/testutil"
|
|
"git.cw.tr/mukan-network/mukan-sdk/x/bank/types"
|
|
minttypes "git.cw.tr/mukan-network/mukan-sdk/x/mint/types"
|
|
)
|
|
|
|
func (suite *KeeperTestSuite) TestQueryBalance() {
|
|
ctx, queryClient := suite.ctx, suite.queryClient
|
|
_, _, addr := testdata.KeyTestPubAddr()
|
|
|
|
origCoins := sdk.NewCoins(newBarCoin(30))
|
|
suite.mockFundAccount(addr)
|
|
suite.Require().NoError(testutil.FundAccount(ctx, suite.bankKeeper, addr, origCoins))
|
|
|
|
testCases := []struct {
|
|
name string
|
|
req *types.QueryBalanceRequest
|
|
expectErrMsg string
|
|
postFn func(res *types.QueryBalanceResponse)
|
|
}{
|
|
{
|
|
"empty request",
|
|
&types.QueryBalanceRequest{},
|
|
"invalid denom",
|
|
nil,
|
|
},
|
|
{
|
|
"invalid denom",
|
|
types.NewQueryBalanceRequest(addr, "0000"),
|
|
"invalid denom",
|
|
nil,
|
|
},
|
|
{
|
|
"empty address",
|
|
types.NewQueryBalanceRequest(sdk.AccAddress{}, barDenom),
|
|
"empty address string is not allowed",
|
|
nil,
|
|
},
|
|
{
|
|
"invalid address",
|
|
&types.QueryBalanceRequest{Address: "foo", Denom: barDenom},
|
|
"invalid address",
|
|
nil,
|
|
},
|
|
{
|
|
"query missing denom",
|
|
&types.QueryBalanceRequest{Address: addr.String()},
|
|
"invalid denom",
|
|
nil,
|
|
},
|
|
{
|
|
"valid query empty result",
|
|
types.NewQueryBalanceRequest(addr, fooDenom),
|
|
"",
|
|
func(res *types.QueryBalanceResponse) {
|
|
suite.True(res.Balance.IsZero())
|
|
},
|
|
},
|
|
{
|
|
"valid query",
|
|
types.NewQueryBalanceRequest(addr, barDenom),
|
|
"",
|
|
func(res *types.QueryBalanceResponse) {
|
|
suite.True(res.Balance.Equal(newBarCoin(30)))
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(tc.name, func() {
|
|
res, err := queryClient.Balance(gocontext.Background(), tc.req)
|
|
if tc.expectErrMsg == "" {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
} else {
|
|
suite.Require().ErrorContains(err, tc.expectErrMsg)
|
|
}
|
|
|
|
if tc.postFn != nil {
|
|
tc.postFn(res)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryAllBalances() {
|
|
ctx, queryClient := suite.ctx, suite.queryClient
|
|
_, _, addr := testdata.KeyTestPubAddr()
|
|
_, err := queryClient.AllBalances(gocontext.Background(), &types.QueryAllBalancesRequest{})
|
|
suite.Require().Error(err)
|
|
|
|
pageReq := &query.PageRequest{
|
|
Key: nil,
|
|
Limit: 1,
|
|
CountTotal: false,
|
|
}
|
|
req := types.NewQueryAllBalancesRequest(addr, pageReq, false)
|
|
res, err := queryClient.AllBalances(gocontext.Background(), req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.True(res.Balances.IsZero())
|
|
|
|
fooCoins := newFooCoin(50)
|
|
barCoins := newBarCoin(30)
|
|
ibcCoins := newIbcCoin(20)
|
|
|
|
origCoins := sdk.NewCoins(fooCoins, barCoins, ibcCoins)
|
|
|
|
suite.mockFundAccount(addr)
|
|
suite.Require().NoError(testutil.FundAccount(ctx, suite.bankKeeper, addr, origCoins))
|
|
|
|
addIBCMetadata(ctx, suite.bankKeeper)
|
|
|
|
res, err = queryClient.AllBalances(gocontext.Background(), req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Equal(res.Balances.Len(), 1)
|
|
suite.NotNil(res.Pagination.NextKey)
|
|
|
|
suite.T().Log("query second page with nextkey")
|
|
pageReq = &query.PageRequest{
|
|
Key: res.Pagination.NextKey,
|
|
Limit: 1,
|
|
CountTotal: true,
|
|
}
|
|
req = types.NewQueryAllBalancesRequest(addr, pageReq, false)
|
|
res, err = queryClient.AllBalances(gocontext.Background(), req)
|
|
suite.Require().NoError(err)
|
|
suite.Equal(res.Balances.Len(), 1)
|
|
suite.NotNil(res.Pagination.NextKey)
|
|
|
|
pageThree := res.Pagination.NextKey
|
|
|
|
suite.T().Log("query third page with nextkey")
|
|
pageReq = &query.PageRequest{
|
|
Key: pageThree,
|
|
Limit: 1,
|
|
CountTotal: true,
|
|
}
|
|
req = types.NewQueryAllBalancesRequest(addr, pageReq, false)
|
|
res, err = queryClient.AllBalances(gocontext.Background(), req)
|
|
suite.Require().NoError(err)
|
|
suite.Equal(res.Balances.Len(), 1)
|
|
suite.Equal(res.Balances[0].Denom, ibcCoins.Denom)
|
|
|
|
suite.T().Log("query third page with nextkey and resolve ibc denom")
|
|
pageReq = &query.PageRequest{
|
|
Key: pageThree,
|
|
Limit: 1,
|
|
CountTotal: true,
|
|
}
|
|
req = types.NewQueryAllBalancesRequest(addr, pageReq, true)
|
|
res, err = queryClient.AllBalances(gocontext.Background(), req)
|
|
suite.Require().NoError(err)
|
|
suite.Equal(res.Balances.Len(), 1)
|
|
suite.Equal(res.Balances[0].Denom, ibcPath+"/"+ibcBaseDenom)
|
|
suite.Nil(res.Pagination.NextKey)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSpendableBalances() {
|
|
_, _, addr := testdata.KeyTestPubAddr()
|
|
|
|
ctx := sdk.UnwrapSDKContext(suite.ctx)
|
|
ctx = ctx.WithBlockTime(time.Now())
|
|
queryClient := suite.mockQueryClient(ctx)
|
|
|
|
_, err := queryClient.SpendableBalances(ctx, &types.QuerySpendableBalancesRequest{})
|
|
suite.Require().Error(err)
|
|
|
|
pageReq := &query.PageRequest{
|
|
Key: nil,
|
|
Limit: 2,
|
|
CountTotal: false,
|
|
}
|
|
req := types.NewQuerySpendableBalancesRequest(addr, pageReq)
|
|
acc := authtypes.NewBaseAccountWithAddress(addr)
|
|
|
|
suite.mockSpendableCoins(ctx, acc)
|
|
res, err := queryClient.SpendableBalances(ctx, req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.True(res.Balances.IsZero())
|
|
|
|
fooCoins := newFooCoin(50)
|
|
barCoins := newBarCoin(30)
|
|
|
|
origCoins := sdk.NewCoins(fooCoins, barCoins)
|
|
vacc, err := vestingtypes.NewContinuousVestingAccount(
|
|
acc,
|
|
sdk.NewCoins(fooCoins),
|
|
ctx.BlockTime().Unix(),
|
|
ctx.BlockTime().Add(time.Hour).Unix(),
|
|
)
|
|
suite.Require().NoError(err)
|
|
|
|
suite.mockFundAccount(addr)
|
|
suite.Require().NoError(testutil.FundAccount(suite.ctx, suite.bankKeeper, addr, origCoins))
|
|
|
|
// move time forward for some tokens to vest
|
|
ctx = ctx.WithBlockTime(ctx.BlockTime().Add(30 * time.Minute))
|
|
queryClient = suite.mockQueryClient(ctx)
|
|
|
|
suite.mockSpendableCoins(ctx, vacc)
|
|
res, err = queryClient.SpendableBalances(ctx, req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Equal(2, res.Balances.Len())
|
|
suite.Nil(res.Pagination.NextKey)
|
|
suite.EqualValues(30, res.Balances[0].Amount.Int64())
|
|
suite.EqualValues(25, res.Balances[1].Amount.Int64())
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestSpendableBalanceByDenom() {
|
|
_, _, addr := testdata.KeyTestPubAddr()
|
|
|
|
ctx := sdk.UnwrapSDKContext(suite.ctx)
|
|
ctx = ctx.WithBlockTime(time.Now())
|
|
queryClient := suite.mockQueryClient(ctx)
|
|
|
|
_, err := queryClient.SpendableBalanceByDenom(ctx, &types.QuerySpendableBalanceByDenomRequest{})
|
|
suite.Require().Error(err)
|
|
|
|
req := types.NewQuerySpendableBalanceByDenomRequest(addr, fooDenom)
|
|
acc := authtypes.NewBaseAccountWithAddress(addr)
|
|
|
|
suite.mockSpendableCoins(ctx, acc)
|
|
res, err := queryClient.SpendableBalanceByDenom(ctx, req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.True(res.Balance.IsZero())
|
|
|
|
fooCoins := newFooCoin(100)
|
|
barCoins := newBarCoin(30)
|
|
|
|
origCoins := sdk.NewCoins(fooCoins, barCoins)
|
|
vacc, err := vestingtypes.NewContinuousVestingAccount(
|
|
acc,
|
|
sdk.NewCoins(fooCoins),
|
|
ctx.BlockTime().Unix(),
|
|
ctx.BlockTime().Add(time.Hour).Unix(),
|
|
)
|
|
suite.Require().NoError(err)
|
|
|
|
suite.mockFundAccount(addr)
|
|
suite.Require().NoError(testutil.FundAccount(suite.ctx, suite.bankKeeper, addr, origCoins))
|
|
|
|
// move time forward for half of the tokens to vest
|
|
ctx = ctx.WithBlockTime(ctx.BlockTime().Add(30 * time.Minute))
|
|
queryClient = suite.mockQueryClient(ctx)
|
|
|
|
// check fooCoins first, it has some vested and some vesting
|
|
suite.mockSpendableCoins(ctx, vacc)
|
|
res, err = queryClient.SpendableBalanceByDenom(ctx, req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.EqualValues(50, res.Balance.Amount.Int64())
|
|
|
|
// check barCoins, all of it is spendable
|
|
req.Denom = barDenom
|
|
suite.mockSpendableCoins(ctx, vacc)
|
|
res, err = queryClient.SpendableBalanceByDenom(ctx, req)
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.EqualValues(30, res.Balance.Amount.Int64())
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryTotalSupply() {
|
|
ctx, queryClient := suite.ctx, suite.queryClient
|
|
res, err := queryClient.TotalSupply(gocontext.Background(), &types.QueryTotalSupplyRequest{})
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
genesisSupply := res.Supply
|
|
testCoins := sdk.NewCoins(sdk.NewInt64Coin("test", 400000000))
|
|
|
|
suite.mockMintCoins(mintAcc)
|
|
suite.Require().NoError(suite.bankKeeper.MintCoins(ctx, minttypes.ModuleName, testCoins))
|
|
|
|
res, err = queryClient.TotalSupply(gocontext.Background(), &types.QueryTotalSupplyRequest{})
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
|
|
expectedTotalSupply := genesisSupply.Add(testCoins...)
|
|
suite.Require().Equal(1, len(res.Supply))
|
|
suite.Require().Equal(res.Supply, expectedTotalSupply)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryTotalSupplyOf() {
|
|
ctx, queryClient := suite.ctx, suite.queryClient
|
|
|
|
test1Supply := sdk.NewInt64Coin("test1", 4000000)
|
|
test2Supply := sdk.NewInt64Coin("test2", 700000000)
|
|
expectedTotalSupply := sdk.NewCoins(test1Supply, test2Supply)
|
|
|
|
suite.mockMintCoins(mintAcc)
|
|
suite.Require().NoError(suite.bankKeeper.MintCoins(ctx, minttypes.ModuleName, expectedTotalSupply))
|
|
|
|
_, err := queryClient.SupplyOf(gocontext.Background(), &types.QuerySupplyOfRequest{})
|
|
suite.Require().Error(err)
|
|
|
|
res, err := queryClient.SupplyOf(gocontext.Background(), &types.QuerySupplyOfRequest{Denom: test1Supply.Denom})
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Require().Equal(test1Supply, res.Amount)
|
|
|
|
// total supply bogus denom
|
|
res, err = queryClient.SupplyOf(gocontext.Background(), &types.QuerySupplyOfRequest{Denom: "bogus"})
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Require().Equal(sdk.NewInt64Coin("bogus", 0), res.Amount)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryParams() {
|
|
res, err := suite.queryClient.Params(gocontext.Background(), &types.QueryParamsRequest{})
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Require().Equal(suite.bankKeeper.GetParams(suite.ctx), res.GetParams())
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryDenomsMetadata() {
|
|
var (
|
|
req *types.QueryDenomsMetadataRequest
|
|
expMetadata = []types.Metadata(nil)
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{
|
|
"empty pagination",
|
|
func() {
|
|
req = &types.QueryDenomsMetadataRequest{}
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"success, no results",
|
|
func() {
|
|
req = &types.QueryDenomsMetadataRequest{
|
|
Pagination: &query.PageRequest{
|
|
Limit: 3,
|
|
CountTotal: true,
|
|
},
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
metadataAtom := types.Metadata{
|
|
Description: "The native staking token of the Cosmos Hub.",
|
|
DenomUnits: []*types.DenomUnit{
|
|
{
|
|
Denom: "uatom",
|
|
Exponent: 0,
|
|
Aliases: []string{"microatom"},
|
|
},
|
|
{
|
|
Denom: "atom",
|
|
Exponent: 6,
|
|
Aliases: []string{"ATOM"},
|
|
},
|
|
},
|
|
Base: "uatom",
|
|
Display: "atom",
|
|
}
|
|
|
|
metadataEth := types.Metadata{
|
|
Description: "Ethereum native token",
|
|
DenomUnits: []*types.DenomUnit{
|
|
{
|
|
Denom: "wei",
|
|
Exponent: 0,
|
|
},
|
|
{
|
|
Denom: "eth",
|
|
Exponent: 18,
|
|
Aliases: []string{"ETH", "ether"},
|
|
},
|
|
},
|
|
Base: "wei",
|
|
Display: "eth",
|
|
}
|
|
|
|
suite.bankKeeper.SetDenomMetaData(suite.ctx, metadataAtom)
|
|
suite.bankKeeper.SetDenomMetaData(suite.ctx, metadataEth)
|
|
expMetadata = []types.Metadata{metadataAtom, metadataEth}
|
|
req = &types.QueryDenomsMetadataRequest{
|
|
Pagination: &query.PageRequest{
|
|
Limit: 7,
|
|
CountTotal: true,
|
|
},
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := suite.ctx
|
|
|
|
res, err := suite.queryClient.DenomsMetadata(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Require().Equal(expMetadata, res.Metadatas)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryDenomMetadata() {
|
|
var (
|
|
req *types.QueryDenomMetadataRequest
|
|
expMetadata = types.Metadata{}
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{
|
|
"empty denom",
|
|
func() {
|
|
req = &types.QueryDenomMetadataRequest{}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"not found denom",
|
|
func() {
|
|
req = &types.QueryDenomMetadataRequest{
|
|
Denom: "foo",
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
expMetadata = types.Metadata{
|
|
Description: "The native staking token of the Cosmos Hub.",
|
|
DenomUnits: []*types.DenomUnit{
|
|
{
|
|
Denom: "uatom",
|
|
Exponent: 0,
|
|
Aliases: []string{"microatom"},
|
|
},
|
|
{
|
|
Denom: "atom",
|
|
Exponent: 6,
|
|
Aliases: []string{"ATOM"},
|
|
},
|
|
},
|
|
Base: "uatom",
|
|
Display: "atom",
|
|
}
|
|
|
|
suite.bankKeeper.SetDenomMetaData(suite.ctx, expMetadata)
|
|
req = &types.QueryDenomMetadataRequest{
|
|
Denom: expMetadata.Base,
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := suite.ctx
|
|
|
|
res, err := suite.queryClient.DenomMetadata(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Require().Equal(expMetadata, res.Metadata)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQueryDenomMetadataByQueryStringRequest() {
|
|
var (
|
|
req *types.QueryDenomMetadataByQueryStringRequest
|
|
expMetadata = types.Metadata{}
|
|
)
|
|
|
|
testCases := []struct {
|
|
msg string
|
|
malleate func()
|
|
expPass bool
|
|
}{
|
|
{
|
|
"empty denom",
|
|
func() {
|
|
req = &types.QueryDenomMetadataByQueryStringRequest{}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"not found denom",
|
|
func() {
|
|
req = &types.QueryDenomMetadataByQueryStringRequest{
|
|
Denom: "foo",
|
|
}
|
|
},
|
|
false,
|
|
},
|
|
{
|
|
"success",
|
|
func() {
|
|
expMetadata = types.Metadata{
|
|
Description: "The native staking token of the Cosmos Hub.",
|
|
DenomUnits: []*types.DenomUnit{
|
|
{
|
|
Denom: "uatom",
|
|
Exponent: 0,
|
|
Aliases: []string{"microatom"},
|
|
},
|
|
{
|
|
Denom: "atom",
|
|
Exponent: 6,
|
|
Aliases: []string{"ATOM"},
|
|
},
|
|
},
|
|
Base: "uatom",
|
|
Display: "atom",
|
|
}
|
|
|
|
suite.bankKeeper.SetDenomMetaData(suite.ctx, expMetadata)
|
|
req = &types.QueryDenomMetadataByQueryStringRequest{
|
|
Denom: expMetadata.Base,
|
|
}
|
|
},
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
|
|
suite.SetupTest() // reset
|
|
|
|
tc.malleate()
|
|
ctx := suite.ctx
|
|
|
|
res, err := suite.queryClient.DenomMetadataByQueryString(ctx, req)
|
|
|
|
if tc.expPass {
|
|
suite.Require().NoError(err)
|
|
suite.Require().NotNil(res)
|
|
suite.Require().Equal(expMetadata, res.Metadata)
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGRPCDenomOwners() {
|
|
ctx := suite.ctx
|
|
|
|
keeper := suite.bankKeeper
|
|
|
|
suite.mockMintCoins(mintAcc)
|
|
suite.Require().NoError(keeper.MintCoins(ctx, minttypes.ModuleName, initCoins))
|
|
|
|
for i := range 10 {
|
|
addr := sdk.AccAddress(fmt.Sprintf("account-%d", i))
|
|
|
|
bal := sdk.NewCoins(sdk.NewCoin(
|
|
sdk.DefaultBondDenom,
|
|
sdk.TokensFromConsensusPower(initialPower/10, sdk.DefaultPowerReduction),
|
|
))
|
|
suite.mockSendCoinsFromModuleToAccount(mintAcc, addr)
|
|
suite.Require().NoError(keeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, addr, bal))
|
|
}
|
|
|
|
testCases := map[string]struct {
|
|
req *types.QueryDenomOwnersRequest
|
|
expPass bool
|
|
numAddrs int
|
|
hasNext bool
|
|
total uint64
|
|
}{
|
|
"empty request": {
|
|
req: &types.QueryDenomOwnersRequest{},
|
|
expPass: false,
|
|
},
|
|
"invalid denom": {
|
|
req: &types.QueryDenomOwnersRequest{
|
|
Denom: "foo",
|
|
},
|
|
expPass: true,
|
|
numAddrs: 0,
|
|
hasNext: false,
|
|
total: 0,
|
|
},
|
|
"valid request - page 1": {
|
|
req: &types.QueryDenomOwnersRequest{
|
|
Denom: sdk.DefaultBondDenom,
|
|
Pagination: &query.PageRequest{
|
|
Limit: 6,
|
|
CountTotal: true,
|
|
},
|
|
},
|
|
expPass: true,
|
|
numAddrs: 6,
|
|
hasNext: true,
|
|
total: 10,
|
|
},
|
|
"valid request - page 2": {
|
|
req: &types.QueryDenomOwnersRequest{
|
|
Denom: sdk.DefaultBondDenom,
|
|
Pagination: &query.PageRequest{
|
|
Offset: 6,
|
|
Limit: 10,
|
|
CountTotal: true,
|
|
},
|
|
},
|
|
expPass: true,
|
|
numAddrs: 4,
|
|
hasNext: false,
|
|
total: 10,
|
|
},
|
|
}
|
|
|
|
for name, tc := range testCases {
|
|
suite.Run(name, func() {
|
|
resp, err := suite.queryClient.DenomOwners(gocontext.Background(), tc.req)
|
|
if tc.expPass {
|
|
suite.NoError(err)
|
|
suite.NotNil(resp)
|
|
suite.Len(resp.DenomOwners, tc.numAddrs)
|
|
suite.Equal(tc.total, resp.Pagination.Total)
|
|
|
|
if tc.hasNext {
|
|
suite.NotNil(resp.Pagination.NextKey)
|
|
} else {
|
|
suite.Nil(resp.Pagination.NextKey)
|
|
}
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
|
|
suite.Require().True(true)
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestQuerySendEnabled() {
|
|
ctx, bankKeeper := suite.ctx, suite.bankKeeper
|
|
|
|
bankKeeper.SetSendEnabled(ctx, "falsestcoin", false)
|
|
bankKeeper.SetSendEnabled(ctx, "truestcoin", true)
|
|
|
|
tests := []struct {
|
|
name string
|
|
req *types.QuerySendEnabledRequest
|
|
exp *types.QuerySendEnabledResponse
|
|
}{
|
|
{
|
|
name: "nil denoms list",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "falsestcoin", Enabled: false},
|
|
{Denom: "truestcoin", Enabled: true},
|
|
},
|
|
Pagination: &query.PageResponse{
|
|
NextKey: nil,
|
|
Total: 2,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "empty denoms list",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "falsestcoin", Enabled: false},
|
|
{Denom: "truestcoin", Enabled: true},
|
|
},
|
|
Pagination: &query.PageResponse{
|
|
NextKey: nil,
|
|
Total: 2,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "limit 1",
|
|
req: &types.QuerySendEnabledRequest{
|
|
Pagination: &query.PageRequest{
|
|
Limit: 1,
|
|
CountTotal: true,
|
|
},
|
|
},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "falsestcoin", Enabled: false},
|
|
},
|
|
Pagination: &query.PageResponse{
|
|
NextKey: []byte("truestcoin"),
|
|
Total: 2,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "just truestcoin",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{"truestcoin"}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "truestcoin", Enabled: true},
|
|
},
|
|
Pagination: nil,
|
|
},
|
|
},
|
|
{
|
|
name: "just falsestcoin",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{"falsestcoin"}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "falsestcoin", Enabled: false},
|
|
},
|
|
Pagination: nil,
|
|
},
|
|
},
|
|
{
|
|
name: "just an unknown coin",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{"unknowniercoin"}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: nil,
|
|
Pagination: nil,
|
|
},
|
|
},
|
|
{
|
|
name: "both truestcoin falsestcoin",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{"truestcoin", "falsestcoin"}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "truestcoin", Enabled: true},
|
|
{Denom: "falsestcoin", Enabled: false},
|
|
},
|
|
Pagination: nil,
|
|
},
|
|
},
|
|
{
|
|
name: "both truestcoin falsestcoin and an unknown",
|
|
req: &types.QuerySendEnabledRequest{Denoms: []string{"truestcoin", "falsestcoin", "unknownestcoin"}},
|
|
exp: &types.QuerySendEnabledResponse{
|
|
SendEnabled: []*types.SendEnabled{
|
|
{Denom: "truestcoin", Enabled: true},
|
|
{Denom: "falsestcoin", Enabled: false},
|
|
},
|
|
Pagination: nil,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
suite.Run(tc.name, func() {
|
|
resp, err := suite.queryClient.SendEnabled(gocontext.Background(), tc.req)
|
|
suite.Require().NoError(err)
|
|
if !suite.Assert().Equal(tc.exp, resp) {
|
|
if !suite.Assert().Len(resp.SendEnabled, len(tc.exp.SendEnabled)) {
|
|
for i := range tc.exp.SendEnabled {
|
|
suite.Assert().Equal(tc.exp.SendEnabled[i].Denom, resp.SendEnabled[i].Denom, fmt.Sprintf("SendEnabled[%d].Denom", i))
|
|
suite.Assert().Equal(tc.exp.SendEnabled[i].Enabled, resp.SendEnabled[i].Enabled, fmt.Sprintf("SendEnabled[%d].Enabled", i))
|
|
}
|
|
}
|
|
if !suite.Assert().Equal(tc.exp.Pagination, resp.Pagination, "Pagination") && tc.exp.Pagination != nil && resp.Pagination != nil {
|
|
suite.Assert().Equal(tc.exp.Pagination.NextKey, resp.Pagination.NextKey, "Pagination.NextKey")
|
|
suite.Assert().Equal(tc.exp.Pagination.Total, resp.Pagination.Total, "Pagination.Total")
|
|
}
|
|
}
|
|
suite.Require().Equal(tc.exp, resp)
|
|
})
|
|
}
|
|
}
|
|
|
|
func (suite *KeeperTestSuite) TestGRPCDenomOwnersByQuery() {
|
|
ctx := suite.ctx
|
|
|
|
keeper := suite.bankKeeper
|
|
|
|
suite.mockMintCoins(mintAcc)
|
|
suite.Require().NoError(keeper.MintCoins(ctx, minttypes.ModuleName, initCoins))
|
|
denom := "ibc/123123213123"
|
|
newCoins := sdk.NewCoins(sdk.NewCoin(denom, initTokens))
|
|
suite.mockMintCoins(mintAcc)
|
|
suite.Require().NoError(keeper.MintCoins(ctx, minttypes.ModuleName, newCoins))
|
|
|
|
for i := range 10 {
|
|
addr := sdk.AccAddress(fmt.Sprintf("account-%d", i))
|
|
|
|
bal := sdk.NewCoins(sdk.NewCoin(
|
|
sdk.DefaultBondDenom,
|
|
sdk.TokensFromConsensusPower(initialPower/10, sdk.DefaultPowerReduction),
|
|
))
|
|
suite.mockSendCoinsFromModuleToAccount(mintAcc, addr)
|
|
suite.Require().NoError(keeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, addr, bal))
|
|
}
|
|
|
|
testCases := map[string]struct {
|
|
req *types.QueryDenomOwnersByQueryRequest
|
|
expPass bool
|
|
numAddrs int
|
|
hasNext bool
|
|
total uint64
|
|
}{
|
|
"empty request": {
|
|
req: &types.QueryDenomOwnersByQueryRequest{},
|
|
expPass: false,
|
|
},
|
|
"invalid denom": {
|
|
req: &types.QueryDenomOwnersByQueryRequest{
|
|
Denom: "foo",
|
|
},
|
|
expPass: true,
|
|
numAddrs: 0,
|
|
hasNext: false,
|
|
total: 0,
|
|
},
|
|
"valid request - page 1": {
|
|
req: &types.QueryDenomOwnersByQueryRequest{
|
|
Denom: sdk.DefaultBondDenom,
|
|
Pagination: &query.PageRequest{
|
|
Limit: 6,
|
|
CountTotal: true,
|
|
},
|
|
},
|
|
expPass: true,
|
|
numAddrs: 6,
|
|
hasNext: true,
|
|
total: 10,
|
|
},
|
|
"valid request - page 2": {
|
|
req: &types.QueryDenomOwnersByQueryRequest{
|
|
Denom: sdk.DefaultBondDenom,
|
|
Pagination: &query.PageRequest{
|
|
Offset: 6,
|
|
Limit: 10,
|
|
CountTotal: true,
|
|
},
|
|
},
|
|
expPass: true,
|
|
numAddrs: 4,
|
|
hasNext: false,
|
|
total: 10,
|
|
},
|
|
"valid request for query": {
|
|
req: &types.QueryDenomOwnersByQueryRequest{
|
|
Denom: denom,
|
|
Pagination: &query.PageRequest{
|
|
Limit: 6,
|
|
CountTotal: true,
|
|
},
|
|
},
|
|
expPass: true,
|
|
numAddrs: 1,
|
|
hasNext: false,
|
|
total: 1,
|
|
},
|
|
}
|
|
|
|
for name, tc := range testCases {
|
|
suite.Run(name, func() {
|
|
resp, err := suite.queryClient.DenomOwnersByQuery(gocontext.Background(), tc.req)
|
|
if tc.expPass {
|
|
suite.NoError(err)
|
|
suite.NotNil(resp)
|
|
suite.Len(resp.DenomOwners, tc.numAddrs)
|
|
suite.Equal(tc.total, resp.Pagination.Total)
|
|
|
|
if tc.hasNext {
|
|
suite.NotNil(resp.Pagination.NextKey)
|
|
} else {
|
|
suite.Nil(resp.Pagination.NextKey)
|
|
}
|
|
} else {
|
|
suite.Require().Error(err)
|
|
}
|
|
})
|
|
}
|
|
|
|
suite.Require().True(true)
|
|
}
|