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

     1  package testutil
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/Finschia/finschia-sdk/client/flags"
     7  	clitestutil "github.com/Finschia/finschia-sdk/testutil/cli"
     8  	sdk "github.com/Finschia/finschia-sdk/types"
     9  	"github.com/Finschia/finschia-sdk/x/collection"
    10  	"github.com/Finschia/finschia-sdk/x/collection/client/cli"
    11  )
    12  
    13  func (s *IntegrationTestSuite) TestNewTxCmdSendFT() {
    14  	val := s.network.Validators[0]
    15  	commonArgs := []string{
    16  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
    17  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
    18  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
    19  	}
    20  
    21  	amount := collection.NewCoins(collection.NewFTCoin(s.ftClassID, s.balance))
    22  	testCases := map[string]struct {
    23  		args  []string
    24  		valid bool
    25  	}{
    26  		"valid transaction": {
    27  			[]string{
    28  				s.contractID,
    29  				s.stranger.String(),
    30  				s.customer.String(),
    31  				amount.String(),
    32  			},
    33  			true,
    34  		},
    35  		"extra args": {
    36  			[]string{
    37  				s.contractID,
    38  				s.stranger.String(),
    39  				s.customer.String(),
    40  				amount.String(),
    41  				"extra",
    42  			},
    43  			false,
    44  		},
    45  		"not enough args": {
    46  			[]string{
    47  				s.contractID,
    48  				s.stranger.String(),
    49  				s.customer.String(),
    50  			},
    51  			false,
    52  		},
    53  		"amount out of range": {
    54  			[]string{
    55  				s.contractID,
    56  				s.stranger.String(),
    57  				s.customer.String(),
    58  				fmt.Sprintf("%s:1%0127d", s.ftClassID, 0),
    59  			},
    60  			false,
    61  		},
    62  		"invalid contract id": {
    63  			[]string{
    64  				"",
    65  				s.stranger.String(),
    66  				s.customer.String(),
    67  				amount.String(),
    68  			},
    69  			false,
    70  		},
    71  	}
    72  
    73  	for name, tc := range testCases {
    74  		s.Run(name, func() {
    75  			cmd := cli.NewTxCmdSendFT()
    76  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
    77  			if !tc.valid {
    78  				s.Require().Error(err)
    79  				return
    80  			}
    81  			s.Require().NoError(err)
    82  
    83  			var res sdk.TxResponse
    84  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
    85  			s.Require().EqualValues(0, res.Code, out.String())
    86  		})
    87  	}
    88  }
    89  
    90  func (s *IntegrationTestSuite) TestNewTxCmdOperatorSendFT() {
    91  	val := s.network.Validators[0]
    92  	commonArgs := []string{
    93  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
    94  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
    95  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
    96  	}
    97  
    98  	amount := collection.NewCoins(collection.NewFTCoin(s.ftClassID, s.balance))
    99  	testCases := map[string]struct {
   100  		args  []string
   101  		valid bool
   102  	}{
   103  		"valid transaction": {
   104  			[]string{
   105  				s.contractID,
   106  				s.operator.String(),
   107  				s.customer.String(),
   108  				s.vendor.String(),
   109  				amount.String(),
   110  			},
   111  			true,
   112  		},
   113  		"extra args": {
   114  			[]string{
   115  				s.contractID,
   116  				s.operator.String(),
   117  				s.customer.String(),
   118  				s.vendor.String(),
   119  				amount.String(),
   120  				"extra",
   121  			},
   122  			false,
   123  		},
   124  		"not enough args": {
   125  			[]string{
   126  				s.contractID,
   127  				s.operator.String(),
   128  				s.customer.String(),
   129  				s.vendor.String(),
   130  			},
   131  			false,
   132  		},
   133  		"amount out of range": {
   134  			[]string{
   135  				s.contractID,
   136  				s.operator.String(),
   137  				s.customer.String(),
   138  				s.vendor.String(),
   139  				fmt.Sprintf("%s:1%0127d", s.ftClassID, 0),
   140  			},
   141  			false,
   142  		},
   143  		"invalid contract id": {
   144  			[]string{
   145  				"",
   146  				s.operator.String(),
   147  				s.customer.String(),
   148  				s.vendor.String(),
   149  				amount.String(),
   150  			},
   151  			false,
   152  		},
   153  	}
   154  
   155  	for name, tc := range testCases {
   156  		s.Run(name, func() {
   157  			cmd := cli.NewTxCmdOperatorSendFT()
   158  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   159  			if !tc.valid {
   160  				s.Require().Error(err)
   161  				return
   162  			}
   163  			s.Require().NoError(err)
   164  
   165  			var res sdk.TxResponse
   166  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   167  			s.Require().EqualValues(0, res.Code, out.String())
   168  		})
   169  	}
   170  }
   171  
   172  func (s *IntegrationTestSuite) TestNewTxCmdSendNFT() {
   173  	val := s.network.Validators[0]
   174  	commonArgs := []string{
   175  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   176  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   177  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   178  	}
   179  
   180  	tokenID := collection.NewNFTID(s.nftClassID, s.lenChain*3*3+1)
   181  	testCases := map[string]struct {
   182  		args  []string
   183  		valid bool
   184  	}{
   185  		"valid transaction": {
   186  			[]string{
   187  				s.contractID,
   188  				s.stranger.String(),
   189  				s.customer.String(),
   190  				tokenID,
   191  			},
   192  			true,
   193  		},
   194  		"extra args": {
   195  			[]string{
   196  				s.contractID,
   197  				s.stranger.String(),
   198  				s.customer.String(),
   199  				tokenID,
   200  				"extra",
   201  			},
   202  			false,
   203  		},
   204  		"not enough args": {
   205  			[]string{
   206  				s.contractID,
   207  				s.stranger.String(),
   208  				s.customer.String(),
   209  			},
   210  			false,
   211  		},
   212  		"amount out of range": {
   213  			[]string{
   214  				s.contractID,
   215  				s.stranger.String(),
   216  				s.customer.String(),
   217  				fmt.Sprintf("%s:1%0127d", s.ftClassID, 0),
   218  			},
   219  			false,
   220  		},
   221  		"invalid contract id": {
   222  			[]string{
   223  				"",
   224  				s.stranger.String(),
   225  				s.customer.String(),
   226  				tokenID,
   227  			},
   228  			false,
   229  		},
   230  	}
   231  
   232  	for name, tc := range testCases {
   233  		s.Run(name, func() {
   234  			cmd := cli.NewTxCmdSendNFT()
   235  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   236  			if !tc.valid {
   237  				s.Require().Error(err)
   238  				return
   239  			}
   240  			s.Require().NoError(err)
   241  
   242  			var res sdk.TxResponse
   243  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   244  			s.Require().EqualValues(0, res.Code, out.String())
   245  		})
   246  	}
   247  }
   248  
   249  func (s *IntegrationTestSuite) TestNewTxCmdOperatorSendNFT() {
   250  	val := s.network.Validators[0]
   251  	commonArgs := []string{
   252  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   253  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   254  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   255  	}
   256  
   257  	tokenID := collection.NewNFTID(s.nftClassID, 1)
   258  	testCases := map[string]struct {
   259  		args  []string
   260  		valid bool
   261  	}{
   262  		"valid transaction": {
   263  			[]string{
   264  				s.contractID,
   265  				s.operator.String(),
   266  				s.customer.String(),
   267  				s.vendor.String(),
   268  				tokenID,
   269  			},
   270  			true,
   271  		},
   272  		"extra args": {
   273  			[]string{
   274  				s.contractID,
   275  				s.operator.String(),
   276  				s.customer.String(),
   277  				s.vendor.String(),
   278  				tokenID,
   279  				"extra",
   280  			},
   281  			false,
   282  		},
   283  		"not enough args": {
   284  			[]string{
   285  				s.contractID,
   286  				s.operator.String(),
   287  				s.customer.String(),
   288  				s.vendor.String(),
   289  			},
   290  			false,
   291  		},
   292  		"amount out of range": {
   293  			[]string{
   294  				s.contractID,
   295  				s.operator.String(),
   296  				s.customer.String(),
   297  				s.vendor.String(),
   298  				fmt.Sprintf("%s:1%0127d", s.ftClassID, 0),
   299  			},
   300  			false,
   301  		},
   302  		"invalid contract id": {
   303  			[]string{
   304  				"",
   305  				s.operator.String(),
   306  				s.customer.String(),
   307  				s.vendor.String(),
   308  				tokenID,
   309  			},
   310  			false,
   311  		},
   312  	}
   313  
   314  	for name, tc := range testCases {
   315  		s.Run(name, func() {
   316  			cmd := cli.NewTxCmdOperatorSendNFT()
   317  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   318  			if !tc.valid {
   319  				s.Require().Error(err)
   320  				return
   321  			}
   322  			s.Require().NoError(err)
   323  
   324  			var res sdk.TxResponse
   325  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   326  			s.Require().EqualValues(0, res.Code, out.String())
   327  		})
   328  	}
   329  }
   330  
   331  func (s *IntegrationTestSuite) TestNewTxCmdCreateContract() {
   332  	val := s.network.Validators[0]
   333  	commonArgs := []string{
   334  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   335  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   336  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   337  	}
   338  
   339  	testCases := map[string]struct {
   340  		args  []string
   341  		valid bool
   342  	}{
   343  		"valid transaction": {
   344  			[]string{
   345  				s.vendor.String(),
   346  			},
   347  			true,
   348  		},
   349  		"extra args": {
   350  			[]string{
   351  				s.vendor.String(),
   352  				"extra",
   353  			},
   354  			false,
   355  		},
   356  		"not enough args": {
   357  			[]string{},
   358  			false,
   359  		},
   360  		"invalid creator": {
   361  			[]string{
   362  				"",
   363  			},
   364  			false,
   365  		},
   366  	}
   367  
   368  	for name, tc := range testCases {
   369  		s.Run(name, func() {
   370  			cmd := cli.NewTxCmdCreateContract()
   371  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   372  			if !tc.valid {
   373  				s.Require().Error(err)
   374  				return
   375  			}
   376  			s.Require().NoError(err)
   377  
   378  			var res sdk.TxResponse
   379  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   380  			s.Require().EqualValues(0, res.Code, out.String())
   381  		})
   382  	}
   383  }
   384  
   385  func (s *IntegrationTestSuite) TestNewTxCmdIssueFT() {
   386  	val := s.network.Validators[0]
   387  	commonArgs := []string{
   388  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   389  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   390  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   391  	}
   392  
   393  	testCases := map[string]struct {
   394  		args  []string
   395  		valid bool
   396  	}{
   397  		"valid transaction": {
   398  			[]string{
   399  				s.contractID,
   400  				s.operator.String(),
   401  				fmt.Sprintf("--%s=%s", cli.FlagName, "tibetian fox"),
   402  				fmt.Sprintf("--%s=%s", cli.FlagTo, s.operator),
   403  			},
   404  			true,
   405  		},
   406  		"extra args": {
   407  			[]string{
   408  				s.contractID,
   409  				s.operator.String(),
   410  				"extra",
   411  				fmt.Sprintf("--%s=%s", cli.FlagName, "tibetian fox"),
   412  				fmt.Sprintf("--%s=%s", cli.FlagTo, s.operator),
   413  			},
   414  			false,
   415  		},
   416  		"not enough args": {
   417  			[]string{
   418  				s.contractID,
   419  				fmt.Sprintf("--%s=%s", cli.FlagName, "tibetian fox"),
   420  				fmt.Sprintf("--%s=%s", cli.FlagTo, s.operator),
   421  			},
   422  			false,
   423  		},
   424  		"invalid contract id": {
   425  			[]string{
   426  				"",
   427  				s.operator.String(),
   428  			},
   429  			false,
   430  		},
   431  	}
   432  
   433  	for name, tc := range testCases {
   434  		s.Run(name, func() {
   435  			cmd := cli.NewTxCmdIssueFT()
   436  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   437  			if !tc.valid {
   438  				s.Require().Error(err)
   439  				return
   440  			}
   441  			s.Require().NoError(err)
   442  
   443  			var res sdk.TxResponse
   444  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   445  			s.Require().EqualValues(0, res.Code, out.String())
   446  		})
   447  	}
   448  }
   449  
   450  func (s *IntegrationTestSuite) TestNewTxCmdIssueNFT() {
   451  	val := s.network.Validators[0]
   452  	commonArgs := []string{
   453  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   454  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   455  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   456  	}
   457  
   458  	testCases := map[string]struct {
   459  		args  []string
   460  		valid bool
   461  	}{
   462  		"valid transaction": {
   463  			[]string{
   464  				s.contractID,
   465  				s.operator.String(),
   466  			},
   467  			true,
   468  		},
   469  		"extra args": {
   470  			[]string{
   471  				s.contractID,
   472  				s.operator.String(),
   473  				"extra",
   474  			},
   475  			false,
   476  		},
   477  		"not enough args": {
   478  			[]string{
   479  				s.contractID,
   480  			},
   481  			false,
   482  		},
   483  		"invalid contract id": {
   484  			[]string{
   485  				"",
   486  				s.operator.String(),
   487  			},
   488  			false,
   489  		},
   490  	}
   491  
   492  	for name, tc := range testCases {
   493  		s.Run(name, func() {
   494  			cmd := cli.NewTxCmdIssueNFT()
   495  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   496  			if !tc.valid {
   497  				s.Require().Error(err)
   498  				return
   499  			}
   500  			s.Require().NoError(err)
   501  
   502  			var res sdk.TxResponse
   503  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   504  			s.Require().EqualValues(0, res.Code, out.String())
   505  		})
   506  	}
   507  }
   508  
   509  func (s *IntegrationTestSuite) TestNewTxCmdMintFT() {
   510  	val := s.network.Validators[0]
   511  	commonArgs := []string{
   512  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   513  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   514  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   515  	}
   516  
   517  	testCases := map[string]struct {
   518  		args  []string
   519  		valid bool
   520  	}{
   521  		"valid transaction": {
   522  			[]string{
   523  				s.contractID,
   524  				s.operator.String(),
   525  				s.customer.String(),
   526  				s.ftClassID,
   527  				s.balance.String(),
   528  			},
   529  			true,
   530  		},
   531  		"extra args": {
   532  			[]string{
   533  				s.contractID,
   534  				s.operator.String(),
   535  				s.customer.String(),
   536  				s.ftClassID,
   537  				s.balance.String(),
   538  				"extra",
   539  			},
   540  			false,
   541  		},
   542  		"not enough args": {
   543  			[]string{
   544  				s.contractID,
   545  				s.operator.String(),
   546  				s.customer.String(),
   547  				s.ftClassID,
   548  			},
   549  			false,
   550  		},
   551  		"invalid contract id": {
   552  			[]string{
   553  				"",
   554  				s.operator.String(),
   555  				s.customer.String(),
   556  				s.ftClassID,
   557  				s.balance.String(),
   558  			},
   559  			false,
   560  		},
   561  	}
   562  
   563  	for name, tc := range testCases {
   564  		s.Run(name, func() {
   565  			cmd := cli.NewTxCmdMintFT()
   566  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   567  			if !tc.valid {
   568  				s.Require().Error(err)
   569  				return
   570  			}
   571  			s.Require().NoError(err)
   572  
   573  			var res sdk.TxResponse
   574  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   575  			s.Require().EqualValues(0, res.Code, out.String())
   576  		})
   577  	}
   578  }
   579  
   580  func (s *IntegrationTestSuite) TestNewTxCmdMintNFT() {
   581  	val := s.network.Validators[0]
   582  	commonArgs := []string{
   583  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   584  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   585  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   586  	}
   587  
   588  	testCases := map[string]struct {
   589  		args  []string
   590  		valid bool
   591  	}{
   592  		"valid transaction": {
   593  			[]string{
   594  				s.contractID,
   595  				s.operator.String(),
   596  				s.customer.String(),
   597  				s.nftClassID,
   598  				fmt.Sprintf("--%s=%s", cli.FlagName, "arctic fox"),
   599  			},
   600  			true,
   601  		},
   602  		"extra args": {
   603  			[]string{
   604  				s.contractID,
   605  				s.operator.String(),
   606  				s.customer.String(),
   607  				s.nftClassID,
   608  				"extra",
   609  			},
   610  			false,
   611  		},
   612  		"not enough args": {
   613  			[]string{
   614  				s.contractID,
   615  				s.operator.String(),
   616  				s.customer.String(),
   617  			},
   618  			false,
   619  		},
   620  		"invalid contract id": {
   621  			[]string{
   622  				"",
   623  				s.operator.String(),
   624  				s.customer.String(),
   625  				s.nftClassID,
   626  			},
   627  			false,
   628  		},
   629  	}
   630  
   631  	for name, tc := range testCases {
   632  		s.Run(name, func() {
   633  			cmd := cli.NewTxCmdMintNFT()
   634  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   635  			if !tc.valid {
   636  				s.Require().Error(err)
   637  				return
   638  			}
   639  			s.Require().NoError(err)
   640  
   641  			var res sdk.TxResponse
   642  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   643  			s.Require().EqualValues(0, res.Code, out.String())
   644  		})
   645  	}
   646  }
   647  
   648  func (s *IntegrationTestSuite) TestNewTxCmdBurnFT() {
   649  	val := s.network.Validators[0]
   650  	commonArgs := []string{
   651  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   652  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   653  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   654  	}
   655  
   656  	amount := collection.NewCoins(collection.NewFTCoin(s.ftClassID, s.balance))
   657  	testCases := map[string]struct {
   658  		args  []string
   659  		valid bool
   660  	}{
   661  		"valid transaction": {
   662  			[]string{
   663  				s.contractID,
   664  				s.operator.String(),
   665  				amount.String(),
   666  			},
   667  			true,
   668  		},
   669  		"extra args": {
   670  			[]string{
   671  				s.contractID,
   672  				s.operator.String(),
   673  				amount.String(),
   674  				"extra",
   675  			},
   676  			false,
   677  		},
   678  		"not enough args": {
   679  			[]string{
   680  				s.contractID,
   681  				s.operator.String(),
   682  			},
   683  			false,
   684  		},
   685  		"invalid contract id": {
   686  			[]string{
   687  				"",
   688  				s.operator.String(),
   689  				amount.String(),
   690  			},
   691  			false,
   692  		},
   693  	}
   694  
   695  	for name, tc := range testCases {
   696  		s.Run(name, func() {
   697  			cmd := cli.NewTxCmdBurnFT()
   698  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   699  			if !tc.valid {
   700  				s.Require().Error(err)
   701  				return
   702  			}
   703  			s.Require().NoError(err)
   704  
   705  			var res sdk.TxResponse
   706  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   707  			s.Require().EqualValues(0, res.Code, out.String())
   708  		})
   709  	}
   710  }
   711  
   712  func (s *IntegrationTestSuite) TestNewTxCmdOperatorBurnFT() {
   713  	val := s.network.Validators[0]
   714  	commonArgs := []string{
   715  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   716  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   717  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   718  	}
   719  
   720  	amount := collection.NewCoins(collection.NewFTCoin(s.ftClassID, s.balance))
   721  	testCases := map[string]struct {
   722  		args  []string
   723  		valid bool
   724  	}{
   725  		"valid transaction": {
   726  			[]string{
   727  				s.contractID,
   728  				s.operator.String(),
   729  				s.vendor.String(),
   730  				amount.String(),
   731  			},
   732  			true,
   733  		},
   734  		"extra args": {
   735  			[]string{
   736  				s.contractID,
   737  				s.operator.String(),
   738  				s.vendor.String(),
   739  				amount.String(),
   740  				"extra",
   741  			},
   742  			false,
   743  		},
   744  		"not enough args": {
   745  			[]string{
   746  				s.contractID,
   747  				s.operator.String(),
   748  				s.vendor.String(),
   749  			},
   750  			false,
   751  		},
   752  		"invalid contract id": {
   753  			[]string{
   754  				"",
   755  				s.operator.String(),
   756  				s.vendor.String(),
   757  				amount.String(),
   758  			},
   759  			false,
   760  		},
   761  	}
   762  
   763  	for name, tc := range testCases {
   764  		s.Run(name, func() {
   765  			cmd := cli.NewTxCmdOperatorBurnFT()
   766  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   767  			if !tc.valid {
   768  				s.Require().Error(err)
   769  				return
   770  			}
   771  			s.Require().NoError(err)
   772  
   773  			var res sdk.TxResponse
   774  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   775  			s.Require().EqualValues(0, res.Code, out.String())
   776  		})
   777  	}
   778  }
   779  
   780  func (s *IntegrationTestSuite) TestNewTxCmdBurnNFT() {
   781  	val := s.network.Validators[0]
   782  	commonArgs := []string{
   783  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   784  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   785  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   786  	}
   787  
   788  	tokenID := collection.NewNFTID(s.nftClassID, s.lenChain*3+1)
   789  	testCases := map[string]struct {
   790  		args  []string
   791  		valid bool
   792  	}{
   793  		"valid transaction": {
   794  			[]string{
   795  				s.contractID,
   796  				s.operator.String(),
   797  				tokenID,
   798  			},
   799  			true,
   800  		},
   801  		"extra args": {
   802  			[]string{
   803  				s.contractID,
   804  				s.operator.String(),
   805  				tokenID,
   806  				"extra",
   807  			},
   808  			false,
   809  		},
   810  		"not enough args": {
   811  			[]string{
   812  				s.contractID,
   813  				s.operator.String(),
   814  			},
   815  			false,
   816  		},
   817  		"invalid contract id": {
   818  			[]string{
   819  				"",
   820  				s.operator.String(),
   821  				tokenID,
   822  			},
   823  			false,
   824  		},
   825  	}
   826  
   827  	for name, tc := range testCases {
   828  		s.Run(name, func() {
   829  			cmd := cli.NewTxCmdBurnNFT()
   830  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   831  			if !tc.valid {
   832  				s.Require().Error(err)
   833  				return
   834  			}
   835  			s.Require().NoError(err)
   836  
   837  			var res sdk.TxResponse
   838  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   839  			s.Require().EqualValues(0, res.Code, out.String())
   840  		})
   841  	}
   842  }
   843  
   844  func (s *IntegrationTestSuite) TestNewTxCmdOperatorOperatorBurnNFT() {
   845  	val := s.network.Validators[0]
   846  	commonArgs := []string{
   847  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   848  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   849  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   850  	}
   851  
   852  	tokenID := collection.NewNFTID(s.nftClassID, s.lenChain*3*2+1)
   853  	testCases := map[string]struct {
   854  		args  []string
   855  		valid bool
   856  	}{
   857  		"valid transaction": {
   858  			[]string{
   859  				s.contractID,
   860  				s.operator.String(),
   861  				s.vendor.String(),
   862  				tokenID,
   863  			},
   864  			true,
   865  		},
   866  		"extra args": {
   867  			[]string{
   868  				s.contractID,
   869  				s.operator.String(),
   870  				s.vendor.String(),
   871  				tokenID,
   872  				"extra",
   873  			},
   874  			false,
   875  		},
   876  		"not enough args": {
   877  			[]string{
   878  				s.contractID,
   879  				s.operator.String(),
   880  				s.vendor.String(),
   881  			},
   882  			false,
   883  		},
   884  		"invalid contract id": {
   885  			[]string{
   886  				"",
   887  				s.operator.String(),
   888  				s.vendor.String(),
   889  				tokenID,
   890  			},
   891  			false,
   892  		},
   893  	}
   894  
   895  	for name, tc := range testCases {
   896  		s.Run(name, func() {
   897  			cmd := cli.NewTxCmdOperatorBurnNFT()
   898  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   899  			if !tc.valid {
   900  				s.Require().Error(err)
   901  				return
   902  			}
   903  			s.Require().NoError(err)
   904  
   905  			var res sdk.TxResponse
   906  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   907  			s.Require().EqualValues(0, res.Code, out.String())
   908  		})
   909  	}
   910  }
   911  
   912  func (s *IntegrationTestSuite) TestNewTxCmdModify() {
   913  	val := s.network.Validators[0]
   914  	commonArgs := []string{
   915  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   916  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   917  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   918  	}
   919  
   920  	testCases := map[string]struct {
   921  		args  []string
   922  		valid bool
   923  	}{
   924  		"valid transaction": {
   925  			[]string{
   926  				s.contractID,
   927  				s.operator.String(),
   928  				s.nftClassID,
   929  				"",
   930  				collection.AttributeKeyName.String(),
   931  				"tibetian fox",
   932  			},
   933  			true,
   934  		},
   935  		"extra args": {
   936  			[]string{
   937  				s.contractID,
   938  				s.operator.String(),
   939  				s.nftClassID,
   940  				"",
   941  				collection.AttributeKeyName.String(),
   942  				"tibetian fox",
   943  				"extra",
   944  			},
   945  			false,
   946  		},
   947  		"not enough args": {
   948  			[]string{
   949  				s.contractID,
   950  				s.operator.String(),
   951  				s.nftClassID,
   952  				"",
   953  				collection.AttributeKeyName.String(),
   954  			},
   955  			false,
   956  		},
   957  		"invalid contract id": {
   958  			[]string{
   959  				"",
   960  				s.operator.String(),
   961  				s.nftClassID,
   962  				"",
   963  				collection.AttributeKeyName.String(),
   964  				"tibetian fox",
   965  			},
   966  			false,
   967  		},
   968  	}
   969  
   970  	for name, tc := range testCases {
   971  		s.Run(name, func() {
   972  			cmd := cli.NewTxCmdModify()
   973  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   974  			if !tc.valid {
   975  				s.Require().Error(err)
   976  				return
   977  			}
   978  			s.Require().NoError(err)
   979  
   980  			var res sdk.TxResponse
   981  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   982  			s.Require().EqualValues(0, res.Code, out.String())
   983  		})
   984  	}
   985  }
   986  
   987  func (s *IntegrationTestSuite) TestNewTxCmdAttach() {
   988  	val := s.network.Validators[0]
   989  	commonArgs := []string{
   990  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   991  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   992  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   993  	}
   994  
   995  	subjectID := collection.NewNFTID(s.nftClassID, s.lenChain*(3*2+1)+1)
   996  	targetID := collection.NewNFTID(s.nftClassID, s.lenChain*(3*2+2)+1)
   997  	testCases := map[string]struct {
   998  		args  []string
   999  		valid bool
  1000  	}{
  1001  		"valid transaction": {
  1002  			[]string{
  1003  				s.contractID,
  1004  				s.vendor.String(),
  1005  				subjectID,
  1006  				targetID,
  1007  			},
  1008  			true,
  1009  		},
  1010  		"extra args": {
  1011  			[]string{
  1012  				s.contractID,
  1013  				s.vendor.String(),
  1014  				subjectID,
  1015  				targetID,
  1016  				"extra",
  1017  			},
  1018  			false,
  1019  		},
  1020  		"not enough args": {
  1021  			[]string{
  1022  				s.contractID,
  1023  				s.vendor.String(),
  1024  				subjectID,
  1025  			},
  1026  			false,
  1027  		},
  1028  		"invalid contract id": {
  1029  			[]string{
  1030  				"",
  1031  				s.vendor.String(),
  1032  				subjectID,
  1033  				targetID,
  1034  			},
  1035  			false,
  1036  		},
  1037  	}
  1038  
  1039  	for name, tc := range testCases {
  1040  		s.Run(name, func() {
  1041  			cmd := cli.NewTxCmdAttach()
  1042  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1043  			if !tc.valid {
  1044  				s.Require().Error(err)
  1045  				return
  1046  			}
  1047  			s.Require().NoError(err)
  1048  
  1049  			var res sdk.TxResponse
  1050  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1051  			s.Require().EqualValues(0, res.Code, out.String())
  1052  		})
  1053  	}
  1054  }
  1055  
  1056  func (s *IntegrationTestSuite) TestNewTxCmdDetach() {
  1057  	val := s.network.Validators[0]
  1058  	commonArgs := []string{
  1059  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1060  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1061  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1062  	}
  1063  
  1064  	subjectID := collection.NewNFTID(s.nftClassID, s.lenChain*(3*3+1)+2)
  1065  	testCases := map[string]struct {
  1066  		args  []string
  1067  		valid bool
  1068  	}{
  1069  		"valid transaction": {
  1070  			[]string{
  1071  				s.contractID,
  1072  				s.stranger.String(),
  1073  				subjectID,
  1074  			},
  1075  			true,
  1076  		},
  1077  		"extra args": {
  1078  			[]string{
  1079  				s.contractID,
  1080  				s.stranger.String(),
  1081  				subjectID,
  1082  				"extra",
  1083  			},
  1084  			false,
  1085  		},
  1086  		"not enough args": {
  1087  			[]string{
  1088  				s.contractID,
  1089  				s.stranger.String(),
  1090  			},
  1091  			false,
  1092  		},
  1093  		"invalid contract id": {
  1094  			[]string{
  1095  				"",
  1096  				s.stranger.String(),
  1097  				subjectID,
  1098  			},
  1099  			false,
  1100  		},
  1101  	}
  1102  
  1103  	for name, tc := range testCases {
  1104  		s.Run(name, func() {
  1105  			cmd := cli.NewTxCmdDetach()
  1106  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1107  			if !tc.valid {
  1108  				s.Require().Error(err)
  1109  				return
  1110  			}
  1111  			s.Require().NoError(err)
  1112  
  1113  			var res sdk.TxResponse
  1114  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1115  			s.Require().EqualValues(0, res.Code, out.String())
  1116  		})
  1117  	}
  1118  }
  1119  
  1120  func (s *IntegrationTestSuite) TestNewTxCmdOperatorAttach() {
  1121  	val := s.network.Validators[0]
  1122  	commonArgs := []string{
  1123  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1124  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1125  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1126  	}
  1127  
  1128  	subjectID := collection.NewNFTID(s.nftClassID, s.lenChain*2+1)
  1129  	targetID := collection.NewNFTID(s.nftClassID, s.lenChain+1)
  1130  	testCases := map[string]struct {
  1131  		args  []string
  1132  		valid bool
  1133  	}{
  1134  		"valid transaction": {
  1135  			[]string{
  1136  				s.contractID,
  1137  				s.operator.String(),
  1138  				s.customer.String(),
  1139  				subjectID,
  1140  				targetID,
  1141  			},
  1142  			true,
  1143  		},
  1144  		"extra args": {
  1145  			[]string{
  1146  				s.contractID,
  1147  				s.operator.String(),
  1148  				s.customer.String(),
  1149  				subjectID,
  1150  				targetID,
  1151  				"extra",
  1152  			},
  1153  			false,
  1154  		},
  1155  		"not enough args": {
  1156  			[]string{
  1157  				s.contractID,
  1158  				s.operator.String(),
  1159  				s.customer.String(),
  1160  				subjectID,
  1161  			},
  1162  			false,
  1163  		},
  1164  		"invalid contract id": {
  1165  			[]string{
  1166  				"",
  1167  				s.operator.String(),
  1168  				s.customer.String(),
  1169  				subjectID,
  1170  				targetID,
  1171  			},
  1172  			false,
  1173  		},
  1174  	}
  1175  
  1176  	for name, tc := range testCases {
  1177  		s.Run(name, func() {
  1178  			cmd := cli.NewTxCmdOperatorAttach()
  1179  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1180  			if !tc.valid {
  1181  				s.Require().Error(err)
  1182  				return
  1183  			}
  1184  			s.Require().NoError(err)
  1185  
  1186  			var res sdk.TxResponse
  1187  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1188  			s.Require().EqualValues(0, res.Code, out.String())
  1189  		})
  1190  	}
  1191  }
  1192  
  1193  func (s *IntegrationTestSuite) TestNewTxCmdOperatorDetach() {
  1194  	val := s.network.Validators[0]
  1195  	commonArgs := []string{
  1196  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1197  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1198  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1199  	}
  1200  
  1201  	subjectID := collection.NewNFTID(s.nftClassID, s.lenChain*3*3)
  1202  	testCases := map[string]struct {
  1203  		args  []string
  1204  		valid bool
  1205  	}{
  1206  		"valid transaction": {
  1207  			[]string{
  1208  				s.contractID,
  1209  				s.operator.String(),
  1210  				s.vendor.String(),
  1211  				subjectID,
  1212  			},
  1213  			true,
  1214  		},
  1215  		"extra args": {
  1216  			[]string{
  1217  				s.contractID,
  1218  				s.operator.String(),
  1219  				s.vendor.String(),
  1220  				subjectID,
  1221  				"extra",
  1222  			},
  1223  			false,
  1224  		},
  1225  		"not enough args": {
  1226  			[]string{
  1227  				s.contractID,
  1228  				s.operator.String(),
  1229  				s.vendor.String(),
  1230  			},
  1231  			false,
  1232  		},
  1233  		"invalid contract id": {
  1234  			[]string{
  1235  				"",
  1236  				s.operator.String(),
  1237  				s.vendor.String(),
  1238  				subjectID,
  1239  			},
  1240  			false,
  1241  		},
  1242  	}
  1243  
  1244  	for name, tc := range testCases {
  1245  		s.Run(name, func() {
  1246  			cmd := cli.NewTxCmdOperatorDetach()
  1247  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1248  			if !tc.valid {
  1249  				s.Require().Error(err)
  1250  				return
  1251  			}
  1252  			s.Require().NoError(err)
  1253  
  1254  			var res sdk.TxResponse
  1255  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1256  			s.Require().EqualValues(0, res.Code, out.String())
  1257  		})
  1258  	}
  1259  }
  1260  
  1261  func (s *IntegrationTestSuite) TestNewTxCmdGrantPermission() {
  1262  	val := s.network.Validators[0]
  1263  	commonArgs := []string{
  1264  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1265  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1266  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1267  	}
  1268  
  1269  	testCases := map[string]struct {
  1270  		args  []string
  1271  		valid bool
  1272  	}{
  1273  		"valid transaction": {
  1274  			[]string{
  1275  				s.contractID,
  1276  				s.operator.String(),
  1277  				s.customer.String(),
  1278  				collection.LegacyPermissionMint.String(),
  1279  			},
  1280  			true,
  1281  		},
  1282  		"extra args": {
  1283  			[]string{
  1284  				s.contractID,
  1285  				s.operator.String(),
  1286  				s.customer.String(),
  1287  				collection.LegacyPermissionMint.String(),
  1288  				"extra",
  1289  			},
  1290  			false,
  1291  		},
  1292  		"not enough args": {
  1293  			[]string{
  1294  				s.contractID,
  1295  				s.operator.String(),
  1296  				s.customer.String(),
  1297  			},
  1298  			false,
  1299  		},
  1300  	}
  1301  
  1302  	for name, tc := range testCases {
  1303  		s.Run(name, func() {
  1304  			cmd := cli.NewTxCmdGrantPermission()
  1305  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1306  			if !tc.valid {
  1307  				s.Require().Error(err)
  1308  				return
  1309  			}
  1310  			s.Require().NoError(err)
  1311  
  1312  			var res sdk.TxResponse
  1313  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1314  			s.Require().EqualValues(0, res.Code, out.String())
  1315  		})
  1316  	}
  1317  }
  1318  
  1319  func (s *IntegrationTestSuite) TestNewTxCmdRevokePermission() {
  1320  	val := s.network.Validators[0]
  1321  	commonArgs := []string{
  1322  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1323  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1324  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1325  	}
  1326  
  1327  	testCases := map[string]struct {
  1328  		args  []string
  1329  		valid bool
  1330  	}{
  1331  		"valid transaction": {
  1332  			[]string{
  1333  				s.contractID,
  1334  				s.vendor.String(),
  1335  				collection.LegacyPermissionModify.String(),
  1336  			},
  1337  			true,
  1338  		},
  1339  		"extra args": {
  1340  			[]string{
  1341  				s.contractID,
  1342  				s.vendor.String(),
  1343  				collection.LegacyPermissionModify.String(),
  1344  				"extra",
  1345  			},
  1346  			false,
  1347  		},
  1348  		"not enough args": {
  1349  			[]string{
  1350  				s.contractID,
  1351  				s.vendor.String(),
  1352  			},
  1353  			false,
  1354  		},
  1355  	}
  1356  
  1357  	for name, tc := range testCases {
  1358  		s.Run(name, func() {
  1359  			cmd := cli.NewTxCmdRevokePermission()
  1360  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1361  			if !tc.valid {
  1362  				s.Require().Error(err)
  1363  				return
  1364  			}
  1365  			s.Require().NoError(err)
  1366  
  1367  			var res sdk.TxResponse
  1368  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1369  			s.Require().EqualValues(0, res.Code, out.String())
  1370  		})
  1371  	}
  1372  }
  1373  
  1374  func (s *IntegrationTestSuite) TestNewTxCmdAuthorizeOperator() {
  1375  	val := s.network.Validators[0]
  1376  	commonArgs := []string{
  1377  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1378  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1379  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1380  	}
  1381  
  1382  	testCases := map[string]struct {
  1383  		args  []string
  1384  		valid bool
  1385  	}{
  1386  		"valid transaction": {
  1387  			[]string{
  1388  				s.contractID,
  1389  				s.vendor.String(),
  1390  				s.customer.String(),
  1391  			},
  1392  			true,
  1393  		},
  1394  		"extra args": {
  1395  			[]string{
  1396  				s.contractID,
  1397  				s.vendor.String(),
  1398  				s.customer.String(),
  1399  				"extra",
  1400  			},
  1401  			false,
  1402  		},
  1403  		"not enough args": {
  1404  			[]string{
  1405  				s.contractID,
  1406  				s.vendor.String(),
  1407  			},
  1408  			false,
  1409  		},
  1410  	}
  1411  
  1412  	for name, tc := range testCases {
  1413  		s.Run(name, func() {
  1414  			cmd := cli.NewTxCmdAuthorizeOperator()
  1415  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1416  			if !tc.valid {
  1417  				s.Require().Error(err)
  1418  				return
  1419  			}
  1420  			s.Require().NoError(err)
  1421  
  1422  			var res sdk.TxResponse
  1423  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1424  			s.Require().EqualValues(0, res.Code, out.String())
  1425  		})
  1426  	}
  1427  }
  1428  
  1429  func (s *IntegrationTestSuite) TestNewTxCmdRevokeOperator() {
  1430  	val := s.network.Validators[0]
  1431  	commonArgs := []string{
  1432  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
  1433  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
  1434  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
  1435  	}
  1436  
  1437  	testCases := map[string]struct {
  1438  		args  []string
  1439  		valid bool
  1440  	}{
  1441  		"valid transaction": {
  1442  			[]string{
  1443  				s.contractID,
  1444  				s.operator.String(),
  1445  				s.vendor.String(),
  1446  			},
  1447  			true,
  1448  		},
  1449  		"extra args": {
  1450  			[]string{
  1451  				s.contractID,
  1452  				s.operator.String(),
  1453  				s.vendor.String(),
  1454  				"extra",
  1455  			},
  1456  			false,
  1457  		},
  1458  		"not enough args": {
  1459  			[]string{
  1460  				s.contractID,
  1461  				s.operator.String(),
  1462  			},
  1463  			false,
  1464  		},
  1465  	}
  1466  
  1467  	for name, tc := range testCases {
  1468  		s.Run(name, func() {
  1469  			cmd := cli.NewTxCmdRevokeOperator()
  1470  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
  1471  			if !tc.valid {
  1472  				s.Require().Error(err)
  1473  				return
  1474  			}
  1475  			s.Require().NoError(err)
  1476  
  1477  			var res sdk.TxResponse
  1478  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
  1479  			s.Require().EqualValues(0, res.Code, out.String())
  1480  		})
  1481  	}
  1482  }