github.com/Finschia/finschia-sdk@v0.49.1/x/feegrant/keeper/grpc_query_test.go (about)

     1  package keeper_test
     2  
     3  import (
     4  	sdk "github.com/Finschia/finschia-sdk/types"
     5  	"github.com/Finschia/finschia-sdk/x/feegrant"
     6  )
     7  
     8  func (suite *KeeperTestSuite) TestFeeAllowance() {
     9  	testCases := []struct {
    10  		name      string
    11  		req       *feegrant.QueryAllowanceRequest
    12  		expectErr bool
    13  		preRun    func()
    14  		postRun   func(_ *feegrant.QueryAllowanceResponse)
    15  	}{
    16  		{
    17  			"nil request",
    18  			nil,
    19  			true,
    20  			func() {},
    21  			func(*feegrant.QueryAllowanceResponse) {},
    22  		},
    23  		{
    24  			"fail: invalid granter",
    25  			&feegrant.QueryAllowanceRequest{
    26  				Granter: "invalid_granter",
    27  				Grantee: suite.addrs[0].String(),
    28  			},
    29  			true,
    30  			func() {},
    31  			func(*feegrant.QueryAllowanceResponse) {},
    32  		},
    33  		{
    34  			"fail: invalid grantee",
    35  			&feegrant.QueryAllowanceRequest{
    36  				Granter: suite.addrs[0].String(),
    37  				Grantee: "invalid_grantee",
    38  			},
    39  			true,
    40  			func() {},
    41  			func(*feegrant.QueryAllowanceResponse) {},
    42  		},
    43  		{
    44  			"fail: no grants",
    45  			&feegrant.QueryAllowanceRequest{
    46  				Granter: suite.addrs[0].String(),
    47  				Grantee: suite.addrs[1].String(),
    48  			},
    49  			true,
    50  			func() {},
    51  			func(*feegrant.QueryAllowanceResponse) {},
    52  		},
    53  		{
    54  			"valid query: expect single grant",
    55  			&feegrant.QueryAllowanceRequest{
    56  				Granter: suite.addrs[0].String(),
    57  				Grantee: suite.addrs[1].String(),
    58  			},
    59  			false,
    60  			func() {
    61  				suite.grantFeeAllowance(suite.addrs[0], suite.addrs[1])
    62  			},
    63  			func(response *feegrant.QueryAllowanceResponse) {
    64  				suite.Require().Equal(response.Allowance.Granter, suite.addrs[0].String())
    65  				suite.Require().Equal(response.Allowance.Grantee, suite.addrs[1].String())
    66  			},
    67  		},
    68  	}
    69  
    70  	for _, tc := range testCases {
    71  		suite.Run(tc.name, func() {
    72  			tc.preRun()
    73  			resp, err := suite.keeper.Allowance(suite.ctx, tc.req)
    74  			if tc.expectErr {
    75  				suite.Require().Error(err)
    76  			} else {
    77  				suite.Require().NoError(err)
    78  				tc.postRun(resp)
    79  			}
    80  		})
    81  	}
    82  }
    83  
    84  func (suite *KeeperTestSuite) TestFeeAllowances() {
    85  	testCases := []struct {
    86  		name      string
    87  		req       *feegrant.QueryAllowancesRequest
    88  		expectErr bool
    89  		preRun    func()
    90  		postRun   func(_ *feegrant.QueryAllowancesResponse)
    91  	}{
    92  		{
    93  			"nil request",
    94  			nil,
    95  			true,
    96  			func() {},
    97  			func(*feegrant.QueryAllowancesResponse) {},
    98  		},
    99  		{
   100  			"fail: invalid grantee",
   101  			&feegrant.QueryAllowancesRequest{
   102  				Grantee: "invalid_grantee",
   103  			},
   104  			true,
   105  			func() {},
   106  			func(*feegrant.QueryAllowancesResponse) {},
   107  		},
   108  		{
   109  			"no grants",
   110  			&feegrant.QueryAllowancesRequest{
   111  				Grantee: suite.addrs[1].String(),
   112  			},
   113  			false,
   114  			func() {},
   115  			func(resp *feegrant.QueryAllowancesResponse) {
   116  				suite.Require().Equal(len(resp.Allowances), 0)
   117  			},
   118  		},
   119  		{
   120  			"valid query: expect single grant",
   121  			&feegrant.QueryAllowancesRequest{
   122  				Grantee: suite.addrs[1].String(),
   123  			},
   124  			false,
   125  			func() {
   126  				suite.grantFeeAllowance(suite.addrs[0], suite.addrs[1])
   127  			},
   128  			func(resp *feegrant.QueryAllowancesResponse) {
   129  				suite.Require().Equal(len(resp.Allowances), 1)
   130  				suite.Require().Equal(resp.Allowances[0].Granter, suite.addrs[0].String())
   131  				suite.Require().Equal(resp.Allowances[0].Grantee, suite.addrs[1].String())
   132  			},
   133  		},
   134  	}
   135  
   136  	for _, tc := range testCases {
   137  		suite.Run(tc.name, func() {
   138  			tc.preRun()
   139  			resp, err := suite.keeper.Allowances(suite.ctx, tc.req)
   140  			if tc.expectErr {
   141  				suite.Require().Error(err)
   142  			} else {
   143  				suite.Require().NoError(err)
   144  				tc.postRun(resp)
   145  			}
   146  		})
   147  	}
   148  }
   149  
   150  func (suite *KeeperTestSuite) TestFeeAllowancesByGranter() {
   151  	testCases := []struct {
   152  		name      string
   153  		req       *feegrant.QueryAllowancesByGranterRequest
   154  		expectErr bool
   155  		preRun    func()
   156  		postRun   func(_ *feegrant.QueryAllowancesByGranterResponse)
   157  	}{
   158  		{
   159  			"nil request",
   160  			nil,
   161  			true,
   162  			func() {},
   163  			func(*feegrant.QueryAllowancesByGranterResponse) {},
   164  		},
   165  		{
   166  			"fail: invalid grantee",
   167  			&feegrant.QueryAllowancesByGranterRequest{
   168  				Granter: "invalid_grantee",
   169  			},
   170  			true,
   171  			func() {},
   172  			func(*feegrant.QueryAllowancesByGranterResponse) {},
   173  		},
   174  		{
   175  			"no grants",
   176  			&feegrant.QueryAllowancesByGranterRequest{
   177  				Granter: suite.addrs[0].String(),
   178  			},
   179  			false,
   180  			func() {},
   181  			func(resp *feegrant.QueryAllowancesByGranterResponse) {
   182  				suite.Require().Equal(len(resp.Allowances), 0)
   183  			},
   184  		},
   185  		{
   186  			"valid query: expect single grant",
   187  			&feegrant.QueryAllowancesByGranterRequest{
   188  				Granter: suite.addrs[0].String(),
   189  			},
   190  			false,
   191  			func() {
   192  				suite.grantFeeAllowance(suite.addrs[0], suite.addrs[1])
   193  			},
   194  			func(resp *feegrant.QueryAllowancesByGranterResponse) {
   195  				suite.Require().Equal(len(resp.Allowances), 1)
   196  				suite.Require().Equal(resp.Allowances[0].Granter, suite.addrs[0].String())
   197  				suite.Require().Equal(resp.Allowances[0].Grantee, suite.addrs[1].String())
   198  			},
   199  		},
   200  	}
   201  
   202  	for _, tc := range testCases {
   203  		suite.Run(tc.name, func() {
   204  			tc.preRun()
   205  			resp, err := suite.keeper.AllowancesByGranter(suite.ctx, tc.req)
   206  			if tc.expectErr {
   207  				suite.Require().Error(err)
   208  			} else {
   209  				suite.Require().NoError(err)
   210  				tc.postRun(resp)
   211  			}
   212  		})
   213  	}
   214  }
   215  
   216  func (suite *KeeperTestSuite) grantFeeAllowance(granter, grantee sdk.AccAddress) {
   217  	exp := suite.sdkCtx.BlockTime().AddDate(1, 0, 0)
   218  	err := suite.app.FeeGrantKeeper.GrantAllowance(suite.sdkCtx, granter, grantee, &feegrant.BasicAllowance{
   219  		SpendLimit: sdk.NewCoins(sdk.NewInt64Coin("atom", 555)),
   220  		Expiration: &exp,
   221  	})
   222  	suite.Require().NoError(err)
   223  }