github.com/Finschia/finschia-sdk@v0.48.1/x/token/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/token"
    10  	"github.com/Finschia/finschia-sdk/x/token/client/cli"
    11  )
    12  
    13  func (s *IntegrationTestSuite) TestNewTxCmdSend() {
    14  	val := s.network.Validators[0]
    15  	commonArgs := []string{
    16  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.customer),
    17  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
    18  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
    19  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
    20  	}
    21  
    22  	testCases := map[string]struct {
    23  		args  []string
    24  		valid bool
    25  	}{
    26  		"valid transaction": {
    27  			[]string{
    28  				s.classes[0].Id,
    29  				s.customer.String(),
    30  				s.vendor.String(),
    31  				"1",
    32  			},
    33  			true,
    34  		},
    35  		"extra args": {
    36  			[]string{
    37  				s.classes[0].Id,
    38  				s.customer.String(),
    39  				s.vendor.String(),
    40  				"1",
    41  				"extra",
    42  			},
    43  			false,
    44  		},
    45  		"not enough args": {
    46  			[]string{
    47  				s.classes[0].Id,
    48  				s.customer.String(),
    49  				s.vendor.String(),
    50  			},
    51  			false,
    52  		},
    53  		"amount out of range": {
    54  			[]string{
    55  				s.classes[0].Id,
    56  				s.customer.String(),
    57  				s.vendor.String(),
    58  				"10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    59  			},
    60  			false,
    61  		},
    62  	}
    63  
    64  	for name, tc := range testCases {
    65  		tc := tc
    66  
    67  		s.Run(name, func() {
    68  			cmd := cli.NewTxCmdSend()
    69  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
    70  			if !tc.valid {
    71  				s.Require().Error(err)
    72  				return
    73  			}
    74  			s.Require().NoError(err)
    75  
    76  			var res sdk.TxResponse
    77  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
    78  			s.Require().EqualValues(0, res.Code, out.String())
    79  		})
    80  	}
    81  }
    82  
    83  func (s *IntegrationTestSuite) TestNewTxCmdOperatorSend() {
    84  	val := s.network.Validators[0]
    85  	commonArgs := []string{
    86  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
    87  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
    88  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
    89  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
    90  	}
    91  
    92  	testCases := map[string]struct {
    93  		args  []string
    94  		valid bool
    95  	}{
    96  		"valid transaction": {
    97  			[]string{
    98  				s.classes[0].Id,
    99  				s.vendor.String(),
   100  				s.customer.String(),
   101  				s.vendor.String(),
   102  				"1",
   103  			},
   104  			true,
   105  		},
   106  		"extra args": {
   107  			[]string{
   108  				s.classes[0].Id,
   109  				s.vendor.String(),
   110  				s.customer.String(),
   111  				s.vendor.String(),
   112  				"1",
   113  				"extra",
   114  			},
   115  			false,
   116  		},
   117  		"not enough args": {
   118  			[]string{
   119  				s.classes[0].Id,
   120  				s.vendor.String(),
   121  				s.customer.String(),
   122  				s.vendor.String(),
   123  			},
   124  			false,
   125  		},
   126  		"amount out of range": {
   127  			[]string{
   128  				s.classes[0].Id,
   129  				s.vendor.String(),
   130  				s.customer.String(),
   131  				s.vendor.String(),
   132  				"10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
   133  			},
   134  			false,
   135  		},
   136  	}
   137  
   138  	for name, tc := range testCases {
   139  		tc := tc
   140  
   141  		s.Run(name, func() {
   142  			cmd := cli.NewTxCmdOperatorSend()
   143  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   144  			if !tc.valid {
   145  				s.Require().Error(err)
   146  				return
   147  			}
   148  			s.Require().NoError(err)
   149  
   150  			var res sdk.TxResponse
   151  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   152  			s.Require().EqualValues(0, res.Code, out.String())
   153  		})
   154  	}
   155  }
   156  
   157  func (s *IntegrationTestSuite) TestNewTxCmdAuthorizeOperator() {
   158  	val := s.network.Validators[0]
   159  	commonArgs := []string{
   160  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   161  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   162  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   163  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   164  	}
   165  
   166  	testCases := map[string]struct {
   167  		args  []string
   168  		valid bool
   169  	}{
   170  		"valid transaction": {
   171  			[]string{
   172  				s.classes[0].Id,
   173  				s.vendor.String(),
   174  				s.customer.String(),
   175  			},
   176  			true,
   177  		},
   178  		"extra args": {
   179  			[]string{
   180  				s.classes[0].Id,
   181  				s.vendor.String(),
   182  				s.customer.String(),
   183  				"extra",
   184  			},
   185  			false,
   186  		},
   187  		"not enough args": {
   188  			[]string{
   189  				s.classes[0].Id,
   190  				s.vendor.String(),
   191  			},
   192  			false,
   193  		},
   194  	}
   195  
   196  	for name, tc := range testCases {
   197  		tc := tc
   198  
   199  		s.Run(name, func() {
   200  			cmd := cli.NewTxCmdAuthorizeOperator()
   201  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   202  			if !tc.valid {
   203  				s.Require().Error(err)
   204  				return
   205  			}
   206  			s.Require().NoError(err)
   207  
   208  			var res sdk.TxResponse
   209  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   210  			s.Require().EqualValues(0, res.Code, out.String())
   211  		})
   212  	}
   213  }
   214  
   215  func (s *IntegrationTestSuite) TestNewTxCmdRevokeOperator() {
   216  	val := s.network.Validators[0]
   217  	commonArgs := []string{
   218  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.customer),
   219  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   220  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   221  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   222  	}
   223  
   224  	testCases := map[string]struct {
   225  		args  []string
   226  		valid bool
   227  	}{
   228  		"valid transaction": {
   229  			[]string{
   230  				s.classes[1].Id,
   231  				s.customer.String(),
   232  				s.vendor.String(),
   233  			},
   234  			true,
   235  		},
   236  		"extra args": {
   237  			[]string{
   238  				s.classes[1].Id,
   239  				s.customer.String(),
   240  				s.vendor.String(),
   241  				"extra",
   242  			},
   243  			false,
   244  		},
   245  		"not enough args": {
   246  			[]string{
   247  				s.classes[1].Id,
   248  				s.customer.String(),
   249  			},
   250  			false,
   251  		},
   252  	}
   253  
   254  	for name, tc := range testCases {
   255  		tc := tc
   256  
   257  		s.Run(name, func() {
   258  			cmd := cli.NewTxCmdRevokeOperator()
   259  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   260  			if !tc.valid {
   261  				s.Require().Error(err)
   262  				return
   263  			}
   264  			s.Require().NoError(err)
   265  
   266  			var res sdk.TxResponse
   267  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   268  			s.Require().EqualValues(0, res.Code, out.String())
   269  		})
   270  	}
   271  }
   272  
   273  func (s *IntegrationTestSuite) TestNewTxCmdIssue() {
   274  	val := s.network.Validators[0]
   275  	commonArgs := []string{
   276  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   277  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   278  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   279  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   280  	}
   281  
   282  	testCases := map[string]struct {
   283  		args  []string
   284  		valid bool
   285  	}{
   286  		"valid transaction": {
   287  			[]string{
   288  				s.vendor.String(),
   289  				s.vendor.String(),
   290  				"Test class",
   291  				"TT",
   292  				fmt.Sprintf("--%s=%s", cli.FlagImageURI, "URI"),
   293  				fmt.Sprintf("--%s=%s", cli.FlagMeta, "META"),
   294  				fmt.Sprintf("--%s=%d", cli.FlagDecimals, 8),
   295  				fmt.Sprintf("--%s=%s", cli.FlagSupply, "10000000000"),
   296  				fmt.Sprintf("--%s=%v", cli.FlagMintable, true),
   297  			},
   298  			true,
   299  		},
   300  		"extra args": {
   301  			[]string{
   302  				s.vendor.String(),
   303  				s.vendor.String(),
   304  				"Test class",
   305  				"TT",
   306  				"extra",
   307  			},
   308  			false,
   309  		},
   310  		"not enough args": {
   311  			[]string{
   312  				s.vendor.String(),
   313  				s.vendor.String(),
   314  				"Test class",
   315  			},
   316  			false,
   317  		},
   318  	}
   319  
   320  	for name, tc := range testCases {
   321  		tc := tc
   322  
   323  		s.Run(name, func() {
   324  			cmd := cli.NewTxCmdIssue()
   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) TestNewTxCmdGrantPermission() {
   340  	val := s.network.Validators[0]
   341  	commonArgs := []string{
   342  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   343  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   344  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   345  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   346  	}
   347  
   348  	testCases := map[string]struct {
   349  		args  []string
   350  		valid bool
   351  	}{
   352  		"valid transaction": {
   353  			[]string{
   354  				s.classes[1].Id,
   355  				s.vendor.String(),
   356  				s.customer.String(),
   357  				token.LegacyPermissionMint.String(),
   358  			},
   359  			true,
   360  		},
   361  		"extra args": {
   362  			[]string{
   363  				s.classes[1].Id,
   364  				s.vendor.String(),
   365  				s.customer.String(),
   366  				token.LegacyPermissionMint.String(),
   367  				"extra",
   368  			},
   369  			false,
   370  		},
   371  		"not enough args": {
   372  			[]string{
   373  				s.classes[1].Id,
   374  				s.vendor.String(),
   375  				s.customer.String(),
   376  			},
   377  			false,
   378  		},
   379  	}
   380  
   381  	for name, tc := range testCases {
   382  		tc := tc
   383  
   384  		s.Run(name, func() {
   385  			cmd := cli.NewTxCmdGrantPermission()
   386  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   387  			if !tc.valid {
   388  				s.Require().Error(err)
   389  				return
   390  			}
   391  			s.Require().NoError(err)
   392  
   393  			var res sdk.TxResponse
   394  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   395  			s.Require().EqualValues(0, res.Code, out.String())
   396  		})
   397  	}
   398  }
   399  
   400  func (s *IntegrationTestSuite) TestNewTxCmdRevokePermission() {
   401  	val := s.network.Validators[0]
   402  	commonArgs := []string{
   403  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   404  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   405  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   406  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   407  	}
   408  
   409  	testCases := map[string]struct {
   410  		args  []string
   411  		valid bool
   412  	}{
   413  		"valid transaction": {
   414  			[]string{
   415  				s.classes[1].Id,
   416  				s.vendor.String(),
   417  				token.LegacyPermissionModify.String(),
   418  			},
   419  			true,
   420  		},
   421  		"extra args": {
   422  			[]string{
   423  				s.classes[1].Id,
   424  				s.vendor.String(),
   425  				token.LegacyPermissionModify.String(),
   426  				"extra",
   427  			},
   428  			false,
   429  		},
   430  		"not enough args": {
   431  			[]string{
   432  				s.classes[1].Id,
   433  				s.vendor.String(),
   434  			},
   435  			false,
   436  		},
   437  	}
   438  
   439  	for name, tc := range testCases {
   440  		tc := tc
   441  
   442  		s.Run(name, func() {
   443  			cmd := cli.NewTxCmdRevokePermission()
   444  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   445  			if !tc.valid {
   446  				s.Require().Error(err)
   447  				return
   448  			}
   449  			s.Require().NoError(err)
   450  
   451  			var res sdk.TxResponse
   452  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   453  			s.Require().EqualValues(0, res.Code, out.String())
   454  		})
   455  	}
   456  }
   457  
   458  func (s *IntegrationTestSuite) TestNewTxCmdMint() {
   459  	val := s.network.Validators[0]
   460  	commonArgs := []string{
   461  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   462  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   463  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   464  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   465  	}
   466  
   467  	testCases := map[string]struct {
   468  		args  []string
   469  		valid bool
   470  	}{
   471  		"valid transaction": {
   472  			[]string{
   473  				s.classes[0].Id,
   474  				s.vendor.String(),
   475  				s.customer.String(),
   476  				"1",
   477  			},
   478  			true,
   479  		},
   480  		"extra args": {
   481  			[]string{
   482  				s.classes[0].Id,
   483  				s.vendor.String(),
   484  				s.customer.String(),
   485  				"1",
   486  				"extra",
   487  			},
   488  			false,
   489  		},
   490  		"not enough args": {
   491  			[]string{
   492  				s.classes[0].Id,
   493  				s.vendor.String(),
   494  				s.customer.String(),
   495  			},
   496  			false,
   497  		},
   498  	}
   499  
   500  	for name, tc := range testCases {
   501  		tc := tc
   502  
   503  		s.Run(name, func() {
   504  			cmd := cli.NewTxCmdMint()
   505  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   506  			if !tc.valid {
   507  				s.Require().Error(err)
   508  				return
   509  			}
   510  			s.Require().NoError(err)
   511  
   512  			var res sdk.TxResponse
   513  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   514  			s.Require().EqualValues(0, res.Code, out.String())
   515  		})
   516  	}
   517  }
   518  
   519  func (s *IntegrationTestSuite) TestNewTxCmdBurn() {
   520  	val := s.network.Validators[0]
   521  	commonArgs := []string{
   522  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   523  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   524  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   525  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   526  	}
   527  
   528  	testCases := map[string]struct {
   529  		args  []string
   530  		valid bool
   531  	}{
   532  		"valid transaction": {
   533  			[]string{
   534  				s.classes[1].Id,
   535  				s.vendor.String(),
   536  				"1",
   537  			},
   538  			true,
   539  		},
   540  		"extra args": {
   541  			[]string{
   542  				s.classes[1].Id,
   543  				s.vendor.String(),
   544  				"1",
   545  				"extra",
   546  			},
   547  			false,
   548  		},
   549  		"not enough args": {
   550  			[]string{
   551  				s.classes[1].Id,
   552  				s.vendor.String(),
   553  			},
   554  			false,
   555  		},
   556  	}
   557  
   558  	for name, tc := range testCases {
   559  		tc := tc
   560  
   561  		s.Run(name, func() {
   562  			cmd := cli.NewTxCmdBurn()
   563  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   564  			if !tc.valid {
   565  				s.Require().Error(err)
   566  				return
   567  			}
   568  			s.Require().NoError(err)
   569  
   570  			var res sdk.TxResponse
   571  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   572  			s.Require().EqualValues(0, res.Code, out.String())
   573  		})
   574  	}
   575  }
   576  
   577  func (s *IntegrationTestSuite) TestNewTxCmdOperatorBurn() {
   578  	val := s.network.Validators[0]
   579  	commonArgs := []string{
   580  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   581  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   582  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   583  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   584  	}
   585  
   586  	testCases := map[string]struct {
   587  		args  []string
   588  		valid bool
   589  	}{
   590  		"valid transaction": {
   591  			[]string{
   592  				s.classes[0].Id,
   593  				s.vendor.String(),
   594  				s.customer.String(),
   595  				"1",
   596  			},
   597  			true,
   598  		},
   599  		"extra args": {
   600  			[]string{
   601  				s.classes[0].Id,
   602  				s.vendor.String(),
   603  				s.customer.String(),
   604  				"1",
   605  				"extra",
   606  			},
   607  			false,
   608  		},
   609  		"not enough args": {
   610  			[]string{
   611  				s.classes[0].Id,
   612  				s.vendor.String(),
   613  				s.customer.String(),
   614  			},
   615  			false,
   616  		},
   617  	}
   618  
   619  	for name, tc := range testCases {
   620  		tc := tc
   621  
   622  		s.Run(name, func() {
   623  			cmd := cli.NewTxCmdOperatorBurn()
   624  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   625  			if !tc.valid {
   626  				s.Require().Error(err)
   627  				return
   628  			}
   629  			s.Require().NoError(err)
   630  
   631  			var res sdk.TxResponse
   632  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   633  			s.Require().EqualValues(0, res.Code, out.String())
   634  		})
   635  	}
   636  }
   637  
   638  func (s *IntegrationTestSuite) TestNewTxCmdModify() {
   639  	val := s.network.Validators[0]
   640  	commonArgs := []string{
   641  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.vendor),
   642  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   643  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   644  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
   645  	}
   646  
   647  	testCases := map[string]struct {
   648  		args  []string
   649  		valid bool
   650  	}{
   651  		"valid transaction": {
   652  			[]string{
   653  				s.classes[0].Id,
   654  				s.vendor.String(),
   655  				token.AttributeKeyName.String(),
   656  				"cool token",
   657  			},
   658  			true,
   659  		},
   660  		"extra args": {
   661  			[]string{
   662  				s.classes[0].Id,
   663  				s.vendor.String(),
   664  				token.AttributeKeyName.String(),
   665  				"cool token",
   666  				"extra",
   667  			},
   668  			false,
   669  		},
   670  		"not enough args": {
   671  			[]string{
   672  				s.classes[0].Id,
   673  				s.vendor.String(),
   674  				token.AttributeKeyName.String(),
   675  			},
   676  			false,
   677  		},
   678  	}
   679  
   680  	for name, tc := range testCases {
   681  		tc := tc
   682  
   683  		s.Run(name, func() {
   684  			cmd := cli.NewTxCmdModify()
   685  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   686  			if !tc.valid {
   687  				s.Require().Error(err)
   688  				return
   689  			}
   690  			s.Require().NoError(err)
   691  
   692  			var res sdk.TxResponse
   693  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out.String())
   694  			s.Require().EqualValues(0, res.Code, out.String())
   695  		})
   696  	}
   697  }