github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/staking/keeper/querier_test.go (about)

     1  package keeper
     2  
     3  import (
     4  	"testing"
     5  
     6  	types2 "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
     7  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
     8  	"github.com/fibonacci-chain/fbc/x/staking/types"
     9  
    10  	"github.com/stretchr/testify/require"
    11  	"github.com/tendermint/go-amino"
    12  )
    13  
    14  func TestQueryValidators(t *testing.T) {
    15  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
    16  	keeper := mockKeeper.Keeper
    17  
    18  	fakeValidator := types.NewValidator(addrVals[0], PKs[0], types.Description{}, types.DefaultMinSelfDelegation)
    19  	keeper.SetValidator(ctx, fakeValidator)
    20  
    21  	getParams := func(status string) types.QueryValidatorsParams {
    22  		basicParams := types.NewQueryValidatorsParams(1, 100, status)
    23  		return basicParams
    24  	}
    25  
    26  	checkPairs := make(map[string]int)
    27  	checkPairs[types2.BondStatusUnbonded] = 1
    28  	checkPairs[types2.BondStatusBonded] = 0
    29  	checkPairs[types2.BondStatusUnbonding] = 0
    30  
    31  	querior := NewQuerier(keeper)
    32  	// queryValidators
    33  	for status, expectedCnt := range checkPairs {
    34  		bz, _ := amino.MarshalJSON(getParams(status))
    35  		path := types.QueryValidators
    36  		data, err := querior(ctx, []string{path}, abci.RequestQuery{Data: bz})
    37  		require.True(t, err == nil, err)
    38  
    39  		validators := types.Validators{}
    40  		e := amino.UnmarshalJSON(data, &validators)
    41  		require.True(t, e == nil, e)
    42  		if expectedCnt == 1 {
    43  			require.True(t, validators != nil && len(validators) == expectedCnt, validators, status, expectedCnt)
    44  
    45  		} else {
    46  			require.True(t, validators == nil, status, expectedCnt)
    47  		}
    48  
    49  	}
    50  	data, err := querior(ctx, []string{types.QueryValidators}, abci.RequestQuery{Data: nil})
    51  	require.Error(t, err)
    52  	require.Nil(t, data)
    53  }
    54  
    55  func TestQueryValidator(t *testing.T) {
    56  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
    57  	keeper := mockKeeper.Keeper
    58  
    59  	fakeValidator := types.NewValidator(addrVals[0], PKs[0], types.Description{}, types.DefaultMinSelfDelegation)
    60  	keeper.SetValidator(ctx, fakeValidator)
    61  
    62  	getParams := func(acc types2.ValAddress) types.QueryValidatorParams {
    63  		basicParams := types.NewQueryValidatorParams(acc)
    64  		return basicParams
    65  	}
    66  
    67  	checkAddress := []types2.ValAddress{addrVals[0], addrVals[1]}
    68  	expectedExist := []bool{true, false}
    69  
    70  	querior := NewQuerier(keeper)
    71  
    72  	// queryValidators
    73  	for i := 0; i < len(checkAddress); i++ {
    74  
    75  		bz, _ := amino.MarshalJSON(getParams(checkAddress[i]))
    76  		path := types.QueryValidator
    77  		data, qerr := querior(ctx, []string{path}, abci.RequestQuery{Data: bz})
    78  
    79  		validator := types.Validator{}
    80  		e := amino.UnmarshalJSON(data, &validator)
    81  		if expectedExist[i] {
    82  			require.True(t, qerr == nil, qerr)
    83  			require.True(t, e == nil, e)
    84  			require.True(t, validator.OperatorAddress.Equals(checkAddress[i]))
    85  
    86  		} else {
    87  			require.True(t, qerr != nil, qerr)
    88  			require.True(t, e != nil, e)
    89  			require.True(t, validator.OperatorAddress == nil || len(validator.OperatorAddress.Bytes()) == 0)
    90  		}
    91  	}
    92  	data, err := querior(ctx, []string{types.QueryValidator}, abci.RequestQuery{Data: nil})
    93  	require.Error(t, err)
    94  	require.Nil(t, data)
    95  }
    96  
    97  func TestQueryParams(t *testing.T) {
    98  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
    99  	keeper := mockKeeper.Keeper
   100  	querior := NewQuerier(keeper)
   101  	data, err := querior(ctx, []string{types.QueryParameters}, abci.RequestQuery{})
   102  	require.True(t, err == nil)
   103  	params := types.Params{}
   104  	_ = amino.UnmarshalJSON(data, &params)
   105  	require.Equal(t, types.DefaultMaxValidators, params.MaxValidators)
   106  }
   107  
   108  func TestQueryAddress(t *testing.T) {
   109  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
   110  	keeper := mockKeeper.Keeper
   111  
   112  	fakeValidator := types.NewValidator(addrVals[0], PKs[0], types.Description{}, types.DefaultMinSelfDelegation)
   113  	keeper.SetValidator(ctx, fakeValidator)
   114  
   115  	querior := NewQuerier(keeper)
   116  	data, err := querior(ctx, []string{types.QueryAddress}, abci.RequestQuery{})
   117  	require.True(t, err == nil)
   118  	require.NotNil(t, data)
   119  
   120  	ovPairs := types.OVPairs{}
   121  	e := types.ModuleCdc.UnmarshalJSON(data, &ovPairs)
   122  	require.Nil(t, e)
   123  	require.NotNil(t, ovPairs.String())
   124  
   125  	data, err = querior(ctx, []string{"wrong path"}, abci.RequestQuery{})
   126  	require.Error(t, err)
   127  	require.Nil(t, data)
   128  
   129  }
   130  
   131  func TestQueryForAddress(t *testing.T) {
   132  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
   133  	keeper := mockKeeper.Keeper
   134  
   135  	fakeValidator := types.NewValidator(addrVals[0], PKs[0], types.Description{}, types.DefaultMinSelfDelegation)
   136  	keeper.SetValidator(ctx, fakeValidator)
   137  	querior := NewQuerier(keeper)
   138  
   139  	// successful case
   140  	data, err := querior(ctx, []string{types.QueryForAddress}, abci.RequestQuery{Data: []byte(fakeValidator.GetConsPubKey().Address().String())})
   141  	require.True(t, err == nil)
   142  	require.NotNil(t, data)
   143  
   144  	// error case : the request length of param != 40
   145  	data, err = querior(ctx, []string{types.QueryForAddress}, abci.RequestQuery{Data: []byte("wrong address")})
   146  	require.Error(t, err)
   147  	require.Nil(t, data)
   148  
   149  	// error case : the request param is not address
   150  	data, err = querior(ctx, []string{types.QueryForAddress}, abci.RequestQuery{Data: []byte("A58856F0FD53BF058B4909A21AEC019107BA6012")})
   151  	require.Error(t, err)
   152  	require.Nil(t, data)
   153  }
   154  
   155  func TestQueryForAccAddress(t *testing.T) {
   156  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
   157  	keeper := mockKeeper.Keeper
   158  
   159  	fakeValidator := types.NewValidator(addrVals[0], PKs[0], types.Description{}, types.DefaultMinSelfDelegation)
   160  	keeper.SetValidator(ctx, fakeValidator)
   161  	querior := NewQuerier(keeper)
   162  
   163  	// successful case
   164  	data, err := querior(ctx, []string{types.QueryForAccAddress}, abci.RequestQuery{Data: []byte(addrVals[0].String())})
   165  	require.True(t, err == nil)
   166  	require.NotNil(t, data)
   167  
   168  	// error case : request param is not address
   169  	data, err = querior(ctx, []string{types.QueryForAccAddress}, abci.RequestQuery{Data: []byte("string")})
   170  	require.Error(t, err)
   171  	require.Nil(t, data)
   172  }
   173  
   174  func TestQueriorQueryProxy(t *testing.T) {
   175  	ctx, _, mockKeeper := CreateTestInput(t, false, SufficientInitBalance)
   176  	keeper := mockKeeper.Keeper
   177  
   178  	fakeValidator := types.NewValidator(addrVals[0], PKs[0], types.Description{}, types.DefaultMinSelfDelegation)
   179  	keeper.SetValidator(ctx, fakeValidator)
   180  	querior := NewQuerier(keeper)
   181  
   182  	// error case
   183  	badParams := "bad"
   184  	bz, _ := types.ModuleCdc.MarshalJSON(badParams)
   185  	data, err := querior(ctx, []string{types.QueryProxy}, abci.RequestQuery{Data: bz})
   186  	require.True(t, err != nil)
   187  	require.True(t, data == nil)
   188  
   189  	// success, but no response
   190  	goodParams := types.NewQueryDelegatorParams(addrDels[0])
   191  	bz, _ = types.ModuleCdc.MarshalJSON(goodParams)
   192  	data, err = querior(ctx, []string{types.QueryProxy}, abci.RequestQuery{Data: bz})
   193  	require.True(t, err == nil)
   194  	require.True(t, data != nil)
   195  
   196  }
   197  
   198  func TestParams(t *testing.T) {
   199  	ctx, _, keeper := CreateTestInput(t, false, 0)
   200  	expParams := types.DefaultParams()
   201  
   202  	//check that the empty keeper loads the default
   203  	resParams := keeper.GetParams(ctx)
   204  	require.True(t, expParams.Equal(resParams))
   205  
   206  	//modify a params, save, and retrieve
   207  	expParams.MaxValidators = 777
   208  	keeper.SetParams(ctx, expParams)
   209  	resParams = keeper.GetParams(ctx)
   210  	require.True(t, expParams.Equal(resParams))
   211  }