github.com/Finschia/finschia-sdk@v0.49.1/x/authz/client/testutil/grpc.go (about)

     1  package testutil
     2  
     3  import (
     4  	"fmt"
     5  	"time"
     6  
     7  	"github.com/Finschia/finschia-sdk/client/flags"
     8  	"github.com/Finschia/finschia-sdk/testutil/rest"
     9  	sdk "github.com/Finschia/finschia-sdk/types"
    10  	"github.com/Finschia/finschia-sdk/x/authz"
    11  	"github.com/Finschia/finschia-sdk/x/authz/client/cli"
    12  	banktypes "github.com/Finschia/finschia-sdk/x/bank/types"
    13  )
    14  
    15  func (s *IntegrationTestSuite) TestQueryGrantGRPC() {
    16  	val := s.network.Validators[0]
    17  	grantee := s.grantee[1]
    18  	grantsURL := val.APIAddress + "/cosmos/authz/v1beta1/grants?granter=%s&grantee=%s&msg_type_url=%s"
    19  	testCases := []struct {
    20  		name      string
    21  		url       string
    22  		expectErr bool
    23  		errorMsg  string
    24  	}{
    25  		{
    26  			"fail invalid granter address",
    27  			fmt.Sprintf(grantsURL, "invalid_granter", grantee.String(), typeMsgSend),
    28  			true,
    29  			"decoding bech32 failed: invalid separator index -1",
    30  		},
    31  		{
    32  			"fail invalid grantee address",
    33  			fmt.Sprintf(grantsURL, val.Address.String(), "invalid_grantee", typeMsgSend),
    34  			true,
    35  			"decoding bech32 failed: invalid separator index -1",
    36  		},
    37  		{
    38  			"fail with empty granter",
    39  			fmt.Sprintf(grantsURL, "", grantee.String(), typeMsgSend),
    40  			true,
    41  			"empty address string is not allowed: invalid request",
    42  		},
    43  		{
    44  			"fail with empty grantee",
    45  			fmt.Sprintf(grantsURL, val.Address.String(), "", typeMsgSend),
    46  			true,
    47  			"empty address string is not allowed: invalid request",
    48  		},
    49  		{
    50  			"fail invalid msg-type",
    51  			fmt.Sprintf(grantsURL, val.Address.String(), grantee.String(), "invalidMsg"),
    52  			true,
    53  			"rpc error: code = NotFound desc = no authorization found for invalidMsg type: key not found",
    54  		},
    55  		{
    56  			"valid query",
    57  			fmt.Sprintf(grantsURL, val.Address.String(), grantee.String(), typeMsgSend),
    58  			false,
    59  			"",
    60  		},
    61  	}
    62  	for _, tc := range testCases {
    63  		s.Run(tc.name, func() {
    64  			resp, _ := rest.GetRequest(tc.url)
    65  			require := s.Require()
    66  			if tc.expectErr {
    67  				require.Contains(string(resp), tc.errorMsg)
    68  			} else {
    69  				var g authz.QueryGrantsResponse
    70  				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &g)
    71  				require.NoError(err)
    72  				require.Len(g.Grants, 1)
    73  				err = g.Grants[0].UnpackInterfaces(val.ClientCtx.InterfaceRegistry)
    74  				s.Require().NoError(err)
    75  				auth := g.Grants[0].GetAuthorization()
    76  				require.Equal(auth.MsgTypeURL(), banktypes.SendAuthorization{}.MsgTypeURL())
    77  			}
    78  		})
    79  	}
    80  }
    81  
    82  func (s *IntegrationTestSuite) TestQueryGrantsGRPC() {
    83  	val := s.network.Validators[0]
    84  	grantee := s.grantee[1]
    85  	grantsURL := val.APIAddress + "/cosmos/authz/v1beta1/grants?granter=%s&grantee=%s"
    86  	testCases := []struct {
    87  		name      string
    88  		url       string
    89  		expectErr bool
    90  		errMsg    string
    91  		preRun    func()
    92  		postRun   func(*authz.QueryGrantsResponse)
    93  	}{
    94  		{
    95  			"valid query: expect single grant",
    96  			fmt.Sprintf(grantsURL, val.Address.String(), grantee.String()),
    97  			false,
    98  			"",
    99  			func() {},
   100  			func(g *authz.QueryGrantsResponse) {
   101  				s.Require().Len(g.Grants, 1)
   102  			},
   103  		},
   104  		{
   105  			"valid query: expect two grants",
   106  			fmt.Sprintf(grantsURL, val.Address.String(), grantee.String()),
   107  			false,
   108  			"",
   109  			func() {
   110  				_, err := ExecGrant(val, []string{
   111  					grantee.String(),
   112  					"generic",
   113  					fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()),
   114  					fmt.Sprintf("--%s=%s", cli.FlagMsgType, typeMsgVote),
   115  					fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   116  					fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   117  					fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(10))).String()),
   118  					fmt.Sprintf("--%s=%d", cli.FlagExpiration, time.Now().Add(time.Minute*time.Duration(120)).Unix()),
   119  				})
   120  				s.Require().NoError(err)
   121  			},
   122  			func(g *authz.QueryGrantsResponse) {
   123  				s.Require().Len(g.Grants, 2)
   124  			},
   125  		},
   126  		{
   127  			"valid query: expect single grant with pagination",
   128  			fmt.Sprintf(grantsURL+"&pagination.limit=1", val.Address.String(), grantee.String()),
   129  			false,
   130  			"",
   131  			func() {},
   132  			func(g *authz.QueryGrantsResponse) {
   133  				s.Require().Len(g.Grants, 1)
   134  			},
   135  		},
   136  		{
   137  			"valid query: expect two grants with pagination",
   138  			fmt.Sprintf(grantsURL+"&pagination.limit=2", val.Address.String(), grantee.String()),
   139  			false,
   140  			"",
   141  			func() {},
   142  			func(g *authz.QueryGrantsResponse) {
   143  				s.Require().Len(g.Grants, 2)
   144  			},
   145  		},
   146  	}
   147  	for _, tc := range testCases {
   148  		s.Run(tc.name, func() {
   149  			tc.preRun()
   150  			resp, _ := rest.GetRequest(tc.url)
   151  			if tc.expectErr {
   152  				s.Require().Contains(string(resp), tc.errMsg)
   153  			} else {
   154  				var authorizations authz.QueryGrantsResponse
   155  				err := val.ClientCtx.Codec.UnmarshalJSON(resp, &authorizations)
   156  				s.Require().NoError(err)
   157  				tc.postRun(&authorizations)
   158  			}
   159  		})
   160  	}
   161  }