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

     1  package testutil
     2  
     3  import (
     4  	"fmt"
     5  	"time"
     6  
     7  	"github.com/Finschia/finschia-sdk/client/flags"
     8  	clitestutil "github.com/Finschia/finschia-sdk/testutil/cli"
     9  	"github.com/Finschia/finschia-sdk/testutil/testdata"
    10  	sdk "github.com/Finschia/finschia-sdk/types"
    11  	txtypes "github.com/Finschia/finschia-sdk/types/tx"
    12  	"github.com/Finschia/finschia-sdk/x/foundation"
    13  	"github.com/Finschia/finschia-sdk/x/foundation/client/cli"
    14  )
    15  
    16  func (s *IntegrationTestSuite) TestNewTxCmdFundTreasury() {
    17  	val := s.network.Validators[0]
    18  	commonArgs := []string{
    19  		fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address),
    20  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
    21  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
    22  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)))),
    23  	}
    24  
    25  	testCases := map[string]struct {
    26  		args  []string
    27  		valid bool
    28  	}{
    29  		"valid transaction": {
    30  			[]string{
    31  				val.Address.String(),
    32  				sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.OneInt())).String(),
    33  			},
    34  			true,
    35  		},
    36  		"wrong number of args": {
    37  			[]string{
    38  				val.Address.String(),
    39  				sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.OneInt())).String(),
    40  				"extra",
    41  			},
    42  			false,
    43  		},
    44  	}
    45  
    46  	for name, tc := range testCases {
    47  		s.Run(name, func() {
    48  			cmd := cli.NewTxCmdFundTreasury()
    49  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
    50  			if !tc.valid {
    51  				s.Require().Error(err)
    52  				return
    53  			}
    54  			s.Require().NoError(err)
    55  
    56  			var res sdk.TxResponse
    57  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
    58  			s.Require().Zero(res.Code, out)
    59  		})
    60  	}
    61  }
    62  
    63  func (s *IntegrationTestSuite) TestNewTxCmdWithdrawFromTreasury() {
    64  	val := s.network.Validators[0]
    65  	commonArgs := []string{
    66  		fmt.Sprintf("--%s", flags.FlagGenerateOnly),
    67  	}
    68  
    69  	testCases := map[string]struct {
    70  		args  []string
    71  		valid bool
    72  	}{
    73  		"valid transaction": {
    74  			[]string{
    75  				s.authority.String(),
    76  				s.stranger.String(),
    77  				sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.OneInt())).String(),
    78  			},
    79  			true,
    80  		},
    81  		"wrong number of args": {
    82  			[]string{
    83  				s.authority.String(),
    84  				s.stranger.String(),
    85  				sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.OneInt())).String(),
    86  				"extra",
    87  			},
    88  			false,
    89  		},
    90  	}
    91  
    92  	for name, tc := range testCases {
    93  		s.Run(name, func() {
    94  			cmd := cli.NewTxCmdWithdrawFromTreasury()
    95  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
    96  			if !tc.valid {
    97  				s.Require().Error(err)
    98  				return
    99  			}
   100  			s.Require().NoError(err)
   101  
   102  			var res txtypes.Tx
   103  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   104  		})
   105  	}
   106  }
   107  
   108  func (s *IntegrationTestSuite) TestNewTxCmdUpdateMembers() {
   109  	val := s.network.Validators[0]
   110  	commonArgs := []string{
   111  		fmt.Sprintf("--%s", flags.FlagGenerateOnly),
   112  	}
   113  
   114  	updates := `[{"address":"%s"}]`
   115  	testCases := map[string]struct {
   116  		args  []string
   117  		valid bool
   118  	}{
   119  		"valid transaction": {
   120  			[]string{
   121  				s.authority.String(),
   122  				fmt.Sprintf(updates, s.comingMember),
   123  			},
   124  			true,
   125  		},
   126  		"wrong number of args": {
   127  			[]string{
   128  				s.authority.String(),
   129  				fmt.Sprintf(updates, s.comingMember),
   130  				"extra",
   131  			},
   132  			false,
   133  		},
   134  	}
   135  
   136  	for name, tc := range testCases {
   137  		s.Run(name, func() {
   138  			cmd := cli.NewTxCmdUpdateMembers()
   139  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   140  			if !tc.valid {
   141  				s.Require().Error(err)
   142  				return
   143  			}
   144  			s.Require().NoError(err)
   145  
   146  			var res txtypes.Tx
   147  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   148  		})
   149  	}
   150  }
   151  
   152  func (s *IntegrationTestSuite) TestNewTxCmdUpdateDecisionPolicy() {
   153  	val := s.network.Validators[0]
   154  	commonArgs := []string{
   155  		fmt.Sprintf("--%s", flags.FlagGenerateOnly),
   156  	}
   157  
   158  	doMarshal := func(policy foundation.DecisionPolicy) string {
   159  		bz, err := val.ClientCtx.Codec.MarshalInterfaceJSON(policy)
   160  		s.Require().NoError(err)
   161  		return string(bz)
   162  	}
   163  	testCases := map[string]struct {
   164  		args  []string
   165  		valid bool
   166  	}{
   167  		"valid transaction": {
   168  			[]string{
   169  				s.authority.String(),
   170  				doMarshal(&foundation.ThresholdDecisionPolicy{
   171  					Threshold: sdk.NewDec(10),
   172  					Windows: &foundation.DecisionPolicyWindows{
   173  						VotingPeriod: time.Hour,
   174  					},
   175  				}),
   176  			},
   177  			true,
   178  		},
   179  		"wrong number of args": {
   180  			[]string{
   181  				s.authority.String(),
   182  				doMarshal(&foundation.ThresholdDecisionPolicy{
   183  					Threshold: sdk.NewDec(10),
   184  					Windows: &foundation.DecisionPolicyWindows{
   185  						VotingPeriod: time.Hour,
   186  					},
   187  				}),
   188  				"extra",
   189  			},
   190  			false,
   191  		},
   192  	}
   193  
   194  	for name, tc := range testCases {
   195  		s.Run(name, func() {
   196  			cmd := cli.NewTxCmdUpdateDecisionPolicy()
   197  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   198  			if !tc.valid {
   199  				s.Require().Error(err)
   200  				return
   201  			}
   202  			s.Require().NoError(err)
   203  
   204  			var res txtypes.Tx
   205  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   206  		})
   207  	}
   208  }
   209  
   210  func (s *IntegrationTestSuite) TestNewTxCmdSubmitProposal() {
   211  	val := s.network.Validators[0]
   212  	commonArgs := []string{
   213  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.permanentMember),
   214  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   215  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   216  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)))),
   217  	}
   218  
   219  	proposers := `["%s"]`
   220  	testCases := map[string]struct {
   221  		args  []string
   222  		valid bool
   223  	}{
   224  		"valid transaction": {
   225  			[]string{
   226  				"test proposal",
   227  				fmt.Sprintf(proposers, s.permanentMember),
   228  				s.msgToString(testdata.NewTestMsg()),
   229  			},
   230  			true,
   231  		},
   232  		"wrong number of args": {
   233  			[]string{
   234  				"test proposal",
   235  				fmt.Sprintf(proposers, s.permanentMember),
   236  				s.msgToString(testdata.NewTestMsg()),
   237  				"extra",
   238  			},
   239  			false,
   240  		},
   241  	}
   242  
   243  	for name, tc := range testCases {
   244  		s.Run(name, func() {
   245  			cmd := cli.NewTxCmdSubmitProposal()
   246  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   247  			if !tc.valid {
   248  				s.Require().Error(err)
   249  				return
   250  			}
   251  			s.Require().NoError(err)
   252  
   253  			var res sdk.TxResponse
   254  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   255  			s.Require().Zero(res.Code, out)
   256  		})
   257  	}
   258  }
   259  
   260  func (s *IntegrationTestSuite) TestNewTxCmdWithdrawProposal() {
   261  	val := s.network.Validators[0]
   262  	commonArgs := []string{
   263  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.permanentMember),
   264  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   265  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   266  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)))),
   267  	}
   268  
   269  	id := s.submitProposal(testdata.NewTestMsg(s.authority), false)
   270  	testCases := map[string]struct {
   271  		args  []string
   272  		valid bool
   273  	}{
   274  		"valid transaction": {
   275  			[]string{
   276  				fmt.Sprint(id),
   277  				s.permanentMember.String(),
   278  			},
   279  			true,
   280  		},
   281  		"wrong number of args": {
   282  			[]string{
   283  				fmt.Sprint(id),
   284  				s.permanentMember.String(),
   285  				"extra",
   286  			},
   287  			false,
   288  		},
   289  	}
   290  
   291  	for name, tc := range testCases {
   292  		s.Run(name, func() {
   293  			cmd := cli.NewTxCmdWithdrawProposal()
   294  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   295  			if !tc.valid {
   296  				s.Require().Error(err)
   297  				return
   298  			}
   299  			s.Require().NoError(err)
   300  
   301  			var res sdk.TxResponse
   302  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   303  			s.Require().Zero(res.Code, out)
   304  		})
   305  	}
   306  }
   307  
   308  func (s *IntegrationTestSuite) TestNewTxCmdVote() {
   309  	val := s.network.Validators[0]
   310  	commonArgs := []string{
   311  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.permanentMember),
   312  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   313  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   314  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)))),
   315  	}
   316  
   317  	id := s.submitProposal(testdata.NewTestMsg(s.authority), false)
   318  	testCases := map[string]struct {
   319  		args  []string
   320  		valid bool
   321  	}{
   322  		"valid transaction": {
   323  			[]string{
   324  				fmt.Sprint(id),
   325  				s.permanentMember.String(),
   326  				"VOTE_OPTION_YES",
   327  				"test vote",
   328  			},
   329  			true,
   330  		},
   331  		"wrong number of args": {
   332  			[]string{
   333  				fmt.Sprint(id),
   334  				s.permanentMember.String(),
   335  				"VOTE_OPTION_YES",
   336  				"test vote",
   337  				"extra",
   338  			},
   339  			false,
   340  		},
   341  	}
   342  
   343  	for name, tc := range testCases {
   344  		s.Run(name, func() {
   345  			cmd := cli.NewTxCmdVote()
   346  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   347  			if !tc.valid {
   348  				s.Require().Error(err)
   349  				return
   350  			}
   351  			s.Require().NoError(err)
   352  
   353  			var res sdk.TxResponse
   354  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   355  			s.Require().Zero(res.Code, out)
   356  		})
   357  	}
   358  }
   359  
   360  func (s *IntegrationTestSuite) TestNewTxCmdExec() {
   361  	val := s.network.Validators[0]
   362  	commonArgs := []string{
   363  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.permanentMember),
   364  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   365  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   366  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)))),
   367  	}
   368  
   369  	testCases := map[string]struct {
   370  		args  []string
   371  		valid bool
   372  	}{
   373  		"valid transaction": {
   374  			[]string{
   375  				fmt.Sprintf("%d", s.proposalID),
   376  				s.permanentMember.String(),
   377  			},
   378  			true,
   379  		},
   380  		"wrong number of args": {
   381  			[]string{
   382  				fmt.Sprintf("%d", s.proposalID),
   383  				s.permanentMember.String(),
   384  				"extra",
   385  			},
   386  			false,
   387  		},
   388  	}
   389  
   390  	for name, tc := range testCases {
   391  		s.Run(name, func() {
   392  			cmd := cli.NewTxCmdExec()
   393  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   394  			if !tc.valid {
   395  				s.Require().Error(err)
   396  				return
   397  			}
   398  			s.Require().NoError(err)
   399  
   400  			var res sdk.TxResponse
   401  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   402  			s.Require().Zero(res.Code, out)
   403  		})
   404  	}
   405  }
   406  
   407  func (s *IntegrationTestSuite) TestNewTxCmdLeaveFoundation() {
   408  	val := s.network.Validators[0]
   409  	commonArgs := []string{
   410  		fmt.Sprintf("--%s=%s", flags.FlagFrom, s.leavingMember),
   411  		fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
   412  		fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
   413  		fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)))),
   414  	}
   415  
   416  	testCases := map[string]struct {
   417  		args  []string
   418  		valid bool
   419  	}{
   420  		"valid transaction": {
   421  			[]string{
   422  				s.leavingMember.String(),
   423  			},
   424  			true,
   425  		},
   426  		"wrong number of args": {
   427  			[]string{
   428  				s.leavingMember.String(),
   429  				"extra",
   430  			},
   431  			false,
   432  		},
   433  	}
   434  
   435  	for name, tc := range testCases {
   436  		s.Run(name, func() {
   437  			cmd := cli.NewTxCmdLeaveFoundation()
   438  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   439  			if !tc.valid {
   440  				s.Require().Error(err)
   441  				return
   442  			}
   443  			s.Require().NoError(err)
   444  
   445  			var res sdk.TxResponse
   446  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   447  			s.Require().Zero(res.Code, out)
   448  		})
   449  	}
   450  }
   451  
   452  func (s *IntegrationTestSuite) TestNewTxCmdGrant() {
   453  	val := s.network.Validators[0]
   454  	commonArgs := []string{
   455  		fmt.Sprintf("--%s", flags.FlagGenerateOnly),
   456  	}
   457  
   458  	doMarshal := func(authorization foundation.Authorization) string {
   459  		bz, err := val.ClientCtx.Codec.MarshalInterfaceJSON(authorization)
   460  		s.Require().NoError(err)
   461  		return string(bz)
   462  	}
   463  	testCases := map[string]struct {
   464  		args  []string
   465  		valid bool
   466  	}{
   467  		"valid transaction": {
   468  			[]string{
   469  				s.authority.String(),
   470  				s.comingMember.String(),
   471  				doMarshal(&foundation.ReceiveFromTreasuryAuthorization{}),
   472  			},
   473  			true,
   474  		},
   475  		"wrong number of args": {
   476  			[]string{
   477  				s.authority.String(),
   478  				s.comingMember.String(),
   479  				doMarshal(&foundation.ReceiveFromTreasuryAuthorization{}),
   480  				"extra",
   481  			},
   482  			false,
   483  		},
   484  	}
   485  
   486  	for name, tc := range testCases {
   487  		s.Run(name, func() {
   488  			cmd := cli.NewTxCmdGrant()
   489  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   490  			if !tc.valid {
   491  				s.Require().Error(err)
   492  				return
   493  			}
   494  			s.Require().NoError(err)
   495  
   496  			var res txtypes.Tx
   497  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   498  		})
   499  	}
   500  }
   501  
   502  func (s *IntegrationTestSuite) TestNewTxCmdRevoke() {
   503  	val := s.network.Validators[0]
   504  	commonArgs := []string{
   505  		fmt.Sprintf("--%s", flags.FlagGenerateOnly),
   506  	}
   507  
   508  	testCases := map[string]struct {
   509  		args  []string
   510  		valid bool
   511  	}{
   512  		"valid transaction": {
   513  			[]string{
   514  				s.authority.String(),
   515  				s.leavingMember.String(),
   516  				foundation.ReceiveFromTreasuryAuthorization{}.MsgTypeURL(),
   517  			},
   518  			true,
   519  		},
   520  		"wrong number of args": {
   521  			[]string{
   522  				s.authority.String(),
   523  				s.leavingMember.String(),
   524  				foundation.ReceiveFromTreasuryAuthorization{}.MsgTypeURL(),
   525  				"extra",
   526  			},
   527  			false,
   528  		},
   529  	}
   530  
   531  	for name, tc := range testCases {
   532  		s.Run(name, func() {
   533  			cmd := cli.NewTxCmdRevoke()
   534  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   535  			if !tc.valid {
   536  				s.Require().Error(err)
   537  				return
   538  			}
   539  			s.Require().NoError(err)
   540  
   541  			var res txtypes.Tx
   542  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &res), out)
   543  		})
   544  	}
   545  }