github.com/Finschia/finschia-sdk@v0.48.1/x/token/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/types/query"
     6  	"github.com/Finschia/finschia-sdk/x/token"
     7  )
     8  
     9  func (s *KeeperTestSuite) TestQueryBalance() {
    10  	// empty request
    11  	_, err := s.queryServer.Balance(s.goCtx, nil)
    12  	s.Require().Error(err)
    13  
    14  	testCases := map[string]struct {
    15  		contractID string
    16  		address    sdk.AccAddress
    17  		valid      bool
    18  		postTest   func(res *token.QueryBalanceResponse)
    19  	}{
    20  		"valid request": {
    21  			contractID: s.contractID,
    22  			address:    s.vendor,
    23  			valid:      true,
    24  			postTest: func(res *token.QueryBalanceResponse) {
    25  				s.Require().Equal(s.balance, res.Amount)
    26  			},
    27  		},
    28  		"invalid contract id": {
    29  			address: s.vendor,
    30  		},
    31  		"invalid address": {
    32  			contractID: s.contractID,
    33  		},
    34  	}
    35  
    36  	for name, tc := range testCases {
    37  		s.Run(name, func() {
    38  			req := &token.QueryBalanceRequest{
    39  				ContractId: tc.contractID,
    40  				Address:    tc.address.String(),
    41  			}
    42  			res, err := s.queryServer.Balance(s.goCtx, req)
    43  			if !tc.valid {
    44  				s.Require().Error(err)
    45  				return
    46  			}
    47  			s.Require().NoError(err)
    48  			s.Require().NotNil(res)
    49  			tc.postTest(res)
    50  		})
    51  	}
    52  }
    53  
    54  func (s *KeeperTestSuite) TestQuerySupply() {
    55  	// empty request
    56  	_, err := s.queryServer.Supply(s.goCtx, nil)
    57  	s.Require().Error(err)
    58  
    59  	testCases := map[string]struct {
    60  		contractID string
    61  		reqType    string
    62  		valid      bool
    63  		postTest   func(res *token.QuerySupplyResponse)
    64  	}{
    65  		"valid supply request": {
    66  			contractID: s.contractID,
    67  			valid:      true,
    68  			postTest: func(res *token.QuerySupplyResponse) {
    69  				s.Require().Equal(s.balance.Mul(sdk.NewInt(3)), res.Amount)
    70  			},
    71  		},
    72  		"no such a contract id": {
    73  			contractID: "fee1dead",
    74  			valid:      true,
    75  			postTest: func(res *token.QuerySupplyResponse) {
    76  				s.Require().Equal(sdk.ZeroInt(), res.Amount)
    77  			},
    78  		},
    79  		"invalid contract id": {},
    80  	}
    81  
    82  	for name, tc := range testCases {
    83  		s.Run(name, func() {
    84  			req := &token.QuerySupplyRequest{
    85  				ContractId: tc.contractID,
    86  			}
    87  			res, err := s.queryServer.Supply(s.goCtx, req)
    88  			if !tc.valid {
    89  				s.Require().Error(err)
    90  				return
    91  			}
    92  			s.Require().NoError(err)
    93  			s.Require().NotNil(res)
    94  			tc.postTest(res)
    95  		})
    96  	}
    97  }
    98  
    99  func (s *KeeperTestSuite) TestQueryMinted() {
   100  	// empty request
   101  	_, err := s.queryServer.Minted(s.goCtx, nil)
   102  	s.Require().Error(err)
   103  
   104  	testCases := map[string]struct {
   105  		contractID string
   106  		valid      bool
   107  		postTest   func(res *token.QueryMintedResponse)
   108  	}{
   109  		"valid mint request": {
   110  			contractID: s.contractID,
   111  			valid:      true,
   112  			postTest: func(res *token.QueryMintedResponse) {
   113  				s.Require().Equal(s.balance.Mul(sdk.NewInt(4)), res.Amount)
   114  			},
   115  		},
   116  		"no such a contract id": {
   117  			contractID: "fee1dead",
   118  			valid:      true,
   119  			postTest: func(res *token.QueryMintedResponse) {
   120  				s.Require().Equal(sdk.ZeroInt(), res.Amount)
   121  			},
   122  		},
   123  		"invalid contract id": {},
   124  	}
   125  
   126  	for name, tc := range testCases {
   127  		s.Run(name, func() {
   128  			req := &token.QueryMintedRequest{
   129  				ContractId: tc.contractID,
   130  			}
   131  			res, err := s.queryServer.Minted(s.goCtx, req)
   132  			if !tc.valid {
   133  				s.Require().Error(err)
   134  				return
   135  			}
   136  			s.Require().NoError(err)
   137  			s.Require().NotNil(res)
   138  			tc.postTest(res)
   139  		})
   140  	}
   141  }
   142  
   143  func (s *KeeperTestSuite) TestQueryBurnt() {
   144  	// empty request
   145  	_, err := s.queryServer.Burnt(s.goCtx, nil)
   146  	s.Require().Error(err)
   147  
   148  	testCases := map[string]struct {
   149  		contractID string
   150  		valid      bool
   151  		postTest   func(res *token.QueryBurntResponse)
   152  	}{
   153  		"valid burn request": {
   154  			contractID: s.contractID,
   155  			valid:      true,
   156  			postTest: func(res *token.QueryBurntResponse) {
   157  				s.Require().Equal(s.balance, res.Amount)
   158  			},
   159  		},
   160  		"no such a contract id": {
   161  			contractID: "fee1dead",
   162  			valid:      true,
   163  			postTest: func(res *token.QueryBurntResponse) {
   164  				s.Require().Equal(sdk.ZeroInt(), res.Amount)
   165  			},
   166  		},
   167  		"invalid contract id": {},
   168  	}
   169  
   170  	for name, tc := range testCases {
   171  		s.Run(name, func() {
   172  			req := &token.QueryBurntRequest{
   173  				ContractId: tc.contractID,
   174  			}
   175  			res, err := s.queryServer.Burnt(s.goCtx, req)
   176  			if !tc.valid {
   177  				s.Require().Error(err)
   178  				return
   179  			}
   180  			s.Require().NoError(err)
   181  			s.Require().NotNil(res)
   182  			tc.postTest(res)
   183  		})
   184  	}
   185  }
   186  
   187  func (s *KeeperTestSuite) TestQueryContract() {
   188  	// empty request
   189  	_, err := s.queryServer.Contract(s.goCtx, nil)
   190  	s.Require().Error(err)
   191  
   192  	testCases := map[string]struct {
   193  		contractID string
   194  		valid      bool
   195  		postTest   func(res *token.QueryContractResponse)
   196  	}{
   197  		"valid request": {
   198  			contractID: s.contractID,
   199  			valid:      true,
   200  			postTest: func(res *token.QueryContractResponse) {
   201  				s.Require().Equal(s.contractID, res.Contract.Id)
   202  			},
   203  		},
   204  		"invalid contract id": {},
   205  		"no such an id": {
   206  			contractID: "00000000",
   207  		},
   208  	}
   209  
   210  	for name, tc := range testCases {
   211  		s.Run(name, func() {
   212  			req := &token.QueryContractRequest{
   213  				ContractId: tc.contractID,
   214  			}
   215  			res, err := s.queryServer.Contract(s.goCtx, req)
   216  			if !tc.valid {
   217  				s.Require().Error(err)
   218  				return
   219  			}
   220  			s.Require().NoError(err)
   221  			s.Require().NotNil(res)
   222  			tc.postTest(res)
   223  		})
   224  	}
   225  }
   226  
   227  func (s *KeeperTestSuite) TestQueryGranteeGrants() {
   228  	// empty request
   229  	_, err := s.queryServer.GranteeGrants(s.goCtx, nil)
   230  	s.Require().Error(err)
   231  
   232  	testCases := map[string]struct {
   233  		contractID string
   234  		grantee    sdk.AccAddress
   235  		valid      bool
   236  		postTest   func(res *token.QueryGranteeGrantsResponse)
   237  	}{
   238  		"valid request": {
   239  			contractID: s.contractID,
   240  			grantee:    s.vendor,
   241  			valid:      true,
   242  			postTest: func(res *token.QueryGranteeGrantsResponse) {
   243  				s.Require().Equal(3, len(res.Grants))
   244  			},
   245  		},
   246  		"class not found": {
   247  			contractID: "fee1dead",
   248  			grantee:    s.vendor,
   249  			valid:      true,
   250  			postTest: func(res *token.QueryGranteeGrantsResponse) {
   251  				s.Require().Equal(0, len(res.Grants))
   252  			},
   253  		},
   254  		"invalid contract id": {
   255  			grantee: s.vendor,
   256  		},
   257  		"invalid grantee": {
   258  			contractID: s.contractID,
   259  		},
   260  	}
   261  
   262  	for name, tc := range testCases {
   263  		s.Run(name, func() {
   264  			req := &token.QueryGranteeGrantsRequest{
   265  				ContractId: tc.contractID,
   266  				Grantee:    tc.grantee.String(),
   267  			}
   268  			res, err := s.queryServer.GranteeGrants(s.goCtx, req)
   269  			if !tc.valid {
   270  				s.Require().Error(err)
   271  				return
   272  			}
   273  			s.Require().NoError(err)
   274  			s.Require().NotNil(res)
   275  			tc.postTest(res)
   276  		})
   277  	}
   278  }
   279  
   280  func (s *KeeperTestSuite) TestQueryIsOperatorFor() {
   281  	// empty request
   282  	_, err := s.queryServer.IsOperatorFor(s.goCtx, nil)
   283  	s.Require().Error(err)
   284  
   285  	testCases := map[string]struct {
   286  		contractID string
   287  		operator   sdk.AccAddress
   288  		holder     sdk.AccAddress
   289  		valid      bool
   290  		postTest   func(res *token.QueryIsOperatorForResponse)
   291  	}{
   292  		"valid request": {
   293  			contractID: s.contractID,
   294  			operator:   s.operator,
   295  			holder:     s.customer,
   296  			valid:      true,
   297  			postTest: func(res *token.QueryIsOperatorForResponse) {
   298  				s.Require().True(res.Authorized)
   299  			},
   300  		},
   301  		"class not found": {
   302  			contractID: "fee1dead",
   303  			operator:   s.operator,
   304  			holder:     s.vendor,
   305  			valid:      true,
   306  			postTest: func(res *token.QueryIsOperatorForResponse) {
   307  				s.Require().False(res.Authorized)
   308  			},
   309  		},
   310  		"invalid contract id": {
   311  			operator: s.operator,
   312  			holder:   s.customer,
   313  		},
   314  		"invalid operator": {
   315  			contractID: s.contractID,
   316  			holder:     s.customer,
   317  		},
   318  		"invalid holder": {
   319  			contractID: s.contractID,
   320  			operator:   s.operator,
   321  		},
   322  	}
   323  
   324  	for name, tc := range testCases {
   325  		s.Run(name, func() {
   326  			req := &token.QueryIsOperatorForRequest{
   327  				ContractId: tc.contractID,
   328  				Operator:   tc.operator.String(),
   329  				Holder:     tc.holder.String(),
   330  			}
   331  			res, err := s.queryServer.IsOperatorFor(s.goCtx, req)
   332  			if !tc.valid {
   333  				s.Require().Error(err)
   334  				return
   335  			}
   336  			s.Require().NoError(err)
   337  			s.Require().NotNil(res)
   338  			tc.postTest(res)
   339  		})
   340  	}
   341  }
   342  
   343  func (s *KeeperTestSuite) TestQueryHoldersByOperator() {
   344  	// empty request
   345  	_, err := s.queryServer.HoldersByOperator(s.goCtx, nil)
   346  	s.Require().Error(err)
   347  
   348  	testCases := map[string]struct {
   349  		contractID string
   350  		operator   sdk.AccAddress
   351  		valid      bool
   352  		count      uint64
   353  		postTest   func(res *token.QueryHoldersByOperatorResponse)
   354  	}{
   355  		"valid request": {
   356  			contractID: s.contractID,
   357  			operator:   s.operator,
   358  			valid:      true,
   359  			postTest: func(res *token.QueryHoldersByOperatorResponse) {
   360  				s.Require().Equal(2, len(res.Holders))
   361  			},
   362  		},
   363  		"valid request with limit": {
   364  			contractID: s.contractID,
   365  			operator:   s.operator,
   366  			valid:      true,
   367  			count:      1,
   368  			postTest: func(res *token.QueryHoldersByOperatorResponse) {
   369  				s.Require().Equal(1, len(res.Holders))
   370  			},
   371  		},
   372  		"class not found": {
   373  			contractID: "fee1dead",
   374  			operator:   s.operator,
   375  			valid:      true,
   376  			postTest: func(res *token.QueryHoldersByOperatorResponse) {
   377  				s.Require().Equal(0, len(res.Holders))
   378  			},
   379  		},
   380  		"invalid contract id": {
   381  			operator: s.operator,
   382  		},
   383  		"invalid operator": {
   384  			contractID: s.contractID,
   385  		},
   386  	}
   387  
   388  	for name, tc := range testCases {
   389  		s.Run(name, func() {
   390  			pageReq := &query.PageRequest{}
   391  			if tc.count != 0 {
   392  				pageReq.Limit = tc.count
   393  			}
   394  			req := &token.QueryHoldersByOperatorRequest{
   395  				ContractId: tc.contractID,
   396  				Operator:   tc.operator.String(),
   397  				Pagination: pageReq,
   398  			}
   399  			res, err := s.queryServer.HoldersByOperator(s.goCtx, req)
   400  			if !tc.valid {
   401  				s.Require().Error(err)
   402  				return
   403  			}
   404  			s.Require().NoError(err)
   405  			s.Require().NotNil(res)
   406  			tc.postTest(res)
   407  		})
   408  	}
   409  }