LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

chore: Replace testify with gotest.tools in bank integration tests (#14477)

Browse Source 
Co-authored-by: atheeshp <59333759+atheeshp@users.noreply.github.com>
This commit is contained in:
Likhita Polavarapu 2023-01-11 20:46:28 +05:30 committed by GitHub
parent f7ead8cbd8
commit f590f290fc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 824 additions and 660 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

294
tests/integration/bank/keeper/deterministic_test.go
View File

@ -3,14 +3,15 @@ package keeper_test
import (
"testing"
"github.com/stretchr/testify/suite"
"github.com/stretchr/testify/require"
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
"gotest.tools/v3/assert"
"pgregory.net/rapid"
"github.com/cosmos/cosmos-sdk/baseapp"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
"github.com/cosmos/cosmos-sdk/testutil/configurator"
simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims"
"github.com/cosmos/cosmos-sdk/testutil/sims"
"github.com/cosmos/cosmos-sdk/testutil/testdata"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/bank/keeper"
@ -26,15 +27,6 @@ import (
_ "github.com/cosmos/cosmos-sdk/x/staking"
)
type DeterministicTestSuite struct {
suite.Suite
ctx sdk.Context
bankKeeper keeper.BaseKeeper
queryClient banktypes.QueryClient
}
var (
denomRegex = sdk.DefaultCoinDenomRegex()
addr1 = sdk.MustAccAddressFromBech32("cosmos139f7kncmglres2nf3h4hc4tade85ekfr8sulz5")
@ -58,14 +50,19 @@ var (
}
)
func TestDeterministicTestSuite(t *testing.T) {
suite.Run(t, new(DeterministicTestSuite))
type deterministicFixture struct {
ctx sdk.Context
bankKeeper keeper.BaseKeeper
queryClient banktypes.QueryClient
}
func (suite *DeterministicTestSuite) SetupTest() {
func initDeterministicFixture(t *testing.T) *deterministicFixture {
f := &deterministicFixture{}
var interfaceRegistry codectypes.InterfaceRegistry
app, err := simtestutil.Setup(
app, err := sims.Setup(
configurator.NewAppConfig(
configurator.AuthModule(),
configurator.TxModule(),
@ -74,63 +71,74 @@ func (suite *DeterministicTestSuite) SetupTest() {
configurator.BankModule(),
configurator.StakingModule(),
),
&suite.bankKeeper,
&f.bankKeeper,
&interfaceRegistry,
)
suite.Require().NoError(err)
assert.NilError(t, err)
ctx := app.BaseApp.NewContext(false, tmproto.Header{})
suite.ctx = ctx
f.ctx = ctx
queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry)
banktypes.RegisterQueryServer(queryHelper, suite.bankKeeper)
suite.queryClient = banktypes.NewQueryClient(queryHelper)
banktypes.RegisterQueryServer(queryHelper, f.bankKeeper)
f.queryClient = banktypes.NewQueryClient(queryHelper)
return f
}
func (suite *DeterministicTestSuite) fundAccount(addr sdk.AccAddress, coin ...sdk.Coin) {
err := banktestutil.FundAccount(suite.bankKeeper, suite.ctx, addr, sdk.NewCoins(coin...))
suite.Require().NoError(err)
func fundAccount(f *deterministicFixture, addr sdk.AccAddress, coin ...sdk.Coin) {
err := banktestutil.FundAccount(f.bankKeeper, f.ctx, addr, sdk.NewCoins(coin...))
assert.NilError(&testing.T{}, err)
}
func (suite *DeterministicTestSuite) getCoin(t *rapid.T) sdk.Coin {
func getCoin(rt *rapid.T) sdk.Coin {
return sdk.NewCoin(
rapid.StringMatching(denomRegex).Draw(t, "denom"),
sdk.NewInt(rapid.Int64Min(1).Draw(t, "amount")),
rapid.StringMatching(denomRegex).Draw(rt, "denom"),
sdk.NewInt(rapid.Int64Min(1).Draw(rt, "amount")),
)
}
func (suite *DeterministicTestSuite) TestGRPCQueryBalance() {
rapid.Check(suite.T(), func(t *rapid.T) {
addr := testdata.AddressGenerator(t).Draw(t, "address")
coin := suite.getCoin(t)
suite.fundAccount(addr, coin)
func TestGRPCQueryBalance(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
addr := testdata.AddressGenerator(rt).Draw(rt, "address")
coin := getCoin(rt)
fundAccount(f, addr, coin)
req := banktypes.NewQueryBalanceRequest(addr, coin.GetDenom())
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.Balance, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.Balance, 0, true)
})
suite.fundAccount(addr1, coin1)
fundAccount(f, addr1, coin1)
req := banktypes.NewQueryBalanceRequest(addr1, coin1.GetDenom())
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.Balance, 1087, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.Balance, 1087, false)
}
func (suite *DeterministicTestSuite) TestGRPCQueryAllBalances() {
rapid.Check(suite.T(), func(t *rapid.T) {
addr := testdata.AddressGenerator(t).Draw(t, "address")
numCoins := rapid.IntRange(1, 10).Draw(t, "num-count")
func TestGRPCQueryAllBalances(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
addr := testdata.AddressGenerator(rt).Draw(rt, "address")
numCoins := rapid.IntRange(1, 10).Draw(rt, "num-count")
coins := make(sdk.Coins, 0, numCoins)
for i := 0; i < numCoins; i++ {
coin := suite.getCoin(t)
coin := getCoin(rt)
// NewCoins sorts the denoms
coins = sdk.NewCoins(append(coins, coin)...)
}
suite.fundAccount(addr, coins...)
fundAccount(f, addr, coins...)
req := banktypes.NewQueryAllBalancesRequest(addr, testdata.PaginationGenerator(t, uint64(numCoins)).Draw(t, "pagination"))
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.AllBalances, 0, true)
req := banktypes.NewQueryAllBalancesRequest(addr, testdata.PaginationGenerator(rt, uint64(numCoins)).Draw(rt, "pagination"))
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.AllBalances, 0, true)
})
coins := sdk.NewCoins(
@ -138,14 +146,18 @@ func (suite *DeterministicTestSuite) TestGRPCQueryAllBalances() {
sdk.NewCoin("denom", sdk.NewInt(100)),
)
suite.fundAccount(addr1, coins...)
fundAccount(f, addr1, coins...)
req := banktypes.NewQueryAllBalancesRequest(addr1, nil)
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.AllBalances, 357, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.AllBalances, 357, false)
}
func (suite *DeterministicTestSuite) TestGRPCQuerySpendableBalances() {
rapid.Check(suite.T(), func(t *rapid.T) {
func TestGRPCQuerySpendableBalances(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(t *rapid.T) {
addr := testdata.AddressGenerator(t).Draw(t, "address")
numCoins := rapid.IntRange(1, 10).Draw(t, "num-count")
coins := make(sdk.Coins, 0, numCoins)
@ -160,11 +172,11 @@ func (suite *DeterministicTestSuite) TestGRPCQuerySpendableBalances() {
coins = sdk.NewCoins(append(coins, coin)...)
}
err := banktestutil.FundAccount(suite.bankKeeper, suite.ctx, addr, coins)
suite.Require().NoError(err)
err := banktestutil.FundAccount(f.bankKeeper, f.ctx, addr, coins)
assert.NilError(t, err)
req := banktypes.NewQuerySpendableBalancesRequest(addr, testdata.PaginationGenerator(t, uint64(numCoins)).Draw(t, "pagination"))
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.SpendableBalances, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.SpendableBalances, 0, true)
})
coins := sdk.NewCoins(
@ -172,91 +184,103 @@ func (suite *DeterministicTestSuite) TestGRPCQuerySpendableBalances() {
sdk.NewCoin("denom", sdk.NewInt(100)),
)
err := banktestutil.FundAccount(suite.bankKeeper, suite.ctx, addr1, coins)
suite.Require().NoError(err)
err := banktestutil.FundAccount(f.bankKeeper, f.ctx, addr1, coins)
assert.NilError(t, err)
req := banktypes.NewQuerySpendableBalancesRequest(addr1, nil)
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.SpendableBalances, 2032, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.SpendableBalances, 2032, false)
}
func (suite *DeterministicTestSuite) TestGRPCQueryTotalSupply() {
res, err := suite.queryClient.TotalSupply(suite.ctx, &banktypes.QueryTotalSupplyRequest{})
suite.Require().NoError(err)
func TestGRPCQueryTotalSupply(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
res, err := f.queryClient.TotalSupply(f.ctx, &banktypes.QueryTotalSupplyRequest{})
assert.NilError(t, err)
initialSupply := res.GetSupply()
rapid.Check(suite.T(), func(t *rapid.T) {
numCoins := rapid.IntRange(1, 3).Draw(t, "num-count")
rapid.Check(t, func(rt *rapid.T) {
numCoins := rapid.IntRange(1, 3).Draw(rt, "num-count")
coins := make(sdk.Coins, 0, numCoins)
for i := 0; i < numCoins; i++ {
coin := sdk.NewCoin(
rapid.StringMatching(denomRegex).Draw(t, "denom"),
sdk.NewInt(rapid.Int64Min(1).Draw(t, "amount")),
rapid.StringMatching(denomRegex).Draw(rt, "denom"),
sdk.NewInt(rapid.Int64Min(1).Draw(rt, "amount")),
)
coins = coins.Add(coin)
}
suite.Require().NoError(suite.bankKeeper.MintCoins(suite.ctx, minttypes.ModuleName, coins))
assert.NilError(t, f.bankKeeper.MintCoins(f.ctx, minttypes.ModuleName, coins))
initialSupply = initialSupply.Add(coins...)
req := &banktypes.QueryTotalSupplyRequest{
Pagination: testdata.PaginationGenerator(t, uint64(len(initialSupply))).Draw(t, "pagination"),
Pagination: testdata.PaginationGenerator(rt, uint64(len(initialSupply))).Draw(rt, "pagination"),
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.TotalSupply, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.TotalSupply, 0, true)
})
suite.SetupTest() // reset
f = initDeterministicFixture(t) // reset
coins := sdk.NewCoins(
sdk.NewCoin("foo", sdk.NewInt(10)),
sdk.NewCoin("bar", sdk.NewInt(100)),
)
suite.Require().NoError(suite.bankKeeper.MintCoins(suite.ctx, minttypes.ModuleName, coins))
assert.NilError(t, f.bankKeeper.MintCoins(f.ctx, minttypes.ModuleName, coins))
req := &banktypes.QueryTotalSupplyRequest{}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.TotalSupply, 243, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.TotalSupply, 243, false)
}
func (suite *DeterministicTestSuite) TestGRPCQueryTotalSupplyOf() {
rapid.Check(suite.T(), func(t *rapid.T) {
func TestGRPCQueryTotalSupplyOf(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
coin := sdk.NewCoin(
rapid.StringMatching(denomRegex).Draw(t, "denom"),
sdk.NewInt(rapid.Int64Min(1).Draw(t, "amount")),
rapid.StringMatching(denomRegex).Draw(rt, "denom"),
sdk.NewInt(rapid.Int64Min(1).Draw(rt, "amount")),
)
suite.Require().NoError(suite.bankKeeper.MintCoins(suite.ctx, minttypes.ModuleName, sdk.NewCoins(coin)))
assert.NilError(t, f.bankKeeper.MintCoins(f.ctx, minttypes.ModuleName, sdk.NewCoins(coin)))
req := &banktypes.QuerySupplyOfRequest{Denom: coin.GetDenom()}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.SupplyOf, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.SupplyOf, 0, true)
})
coin := sdk.NewCoin("bar", sdk.NewInt(100))
suite.Require().NoError(suite.bankKeeper.MintCoins(suite.ctx, minttypes.ModuleName, sdk.NewCoins(coin)))
assert.NilError(t, f.bankKeeper.MintCoins(f.ctx, minttypes.ModuleName, sdk.NewCoins(coin)))
req := &banktypes.QuerySupplyOfRequest{Denom: coin.GetDenom()}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.SupplyOf, 1021, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.SupplyOf, 1021, false)
}
func (suite *DeterministicTestSuite) TestGRPCQueryParams() {
rapid.Check(suite.T(), func(t *rapid.T) {
func TestGRPCQueryParams(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
enabledStatus := banktypes.SendEnabled{
Denom: rapid.StringMatching(denomRegex).Draw(t, "denom"),
Enabled: rapid.Bool().Draw(t, "status"),
Denom: rapid.StringMatching(denomRegex).Draw(rt, "denom"),
Enabled: rapid.Bool().Draw(rt, "status"),
}
params := banktypes.Params{
SendEnabled: []*banktypes.SendEnabled{&enabledStatus},
DefaultSendEnabled: rapid.Bool().Draw(t, "send"),
DefaultSendEnabled: rapid.Bool().Draw(rt, "send"),
}
suite.bankKeeper.SetParams(suite.ctx, params)
f.bankKeeper.SetParams(f.ctx, params)
req := &banktypes.QueryParamsRequest{}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.Params, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.Params, 0, true)
})
enabledStatus := banktypes.SendEnabled{
@ -269,13 +293,13 @@ func (suite *DeterministicTestSuite) TestGRPCQueryParams() {
DefaultSendEnabled: false,
}
suite.bankKeeper.SetParams(suite.ctx, params)
f.bankKeeper.SetParams(f.ctx, params)
req := &banktypes.QueryParamsRequest{}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.Params, 1003, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.Params, 1003, false)
}
func (suite *DeterministicTestSuite) createAndReturnMetadatas(t *rapid.T, count int) []banktypes.Metadata {
func createAndReturnMetadatas(t *rapid.T, count int) []banktypes.Metadata {
denomsMetadata := make([]banktypes.Metadata, 0, count)
for i := 0; i < count; i++ {
@ -310,67 +334,79 @@ func (suite *DeterministicTestSuite) createAndReturnMetadatas(t *rapid.T, count
return denomsMetadata
}
func (suite *DeterministicTestSuite) TestGRPCDenomsMetadata() {
rapid.Check(suite.T(), func(t *rapid.T) {
count := rapid.IntRange(1, 3).Draw(t, "count")
denomsMetadata := suite.createAndReturnMetadatas(t, count)
suite.Require().Len(denomsMetadata, count)
func TestGRPCDenomsMetadata(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
count := rapid.IntRange(1, 3).Draw(rt, "count")
denomsMetadata := createAndReturnMetadatas(rt, count)
assert.Assert(t, len(denomsMetadata) == count)
for i := 0; i < count; i++ {
suite.bankKeeper.SetDenomMetaData(suite.ctx, denomsMetadata[i])
f.bankKeeper.SetDenomMetaData(f.ctx, denomsMetadata[i])
}
req := &banktypes.QueryDenomsMetadataRequest{
Pagination: testdata.PaginationGenerator(t, uint64(count)).Draw(t, "pagination"),
Pagination: testdata.PaginationGenerator(rt, uint64(count)).Draw(rt, "pagination"),
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.DenomsMetadata, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.DenomsMetadata, 0, true)
})
suite.SetupTest() // reset
f = initDeterministicFixture(t) // reset
suite.bankKeeper.SetDenomMetaData(suite.ctx, metadataAtom)
f.bankKeeper.SetDenomMetaData(f.ctx, metadataAtom)
req := &banktypes.QueryDenomsMetadataRequest{}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.DenomsMetadata, 660, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.DenomsMetadata, 660, false)
}
func (suite *DeterministicTestSuite) TestGRPCDenomMetadata() {
rapid.Check(suite.T(), func(t *rapid.T) {
denomMetadata := suite.createAndReturnMetadatas(t, 1)
suite.Require().Len(denomMetadata, 1)
suite.bankKeeper.SetDenomMetaData(suite.ctx, denomMetadata[0])
func TestGRPCDenomMetadata(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
denomMetadata := createAndReturnMetadatas(rt, 1)
assert.Assert(t, len(denomMetadata) == 1)
f.bankKeeper.SetDenomMetaData(f.ctx, denomMetadata[0])
req := &banktypes.QueryDenomMetadataRequest{
Denom: denomMetadata[0].Base,
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.DenomMetadata, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.DenomMetadata, 0, true)
})
suite.bankKeeper.SetDenomMetaData(suite.ctx, metadataAtom)
f.bankKeeper.SetDenomMetaData(f.ctx, metadataAtom)
req := &banktypes.QueryDenomMetadataRequest{
Denom: metadataAtom.Base,
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.DenomMetadata, 1300, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.DenomMetadata, 1300, false)
}
func (suite *DeterministicTestSuite) TestGRPCSendEnabled() {
func TestGRPCSendEnabled(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
allDenoms := []string{}
rapid.Check(suite.T(), func(t *rapid.T) {
count := rapid.IntRange(0, 10).Draw(t, "count")
rapid.Check(t, func(rt *rapid.T) {
count := rapid.IntRange(0, 10).Draw(rt, "count")
denoms := make([]string, 0, count)
for i := 0; i < count; i++ {
coin := banktypes.SendEnabled{
Denom: rapid.StringMatching(denomRegex).Draw(t, "denom"),
Enabled: rapid.Bool().Draw(t, "enabled-status"),
Denom: rapid.StringMatching(denomRegex).Draw(rt, "denom"),
Enabled: rapid.Bool().Draw(rt, "enabled-status"),
}
suite.bankKeeper.SetSendEnabled(suite.ctx, coin.Denom, coin.Enabled)
f.bankKeeper.SetSendEnabled(f.ctx, coin.Denom, coin.Enabled)
denoms = append(denoms, coin.Denom)
}
@ -379,9 +415,9 @@ func (suite *DeterministicTestSuite) TestGRPCSendEnabled() {
req := &banktypes.QuerySendEnabledRequest{
Denoms: denoms,
// Pagination is only taken into account when `denoms` is an empty array
Pagination: testdata.PaginationGenerator(t, uint64(len(allDenoms))).Draw(t, "pagination"),
Pagination: testdata.PaginationGenerator(rt, uint64(len(allDenoms))).Draw(rt, "pagination"),
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.SendEnabled, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.SendEnabled, 0, true)
})
coin1 := banktypes.SendEnabled{
@ -393,37 +429,41 @@ func (suite *DeterministicTestSuite) TestGRPCSendEnabled() {
Enabled: true,
}
suite.bankKeeper.SetSendEnabled(suite.ctx, coin1.Denom, false)
suite.bankKeeper.SetSendEnabled(suite.ctx, coin2.Denom, true)
f.bankKeeper.SetSendEnabled(f.ctx, coin1.Denom, false)
f.bankKeeper.SetSendEnabled(f.ctx, coin2.Denom, true)
req := &banktypes.QuerySendEnabledRequest{
Denoms: []string{coin1.GetDenom(), coin2.GetDenom()},
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.SendEnabled, 4063, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.SendEnabled, 4063, false)
}
func (suite *DeterministicTestSuite) TestGRPCDenomOwners() {
rapid.Check(suite.T(), func(t *rapid.T) {
denom := rapid.StringMatching(denomRegex).Draw(t, "denom")
numAddr := rapid.IntRange(1, 10).Draw(t, "number-address")
func TestGRPCDenomOwners(t *testing.T) {
t.Parallel()
f := initDeterministicFixture(t)
tt := require.New(t)
rapid.Check(t, func(rt *rapid.T) {
denom := rapid.StringMatching(denomRegex).Draw(rt, "denom")
numAddr := rapid.IntRange(1, 10).Draw(rt, "number-address")
for i := 0; i < numAddr; i++ {
addr := testdata.AddressGenerator(t).Draw(t, "address")
addr := testdata.AddressGenerator(rt).Draw(rt, "address")
coin := sdk.NewCoin(
denom,
sdk.NewInt(rapid.Int64Min(1).Draw(t, "amount")),
sdk.NewInt(rapid.Int64Min(1).Draw(rt, "amount")),
)
err := banktestutil.FundAccount(suite.bankKeeper, suite.ctx, addr, sdk.NewCoins(coin))
suite.Require().NoError(err)
err := banktestutil.FundAccount(f.bankKeeper, f.ctx, addr, sdk.NewCoins(coin))
assert.NilError(t, err)
}
req := &banktypes.QueryDenomOwnersRequest{
Denom: denom,
Pagination: testdata.PaginationGenerator(t, uint64(numAddr)).Draw(t, "pagination"),
Pagination: testdata.PaginationGenerator(rt, uint64(numAddr)).Draw(rt, "pagination"),
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.DenomOwners, 0, true)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.DenomOwners, 0, true)
})
denomOwners := []*banktypes.DenomOwner{
@ -439,14 +479,14 @@ func (suite *DeterministicTestSuite) TestGRPCDenomOwners() {
for i := 0; i < len(denomOwners); i++ {
addr, err := sdk.AccAddressFromBech32(denomOwners[i].Address)
suite.Require().NoError(err)
assert.NilError(t, err)
err = banktestutil.FundAccount(suite.bankKeeper, suite.ctx, addr, sdk.NewCoins(coin1))
suite.Require().NoError(err)
err = banktestutil.FundAccount(f.bankKeeper, f.ctx, addr, sdk.NewCoins(coin1))
assert.NilError(t, err)
}
req := &banktypes.QueryDenomOwnersRequest{
Denom: coin1.GetDenom(),
}
testdata.DeterministicIterations(suite.ctx, suite.Require(), req, suite.queryClient.DenomOwners, 2525, false)
testdata.DeterministicIterations(f.ctx, tt, req, f.queryClient.DenomOwners, 2525, false)
}

1188
tests/integration/bank/keeper/keeper_test.go
View File

File diff suppressed because it is too large Load Diff

2
testutil/testdata/grpc_query.go vendored
View File

@ -65,6 +65,8 @@ func (m *TestAnyResponse) UnpackInterfaces(unpacker types.AnyUnpacker) error {
// 2. That the gas consumption of the query is the same. When
// `gasOverwrite` is set to true, we also check that this consumed
// gas value is equal to the hardcoded `gasConsumed`.
//
// TODO: replace "github.com/stretchr/testify/require" with "gotest.tools/v3"
func DeterministicIterations[request proto.Message, response proto.Message](
ctx sdk.Context,
require *require.Assertions,