certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

temporal commit on querier test, it passes

This commit is contained in:
Jonathan Gimeno 2020-02-18 16:44:23 +01:00
parent 6025132720
commit c84c5922e4
2 changed files with 451 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
x/staking/keeper/common_refactor_test.go
View File

@ -5,10 +5,10 @@ import (
"encoding/hex" "encoding/hex"
"strconv" "strconv"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/crypto/ed25519" "github.com/tendermint/tendermint/crypto/ed25519"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/tendermint/tendermint/crypto"
) )
var ( var (

889
x/staking/keeper/querier_test.go
View File

@ -1,4 +1,4 @@
package keeper package keeper_test
import ( import (
"fmt" "fmt"
@ -8,7 +8,9 @@ import (
abci "github.com/tendermint/tendermint/abci/types" abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/types" "github.com/cosmos/cosmos-sdk/x/staking/types"
) )
@ -20,15 +22,17 @@ var (
func TestNewQuerier(t *testing.T) { func TestNewQuerier(t *testing.T) {
cdc := codec.New() cdc := codec.New()
ctx, _, _, keeper, _ := CreateTestInput(t, false, 1000) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
// Create Validators // Create Validators
amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8)} amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8)}
var validators [2]types.Validator var validators [2]types.Validator
for i, amt := range amts { for i, amt := range amts {
validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{}) validators[i] = types.NewValidator(sdk.ValAddress(Addrs[i]), PKs[i], types.Description{})
validators[i], _ = validators[i].AddTokensFromDel(amt) validators[i], _ = validators[i].AddTokensFromDel(amt)
keeper.SetValidator(ctx, validators[i]) app.StakingKeeper.SetValidator(ctx, validators[i])
keeper.SetValidatorByPowerIndex(ctx, validators[i]) app.StakingKeeper.SetValidatorByPowerIndex(ctx, validators[i])
} }
header := abci.Header{ header := abci.Header{
@ -36,14 +40,14 @@ func TestNewQuerier(t *testing.T) {
Height: 5, Height: 5,
} }
hi := types.NewHistoricalInfo(header, validators[:]) hi := types.NewHistoricalInfo(header, validators[:])
keeper.SetHistoricalInfo(ctx, 5, hi) app.StakingKeeper.SetHistoricalInfo(ctx, 5, hi)
query := abci.RequestQuery{ query := abci.RequestQuery{
Path: "", Path: "",
Data: []byte{}, Data: []byte{},
} }
querier := NewQuerier(keeper) querier := staking.NewQuerier(app.StakingKeeper)
bz, err := querier(ctx, []string{"other"}, query) bz, err := querier(ctx, []string{"other"}, query)
require.Error(t, err) require.Error(t, err)
@ -107,32 +111,37 @@ func TestNewQuerier(t *testing.T) {
func TestQueryParametersPool(t *testing.T) { func TestQueryParametersPool(t *testing.T) {
cdc := codec.New() cdc := codec.New()
ctx, _, _, keeper, _ := CreateTestInput(t, false, 1000) app := simapp.Setup(false)
ctx := app.BaseApp.NewContext(false, abci.Header{})
querier := staking.NewQuerier(app.StakingKeeper)
bondDenom := sdk.DefaultBondDenom bondDenom := sdk.DefaultBondDenom
res, err := queryParameters(ctx, keeper) res, err := querier(ctx, []string{staking.QueryParameters}, abci.RequestQuery{})
require.NoError(t, err) require.NoError(t, err)
var params types.Params var params types.Params
errRes := cdc.UnmarshalJSON(res, &params) errRes := cdc.UnmarshalJSON(res, &params)
require.NoError(t, errRes) require.NoError(t, errRes)
require.Equal(t, keeper.GetParams(ctx), params) require.Equal(t, app.StakingKeeper.GetParams(ctx), params)
res, err = queryPool(ctx, keeper) res, err = querier(ctx, []string{staking.QueryPool}, abci.RequestQuery{})
require.NoError(t, err) require.NoError(t, err)
var pool types.Pool var pool types.Pool
bondedPool := keeper.GetBondedPool(ctx) bondedPool := app.StakingKeeper.GetBondedPool(ctx)
notBondedPool := keeper.GetNotBondedPool(ctx) notBondedPool := app.StakingKeeper.GetNotBondedPool(ctx)
require.NoError(t, cdc.UnmarshalJSON(res, &pool)) require.NoError(t, cdc.UnmarshalJSON(res, &pool))
require.Equal(t, keeper.bankKeeper.GetBalance(ctx, notBondedPool.GetAddress(), bondDenom).Amount, pool.NotBondedTokens) require.Equal(t, app.BankKeeper.GetBalance(ctx, notBondedPool.GetAddress(), bondDenom).Amount, pool.NotBondedTokens)
require.Equal(t, keeper.bankKeeper.GetBalance(ctx, bondedPool.GetAddress(), bondDenom).Amount, pool.BondedTokens) require.Equal(t, app.BankKeeper.GetBalance(ctx, bondedPool.GetAddress(), bondDenom).Amount, pool.BondedTokens)
} }
func TestQueryValidators(t *testing.T) { func TestQueryValidators(t *testing.T) {
cdc := codec.New() cdc := codec.New()
ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000) app := simapp.Setup(false)
params := keeper.GetParams(ctx) ctx := app.BaseApp.NewContext(false, abci.Header{})
params := app.StakingKeeper.GetParams(ctx)
querier := staking.NewQuerier(app.StakingKeeper)
// Create Validators // Create Validators
amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)} amts := []sdk.Int{sdk.NewInt(9), sdk.NewInt(8), sdk.NewInt(7)}
@ -144,12 +153,12 @@ func TestQueryValidators(t *testing.T) {
validators[i] = validators[i].UpdateStatus(status[i]) validators[i] = validators[i].UpdateStatus(status[i])
} }
keeper.SetValidator(ctx, validators[0]) app.StakingKeeper.SetValidator(ctx, validators[0])
keeper.SetValidator(ctx, validators[1]) app.StakingKeeper.SetValidator(ctx, validators[1])
keeper.SetValidator(ctx, validators[2]) app.StakingKeeper.SetValidator(ctx, validators[2])
// Query Validators // Query Validators
queriedValidators := keeper.GetValidators(ctx, params.MaxValidators) queriedValidators := app.StakingKeeper.GetValidators(ctx, params.MaxValidators)
for i, s := range status { for i, s := range status {
queryValsParams := types.NewQueryValidatorsParams(1, int(params.MaxValidators), s.String()) queryValsParams := types.NewQueryValidatorsParams(1, int(params.MaxValidators), s.String())
@ -161,7 +170,7 @@ func TestQueryValidators(t *testing.T) {
Data: bz, Data: bz,
} }
res, err := queryValidators(ctx, req, keeper) res, err := querier(ctx, []string{types.QueryValidators}, req)
require.NoError(t, err) require.NoError(t, err)
var validatorsResp []types.Validator var validatorsResp []types.Validator
@ -182,7 +191,7 @@ func TestQueryValidators(t *testing.T) {
Path: "/custom/staking/validator", Path: "/custom/staking/validator",
Data: bz, Data: bz,
} }
res, err := queryValidator(ctx, query, keeper) res, err := querier(ctx, []string{types.QueryValidator}, query)
require.NoError(t, err) require.NoError(t, err)
var validator types.Validator var validator types.Validator
@ -192,420 +201,422 @@ func TestQueryValidators(t *testing.T) {
require.Equal(t, queriedValidators[0], validator) require.Equal(t, queriedValidators[0], validator)
} }
func TestQueryDelegation(t *testing.T) { //func TestQueryDelegation(t *testing.T) {
cdc := codec.New() // cdc := codec.New()
ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000) // app := simapp.Setup(false)
params := keeper.GetParams(ctx) // ctx := app.BaseApp.NewContext(false, abci.Header{})
// params := app.StakingKeeper.GetParams(ctx)
// Create Validators and Delegation // querier := staking.NewQuerier(app.StakingKeeper)
val1 := types.NewValidator(addrVal1, pk1, types.Description{}) //
keeper.SetValidator(ctx, val1) // // Create Validators and Delegation
keeper.SetValidatorByPowerIndex(ctx, val1) // val1 := types.NewValidator(addrVal1, pk1, types.Description{})
// app.StakingKeeper.SetValidator(ctx, val1)
val2 := types.NewValidator(addrVal2, pk2, types.Description{}) // app.StakingKeeper.SetValidatorByPowerIndex(ctx, val1)
keeper.SetValidator(ctx, val2) //
keeper.SetValidatorByPowerIndex(ctx, val2) // val2 := types.NewValidator(addrVal2, pk2, types.Description{})
// app.StakingKeeper.SetValidator(ctx, val2)
delTokens := sdk.TokensFromConsensusPower(20) // app.StakingKeeper.SetValidatorByPowerIndex(ctx, val2)
keeper.Delegate(ctx, addrAcc2, delTokens, sdk.Unbonded, val1, true) //
// delTokens := sdk.TokensFromConsensusPower(20)
// apply TM updates // app.StakingKeeper.Delegate(ctx, addrAcc2, delTokens, sdk.Unbonded, val1, true)
keeper.ApplyAndReturnValidatorSetUpdates(ctx) //
// // apply TM updates
// Query Delegator bonded validators // app.StakingKeeper.ApplyAndReturnValidatorSetUpdates(ctx)
queryParams := types.NewQueryDelegatorParams(addrAcc2) //
bz, errRes := cdc.MarshalJSON(queryParams) // // Query Delegator bonded validators
require.NoError(t, errRes) // queryParams := types.NewQueryDelegatorParams(addrAcc2)
// bz, errRes := cdc.MarshalJSON(queryParams)
query := abci.RequestQuery{ // require.NoError(t, errRes)
Path: "/custom/staking/delegatorValidators", //
Data: bz, // query := abci.RequestQuery{
} // Path: "/custom/staking/delegatorValidators",
// Data: bz,
delValidators := keeper.GetDelegatorValidators(ctx, addrAcc2, params.MaxValidators) // }
//
res, err := queryDelegatorValidators(ctx, query, keeper) // delValidators := app.StakingKeeper.GetDelegatorValidators(ctx, addrAcc2, params.MaxValidators)
require.NoError(t, err) //
// res, err := querier(ctx, []string{types.QueryDelegatorValidators}, query)
var validatorsResp []types.Validator // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &validatorsResp) //
require.NoError(t, errRes) // var validatorsResp []types.Validator
// errRes = cdc.UnmarshalJSON(res, &validatorsResp)
require.Equal(t, len(delValidators), len(validatorsResp)) // require.NoError(t, errRes)
require.ElementsMatch(t, delValidators, validatorsResp) //
// require.Equal(t, len(delValidators), len(validatorsResp))
// error unknown request // require.ElementsMatch(t, delValidators, validatorsResp)
query.Data = bz[:len(bz)-1] //
// // error unknown request
_, err = queryDelegatorValidators(ctx, query, keeper) // query.Data = bz[:len(bz)-1]
require.Error(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegatorValidators}, query)
// Query bonded validator // require.Error(t, err)
queryBondParams := types.NewQueryBondsParams(addrAcc2, addrVal1) //
bz, errRes = cdc.MarshalJSON(queryBondParams) // // Query bonded validator
require.NoError(t, errRes) // queryBondParams := types.NewQueryBondsParams(addrAcc2, addrVal1)
// bz, errRes = cdc.MarshalJSON(queryBondParams)
query = abci.RequestQuery{ // require.NoError(t, errRes)
Path: "/custom/staking/delegatorValidator", //
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/delegatorValidator",
// Data: bz,
res, err = queryDelegatorValidator(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegatorValidator}, query)
var validator types.Validator // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &validator) //
require.NoError(t, errRes) // var validator types.Validator
// errRes = cdc.UnmarshalJSON(res, &validator)
require.Equal(t, delValidators[0], validator) // require.NoError(t, errRes)
//
// error unknown request // require.Equal(t, delValidators[0], validator)
query.Data = bz[:len(bz)-1] //
// // error unknown request
_, err = queryDelegatorValidator(ctx, query, keeper) // query.Data = bz[:len(bz)-1]
require.Error(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegatorValidator}, query)
// Query delegation // require.Error(t, err)
//
query = abci.RequestQuery{ // // Query delegation
Path: "/custom/staking/delegation", //
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/delegation",
// Data: bz,
delegation, found := keeper.GetDelegation(ctx, addrAcc2, addrVal1) // }
require.True(t, found) //
// delegation, found := app.StakingKeeper.GetDelegation(ctx, addrAcc2, addrVal1)
res, err = queryDelegation(ctx, query, keeper) // require.True(t, found)
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegation}, query)
var delegationRes types.DelegationResponse // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &delegationRes) //
require.NoError(t, errRes) // var delegationRes types.DelegationResponse
// errRes = cdc.UnmarshalJSON(res, &delegationRes)
require.Equal(t, delegation.ValidatorAddress, delegationRes.ValidatorAddress) // require.NoError(t, errRes)
require.Equal(t, delegation.DelegatorAddress, delegationRes.DelegatorAddress) //
require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationRes.Balance) // require.Equal(t, delegation.ValidatorAddress, delegationRes.ValidatorAddress)
// require.Equal(t, delegation.DelegatorAddress, delegationRes.DelegatorAddress)
// Query Delegator Delegations // require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationRes.Balance)
query = abci.RequestQuery{ //
Path: "/custom/staking/delegatorDelegations", // // Query Delegator Delegations
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/delegatorDelegations",
// Data: bz,
res, err = queryDelegatorDelegations(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegatorDelegations}, query)
var delegatorDelegations types.DelegationResponses // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &delegatorDelegations) //
require.NoError(t, errRes) // var delegatorDelegations types.DelegationResponses
require.Len(t, delegatorDelegations, 1) // errRes = cdc.UnmarshalJSON(res, &delegatorDelegations)
require.Equal(t, delegation.ValidatorAddress, delegatorDelegations[0].ValidatorAddress) // require.NoError(t, errRes)
require.Equal(t, delegation.DelegatorAddress, delegatorDelegations[0].DelegatorAddress) // require.Len(t, delegatorDelegations, 1)
require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegatorDelegations[0].Balance) // require.Equal(t, delegation.ValidatorAddress, delegatorDelegations[0].ValidatorAddress)
// require.Equal(t, delegation.DelegatorAddress, delegatorDelegations[0].DelegatorAddress)
// error unknown request // require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegatorDelegations[0].Balance)
query.Data = bz[:len(bz)-1] //
// // error unknown request
_, err = queryDelegation(ctx, query, keeper) // query.Data = bz[:len(bz)-1]
require.Error(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegation}, query)
// Query validator delegations // require.Error(t, err)
//
bz, errRes = cdc.MarshalJSON(types.NewQueryValidatorParams(addrVal1)) // // Query validator delegations
require.NoError(t, errRes) //
// bz, errRes = cdc.MarshalJSON(types.NewQueryValidatorParams(addrVal1))
query = abci.RequestQuery{ // require.NoError(t, errRes)
Path: "custom/staking/validatorDelegations", //
Data: bz, // query = abci.RequestQuery{
} // Path: "custom/staking/validatorDelegations",
// Data: bz,
res, err = queryValidatorDelegations(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryValidatorDelegations}, query)
var delegationsRes types.DelegationResponses // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &delegationsRes) //
require.NoError(t, errRes) // var delegationsRes types.DelegationResponses
require.Len(t, delegatorDelegations, 1) // errRes = cdc.UnmarshalJSON(res, &delegationsRes)
require.Equal(t, delegation.ValidatorAddress, delegationsRes[0].ValidatorAddress) // require.NoError(t, errRes)
require.Equal(t, delegation.DelegatorAddress, delegationsRes[0].DelegatorAddress) // require.Len(t, delegatorDelegations, 1)
require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance) // require.Equal(t, delegation.ValidatorAddress, delegationsRes[0].ValidatorAddress)
// require.Equal(t, delegation.DelegatorAddress, delegationsRes[0].DelegatorAddress)
// Query unbonging delegation // require.Equal(t, sdk.NewCoin(sdk.DefaultBondDenom, delegation.Shares.TruncateInt()), delegationsRes[0].Balance)
unbondingTokens := sdk.TokensFromConsensusPower(10) //
_, err = keeper.Undelegate(ctx, addrAcc2, val1.OperatorAddress, unbondingTokens.ToDec()) // // Query unbonging delegation
require.NoError(t, err) // unbondingTokens := sdk.TokensFromConsensusPower(10)
// _, err = app.StakingKeeper.Undelegate(ctx, addrAcc2, val1.OperatorAddress, unbondingTokens.ToDec())
queryBondParams = types.NewQueryBondsParams(addrAcc2, addrVal1) // require.NoError(t, err)
bz, errRes = cdc.MarshalJSON(queryBondParams) //
require.NoError(t, errRes) // queryBondParams = types.NewQueryBondsParams(addrAcc2, addrVal1)
// bz, errRes = cdc.MarshalJSON(queryBondParams)
query = abci.RequestQuery{ // require.NoError(t, errRes)
Path: "/custom/staking/unbondingDelegation", //
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/unbondingDelegation",
// Data: bz,
unbond, found := keeper.GetUnbondingDelegation(ctx, addrAcc2, addrVal1) // }
require.True(t, found) //
// unbond, found := app.StakingKeeper.GetUnbondingDelegation(ctx, addrAcc2, addrVal1)
res, err = queryUnbondingDelegation(ctx, query, keeper) // require.True(t, found)
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryUnbondingDelegation}, query)
var unbondRes types.UnbondingDelegation // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &unbondRes) //
require.NoError(t, errRes) // var unbondRes types.UnbondingDelegation
// errRes = cdc.UnmarshalJSON(res, &unbondRes)
require.Equal(t, unbond, unbondRes) // require.NoError(t, errRes)
//
// error unknown request // require.Equal(t, unbond, unbondRes)
query.Data = bz[:len(bz)-1] //
// // error unknown request
_, err = queryUnbondingDelegation(ctx, query, keeper) // query.Data = bz[:len(bz)-1]
require.Error(t, err) //
// _, err = querier(ctx, []string{types.QueryUnbondingDelegation}, query)
// Query Delegator Delegations // require.Error(t, err)
//
query = abci.RequestQuery{ // // Query Delegator Delegations
Path: "/custom/staking/delegatorUnbondingDelegations", //
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/delegatorUnbondingDelegations",
// Data: bz,
res, err = queryDelegatorUnbondingDelegations(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryDelegatorUnbondingDelegations}, query)
var delegatorUbds []types.UnbondingDelegation // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &delegatorUbds) //
require.NoError(t, errRes) // var delegatorUbds []types.UnbondingDelegation
require.Equal(t, unbond, delegatorUbds[0]) // errRes = cdc.UnmarshalJSON(res, &delegatorUbds)
// require.NoError(t, errRes)
// error unknown request // require.Equal(t, unbond, delegatorUbds[0])
query.Data = bz[:len(bz)-1] //
// // error unknown request
_, err = queryDelegatorUnbondingDelegations(ctx, query, keeper) // query.Data = bz[:len(bz)-1]
require.Error(t, err) //
// _, err = querier(ctx, []string{types.QueryDelegatorUnbondingDelegations}, query)
// Query redelegation // require.Error(t, err)
redelegationTokens := sdk.TokensFromConsensusPower(10) //
_, err = keeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddress, // // Query redelegation
val2.OperatorAddress, redelegationTokens.ToDec()) // redelegationTokens := sdk.TokensFromConsensusPower(10)
require.NoError(t, err) // _, err = app.StakingKeeper.BeginRedelegation(ctx, addrAcc2, val1.OperatorAddress,
redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress) // val2.OperatorAddress, redelegationTokens.ToDec())
require.True(t, found) // require.NoError(t, err)
// redel, found := app.StakingKeeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress)
bz, errRes = cdc.MarshalJSON(types.NewQueryRedelegationParams(addrAcc2, val1.OperatorAddress, val2.OperatorAddress)) // require.True(t, found)
require.NoError(t, errRes) //
// bz, errRes = cdc.MarshalJSON(types.NewQueryRedelegationParams(addrAcc2, val1.OperatorAddress, val2.OperatorAddress))
query = abci.RequestQuery{ // require.NoError(t, errRes)
Path: "/custom/staking/redelegations", //
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/redelegations",
// Data: bz,
res, err = queryRedelegations(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err = querier(ctx, []string{types.QueryRedelegations}, query)
var redelRes types.RedelegationResponses // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &redelRes) //
require.NoError(t, errRes) // var redelRes types.RedelegationResponses
require.Len(t, redelRes, 1) // errRes = cdc.UnmarshalJSON(res, &redelRes)
require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress) // require.NoError(t, errRes)
require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress) // require.Len(t, redelRes, 1)
require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress) // require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress)
require.Len(t, redel.Entries, len(redelRes[0].Entries)) // require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress)
} // require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress)
// require.Len(t, redel.Entries, len(redelRes[0].Entries))
func TestQueryRedelegations(t *testing.T) { //}
cdc := codec.New() //
ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000) //func TestQueryRedelegations(t *testing.T) {
// cdc := codec.New()
// Create Validators and Delegation // ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000)
val1 := types.NewValidator(addrVal1, pk1, types.Description{}) //
val2 := types.NewValidator(addrVal2, pk2, types.Description{}) // // Create Validators and Delegation
keeper.SetValidator(ctx, val1) // val1 := types.NewValidator(addrVal1, pk1, types.Description{})
keeper.SetValidator(ctx, val2) // val2 := types.NewValidator(addrVal2, pk2, types.Description{})
// keeper.SetValidator(ctx, val1)
delAmount := sdk.TokensFromConsensusPower(100) // keeper.SetValidator(ctx, val2)
keeper.Delegate(ctx, addrAcc2, delAmount, sdk.Unbonded, val1, true) //
_ = keeper.ApplyAndReturnValidatorSetUpdates(ctx) // delAmount := sdk.TokensFromConsensusPower(100)
// keeper.Delegate(ctx, addrAcc2, delAmount, sdk.Unbonded, val1, true)
rdAmount := sdk.TokensFromConsensusPower(20) // _ = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec()) //
keeper.ApplyAndReturnValidatorSetUpdates(ctx) // rdAmount := sdk.TokensFromConsensusPower(20)
// keeper.BeginRedelegation(ctx, addrAcc2, val1.GetOperator(), val2.GetOperator(), rdAmount.ToDec())
redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress) // keeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.True(t, found) //
// redel, found := keeper.GetRedelegation(ctx, addrAcc2, val1.OperatorAddress, val2.OperatorAddress)
// delegator redelegations // require.True(t, found)
queryDelegatorParams := types.NewQueryDelegatorParams(addrAcc2) //
bz, errRes := cdc.MarshalJSON(queryDelegatorParams) // // delegator redelegations
require.NoError(t, errRes) // queryDelegatorParams := types.NewQueryDelegatorParams(addrAcc2)
// bz, errRes := cdc.MarshalJSON(queryDelegatorParams)
query := abci.RequestQuery{ // require.NoError(t, errRes)
Path: "/custom/staking/redelegations", //
Data: bz, // query := abci.RequestQuery{
} // Path: "/custom/staking/redelegations",
// Data: bz,
res, err := queryRedelegations(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err := queryRedelegations(ctx, query, keeper)
var redelRes types.RedelegationResponses // require.NoError(t, err)
errRes = cdc.UnmarshalJSON(res, &redelRes) //
require.NoError(t, errRes) // var redelRes types.RedelegationResponses
require.Len(t, redelRes, 1) // errRes = cdc.UnmarshalJSON(res, &redelRes)
require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress) // require.NoError(t, errRes)
require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress) // require.Len(t, redelRes, 1)
require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress) // require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress)
require.Len(t, redel.Entries, len(redelRes[0].Entries)) // require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress)
// require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress)
// validator redelegations // require.Len(t, redel.Entries, len(redelRes[0].Entries))
queryValidatorParams := types.NewQueryValidatorParams(val1.GetOperator()) //
bz, errRes = cdc.MarshalJSON(queryValidatorParams) // // validator redelegations
require.NoError(t, errRes) // queryValidatorParams := types.NewQueryValidatorParams(val1.GetOperator())
// bz, errRes = cdc.MarshalJSON(queryValidatorParams)
query = abci.RequestQuery{ // require.NoError(t, errRes)
Path: "/custom/staking/redelegations", //
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/redelegations",
// Data: bz,
res, err = queryRedelegations(ctx, query, keeper) // }
require.NoError(t, err) //
// res, err = queryRedelegations(ctx, query, keeper)
errRes = cdc.UnmarshalJSON(res, &redelRes) // require.NoError(t, err)
require.NoError(t, errRes) //
require.Len(t, redelRes, 1) // errRes = cdc.UnmarshalJSON(res, &redelRes)
require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress) // require.NoError(t, errRes)
require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress) // require.Len(t, redelRes, 1)
require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress) // require.Equal(t, redel.DelegatorAddress, redelRes[0].DelegatorAddress)
require.Len(t, redel.Entries, len(redelRes[0].Entries)) // require.Equal(t, redel.ValidatorSrcAddress, redelRes[0].ValidatorSrcAddress)
} // require.Equal(t, redel.ValidatorDstAddress, redelRes[0].ValidatorDstAddress)
// require.Len(t, redel.Entries, len(redelRes[0].Entries))
func TestQueryUnbondingDelegation(t *testing.T) { //}
cdc := codec.New() //
ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000) //func TestQueryUnbondingDelegation(t *testing.T) {
// cdc := codec.New()
// Create Validators and Delegation // ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000)
val1 := types.NewValidator(addrVal1, pk1, types.Description{}) //
keeper.SetValidator(ctx, val1) // // Create Validators and Delegation
// val1 := types.NewValidator(addrVal1, pk1, types.Description{})
// delegate // keeper.SetValidator(ctx, val1)
delAmount := sdk.TokensFromConsensusPower(100) //
_, err := keeper.Delegate(ctx, addrAcc1, delAmount, sdk.Unbonded, val1, true) // // delegate
require.NoError(t, err) // delAmount := sdk.TokensFromConsensusPower(100)
_ = keeper.ApplyAndReturnValidatorSetUpdates(ctx) // _, err := keeper.Delegate(ctx, addrAcc1, delAmount, sdk.Unbonded, val1, true)
// require.NoError(t, err)
// undelegate // _ = keeper.ApplyAndReturnValidatorSetUpdates(ctx)
undelAmount := sdk.TokensFromConsensusPower(20) //
_, err = keeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec()) // // undelegate
require.NoError(t, err) // undelAmount := sdk.TokensFromConsensusPower(20)
keeper.ApplyAndReturnValidatorSetUpdates(ctx) // _, err = keeper.Undelegate(ctx, addrAcc1, val1.GetOperator(), undelAmount.ToDec())
// require.NoError(t, err)
_, found := keeper.GetUnbondingDelegation(ctx, addrAcc1, val1.OperatorAddress) // keeper.ApplyAndReturnValidatorSetUpdates(ctx)
require.True(t, found) //
// _, found := keeper.GetUnbondingDelegation(ctx, addrAcc1, val1.OperatorAddress)
// // require.True(t, found)
// found: query unbonding delegation by delegator and validator //
// // //
queryValidatorParams := types.NewQueryBondsParams(addrAcc1, val1.GetOperator()) // // found: query unbonding delegation by delegator and validator
bz, errRes := cdc.MarshalJSON(queryValidatorParams) // //
require.NoError(t, errRes) // queryValidatorParams := types.NewQueryBondsParams(addrAcc1, val1.GetOperator())
query := abci.RequestQuery{ // bz, errRes := cdc.MarshalJSON(queryValidatorParams)
Path: "/custom/staking/unbondingDelegation", // require.NoError(t, errRes)
Data: bz, // query := abci.RequestQuery{
} // Path: "/custom/staking/unbondingDelegation",
res, err := queryUnbondingDelegation(ctx, query, keeper) // Data: bz,
require.NoError(t, err) // }
require.NotNil(t, res) // res, err := queryUnbondingDelegation(ctx, query, keeper)
var ubDel types.UnbondingDelegation // require.NoError(t, err)
require.NoError(t, cdc.UnmarshalJSON(res, &ubDel)) // require.NotNil(t, res)
require.Equal(t, addrAcc1, ubDel.DelegatorAddress) // var ubDel types.UnbondingDelegation
require.Equal(t, val1.OperatorAddress, ubDel.ValidatorAddress) // require.NoError(t, cdc.UnmarshalJSON(res, &ubDel))
require.Equal(t, 1, len(ubDel.Entries)) // require.Equal(t, addrAcc1, ubDel.DelegatorAddress)
// require.Equal(t, val1.OperatorAddress, ubDel.ValidatorAddress)
// // require.Equal(t, 1, len(ubDel.Entries))
// not found: query unbonding delegation by delegator and validator //
// // //
queryValidatorParams = types.NewQueryBondsParams(addrAcc2, val1.GetOperator()) // // not found: query unbonding delegation by delegator and validator
bz, errRes = cdc.MarshalJSON(queryValidatorParams) // //
require.NoError(t, errRes) // queryValidatorParams = types.NewQueryBondsParams(addrAcc2, val1.GetOperator())
query = abci.RequestQuery{ // bz, errRes = cdc.MarshalJSON(queryValidatorParams)
Path: "/custom/staking/unbondingDelegation", // require.NoError(t, errRes)
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/unbondingDelegation",
_, err = queryUnbondingDelegation(ctx, query, keeper) // Data: bz,
require.Error(t, err) // }
// _, err = queryUnbondingDelegation(ctx, query, keeper)
// // require.Error(t, err)
// found: query unbonding delegation by delegator and validator //
// // //
queryDelegatorParams := types.NewQueryDelegatorParams(addrAcc1) // // found: query unbonding delegation by delegator and validator
bz, errRes = cdc.MarshalJSON(queryDelegatorParams) // //
require.NoError(t, errRes) // queryDelegatorParams := types.NewQueryDelegatorParams(addrAcc1)
query = abci.RequestQuery{ // bz, errRes = cdc.MarshalJSON(queryDelegatorParams)
Path: "/custom/staking/delegatorUnbondingDelegations", // require.NoError(t, errRes)
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/delegatorUnbondingDelegations",
res, err = queryDelegatorUnbondingDelegations(ctx, query, keeper) // Data: bz,
require.NoError(t, err) // }
require.NotNil(t, res) // res, err = queryDelegatorUnbondingDelegations(ctx, query, keeper)
var ubDels []types.UnbondingDelegation // require.NoError(t, err)
require.NoError(t, cdc.UnmarshalJSON(res, &ubDels)) // require.NotNil(t, res)
require.Equal(t, 1, len(ubDels)) // var ubDels []types.UnbondingDelegation
require.Equal(t, addrAcc1, ubDels[0].DelegatorAddress) // require.NoError(t, cdc.UnmarshalJSON(res, &ubDels))
require.Equal(t, val1.OperatorAddress, ubDels[0].ValidatorAddress) // require.Equal(t, 1, len(ubDels))
// require.Equal(t, addrAcc1, ubDels[0].DelegatorAddress)
// // require.Equal(t, val1.OperatorAddress, ubDels[0].ValidatorAddress)
// not found: query unbonding delegation by delegator and validator //
// // //
queryDelegatorParams = types.NewQueryDelegatorParams(addrAcc2) // // not found: query unbonding delegation by delegator and validator
bz, errRes = cdc.MarshalJSON(queryDelegatorParams) // //
require.NoError(t, errRes) // queryDelegatorParams = types.NewQueryDelegatorParams(addrAcc2)
query = abci.RequestQuery{ // bz, errRes = cdc.MarshalJSON(queryDelegatorParams)
Path: "/custom/staking/delegatorUnbondingDelegations", // require.NoError(t, errRes)
Data: bz, // query = abci.RequestQuery{
} // Path: "/custom/staking/delegatorUnbondingDelegations",
res, err = queryDelegatorUnbondingDelegations(ctx, query, keeper) // Data: bz,
require.NoError(t, err) // }
require.NotNil(t, res) // res, err = queryDelegatorUnbondingDelegations(ctx, query, keeper)
require.NoError(t, cdc.UnmarshalJSON(res, &ubDels)) // require.NoError(t, err)
require.Equal(t, 0, len(ubDels)) // require.NotNil(t, res)
} // require.NoError(t, cdc.UnmarshalJSON(res, &ubDels))
// require.Equal(t, 0, len(ubDels))
func TestQueryHistoricalInfo(t *testing.T) { //}
cdc := codec.New() //
ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000) //func TestQueryHistoricalInfo(t *testing.T) {
// cdc := codec.New()
// Create Validators and Delegation // ctx, _, _, keeper, _ := CreateTestInput(t, false, 10000)
val1 := types.NewValidator(addrVal1, pk1, types.Description{}) //
val2 := types.NewValidator(addrVal2, pk2, types.Description{}) // // Create Validators and Delegation
vals := []types.Validator{val1, val2} // val1 := types.NewValidator(addrVal1, pk1, types.Description{})
keeper.SetValidator(ctx, val1) // val2 := types.NewValidator(addrVal2, pk2, types.Description{})
keeper.SetValidator(ctx, val2) // vals := []types.Validator{val1, val2}
// keeper.SetValidator(ctx, val1)
header := abci.Header{ // keeper.SetValidator(ctx, val2)
ChainID: "HelloChain", //
Height: 5, // header := abci.Header{
} // ChainID: "HelloChain",
hi := types.NewHistoricalInfo(header, vals) // Height: 5,
keeper.SetHistoricalInfo(ctx, 5, hi) // }
// hi := types.NewHistoricalInfo(header, vals)
queryHistoricalParams := types.NewQueryHistoricalInfoParams(4) // keeper.SetHistoricalInfo(ctx, 5, hi)
bz, errRes := cdc.MarshalJSON(queryHistoricalParams) //
require.NoError(t, errRes) // queryHistoricalParams := types.NewQueryHistoricalInfoParams(4)
query := abci.RequestQuery{ // bz, errRes := cdc.MarshalJSON(queryHistoricalParams)
Path: "/custom/staking/historicalInfo", // require.NoError(t, errRes)
Data: bz, // query := abci.RequestQuery{
} // Path: "/custom/staking/historicalInfo",
res, err := queryHistoricalInfo(ctx, query, keeper) // Data: bz,
require.Error(t, err, "Invalid query passed") // }
require.Nil(t, res, "Invalid query returned non-nil result") // res, err := queryHistoricalInfo(ctx, query, keeper)
// require.Error(t, err, "Invalid query passed")
queryHistoricalParams = types.NewQueryHistoricalInfoParams(5) // require.Nil(t, res, "Invalid query returned non-nil result")
bz, errRes = cdc.MarshalJSON(queryHistoricalParams) //
require.NoError(t, errRes) // queryHistoricalParams = types.NewQueryHistoricalInfoParams(5)
query.Data = bz // bz, errRes = cdc.MarshalJSON(queryHistoricalParams)
res, err = queryHistoricalInfo(ctx, query, keeper) // require.NoError(t, errRes)
require.NoError(t, err, "Valid query passed") // query.Data = bz
require.NotNil(t, res, "Valid query returned nil result") // res, err = queryHistoricalInfo(ctx, query, keeper)
// require.NoError(t, err, "Valid query passed")
var recv types.HistoricalInfo // require.NotNil(t, res, "Valid query returned nil result")
require.NoError(t, cdc.UnmarshalJSON(res, &recv)) //
require.Equal(t, hi, recv, "HistoricalInfo query returned wrong result") // var recv types.HistoricalInfo
} // require.NoError(t, cdc.UnmarshalJSON(res, &recv))
// require.Equal(t, hi, recv, "HistoricalInfo query returned wrong result")
//}