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