github.com/Finschia/finschia-sdk@v0.48.1/x/collection/keeper/send_test.go (about)

     1  package keeper_test
     2  
     3  import (
     4  	"fmt"
     5  
     6  	sdk "github.com/Finschia/finschia-sdk/types"
     7  	"github.com/Finschia/finschia-sdk/x/collection"
     8  )
     9  
    10  func (s *KeeperTestSuite) TestSendCoins() {
    11  	testCases := map[string]struct {
    12  		amount collection.Coin
    13  		err    error
    14  	}{
    15  		"valid send (fungible token)": {
    16  			amount: collection.NewFTCoin(s.ftClassID, s.balance),
    17  		},
    18  		"valid send (non-fungible token)": {
    19  			amount: collection.NewNFTCoin(s.nftClassID, 1),
    20  		},
    21  		"insufficient tokens": {
    22  			amount: collection.NewFTCoin(s.ftClassID, s.balance.Add(sdk.OneInt())),
    23  			err:    collection.ErrInsufficientToken,
    24  		},
    25  	}
    26  
    27  	for name, tc := range testCases {
    28  		s.Run(name, func() {
    29  			ctx, _ := s.ctx.CacheContext()
    30  
    31  			tokenID := tc.amount.TokenId
    32  			customerBalance := s.keeper.GetBalance(ctx, s.contractID, s.customer, tokenID)
    33  			operatorBalance := s.keeper.GetBalance(ctx, s.contractID, s.operator, tokenID)
    34  
    35  			err := s.keeper.SendCoins(ctx, s.contractID, s.customer, s.operator, collection.NewCoins(tc.amount))
    36  			s.Require().ErrorIs(err, tc.err)
    37  			if tc.err != nil {
    38  				return
    39  			}
    40  
    41  			newCustomerBalance := s.keeper.GetBalance(ctx, s.contractID, s.customer, tokenID)
    42  			newOperatorBalance := s.keeper.GetBalance(ctx, s.contractID, s.operator, tokenID)
    43  			s.Require().True(customerBalance.Sub(tc.amount.Amount).Equal(newCustomerBalance))
    44  			s.Require().True(operatorBalance.Add(tc.amount.Amount).Equal(newOperatorBalance))
    45  		})
    46  	}
    47  }
    48  
    49  func (s *KeeperTestSuite) TestAuthorizeOperator() {
    50  	userDescriptions := map[string]string{
    51  		s.vendor.String():   "vendor",
    52  		s.operator.String(): "operator",
    53  		s.customer.String(): "customer",
    54  	}
    55  	for operator, operatorDesc := range userDescriptions {
    56  		for from, fromDesc := range userDescriptions {
    57  			name := fmt.Sprintf("Operator: %s, From: %s", operatorDesc, fromDesc)
    58  			s.Run(name, func() {
    59  				ctx, _ := s.ctx.CacheContext()
    60  
    61  				fromAddr, err := sdk.AccAddressFromBech32(from)
    62  				s.Require().NoError(err)
    63  				operatorAddr, err := sdk.AccAddressFromBech32(operator)
    64  				s.Require().NoError(err)
    65  
    66  				_, queryErr := s.keeper.GetAuthorization(ctx, s.contractID, fromAddr, operatorAddr)
    67  				err = s.keeper.AuthorizeOperator(ctx, s.contractID, fromAddr, operatorAddr)
    68  				if queryErr == nil { // authorize must fail
    69  					s.Require().ErrorIs(err, collection.ErrCollectionAlreadyApproved)
    70  				} else {
    71  					s.Require().ErrorIs(queryErr, collection.ErrCollectionNotApproved)
    72  					s.Require().NoError(err)
    73  					_, queryErr := s.keeper.GetAuthorization(ctx, s.contractID, fromAddr, operatorAddr)
    74  					s.Require().NoError(queryErr)
    75  				}
    76  			})
    77  		}
    78  	}
    79  }
    80  
    81  func (s *KeeperTestSuite) TestRevokeOperator() {
    82  	userDescriptions := map[string]string{
    83  		s.vendor.String():   "vendor",
    84  		s.operator.String(): "operator",
    85  		s.customer.String(): "customer",
    86  	}
    87  	for operator, operatorDesc := range userDescriptions {
    88  		for from, fromDesc := range userDescriptions {
    89  			name := fmt.Sprintf("Operator: %s, From: %s", operatorDesc, fromDesc)
    90  			s.Run(name, func() {
    91  				ctx, _ := s.ctx.CacheContext()
    92  
    93  				fromAddr, err := sdk.AccAddressFromBech32(from)
    94  				s.Require().NoError(err)
    95  				operatorAddr, err := sdk.AccAddressFromBech32(operator)
    96  				s.Require().NoError(err)
    97  
    98  				_, queryErr := s.keeper.GetAuthorization(ctx, s.contractID, fromAddr, operatorAddr)
    99  				err = s.keeper.RevokeOperator(ctx, s.contractID, fromAddr, operatorAddr)
   100  				if queryErr != nil { // revoke must fail
   101  					s.Require().ErrorIs(queryErr, collection.ErrCollectionNotApproved)
   102  					s.Require().ErrorIs(err, collection.ErrCollectionNotApproved)
   103  				} else {
   104  					s.Require().NoError(err)
   105  					_, queryErr := s.keeper.GetAuthorization(ctx, s.contractID, fromAddr, operatorAddr)
   106  					s.Require().ErrorIs(queryErr, collection.ErrCollectionNotApproved)
   107  				}
   108  			})
   109  		}
   110  	}
   111  }