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

     1  package testutil
     2  
     3  import (
     4  	"fmt"
     5  
     6  	ostcli "github.com/Finschia/ostracon/libs/cli"
     7  	"github.com/gogo/protobuf/proto"
     8  
     9  	"github.com/Finschia/finschia-sdk/client/flags"
    10  	clitestutil "github.com/Finschia/finschia-sdk/testutil/cli"
    11  	sdk "github.com/Finschia/finschia-sdk/types"
    12  	"github.com/Finschia/finschia-sdk/x/foundation"
    13  	"github.com/Finschia/finschia-sdk/x/foundation/client/cli"
    14  )
    15  
    16  func (s *IntegrationTestSuite) TestNewQueryCmdParams() {
    17  	val := s.network.Validators[0]
    18  	commonArgs := []string{
    19  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
    20  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
    21  	}
    22  
    23  	testCases := map[string]struct {
    24  		args     []string
    25  		valid    bool
    26  		expected proto.Message
    27  	}{
    28  		"valid query": {
    29  			[]string{},
    30  			true,
    31  			&foundation.QueryParamsResponse{
    32  				Params: foundation.Params{
    33  					FoundationTax: sdk.MustNewDecFromStr("0.2"),
    34  				},
    35  			},
    36  		},
    37  		"wrong number of args": {
    38  			[]string{
    39  				"extra",
    40  			},
    41  			false,
    42  			nil,
    43  		},
    44  	}
    45  
    46  	for name, tc := range testCases {
    47  		tc := tc
    48  
    49  		s.Run(name, func() {
    50  			cmd := cli.NewQueryCmdParams()
    51  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
    52  			if !tc.valid {
    53  				s.Require().Error(err)
    54  				return
    55  			}
    56  			s.Require().NoError(err)
    57  
    58  			var actual foundation.QueryParamsResponse
    59  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
    60  			s.Require().Equal(tc.expected, &actual)
    61  		})
    62  	}
    63  }
    64  
    65  func (s *IntegrationTestSuite) TestNewQueryCmdTreasury() {
    66  	val := s.network.Validators[0]
    67  	commonArgs := []string{
    68  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
    69  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
    70  	}
    71  
    72  	testCases := map[string]struct {
    73  		args  []string
    74  		valid bool
    75  	}{
    76  		"valid query": {
    77  			[]string{},
    78  			true,
    79  		},
    80  		"wrong number of args": {
    81  			[]string{
    82  				"extra",
    83  			},
    84  			false,
    85  		},
    86  	}
    87  
    88  	for name, tc := range testCases {
    89  		tc := tc
    90  
    91  		s.Run(name, func() {
    92  			cmd := cli.NewQueryCmdTreasury()
    93  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
    94  			if !tc.valid {
    95  				s.Require().Error(err)
    96  				return
    97  			}
    98  			s.Require().NoError(err)
    99  
   100  			var actual foundation.QueryTreasuryResponse
   101  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   102  		})
   103  	}
   104  }
   105  
   106  func (s *IntegrationTestSuite) TestNewQueryCmdFoundationInfo() {
   107  	val := s.network.Validators[0]
   108  	commonArgs := []string{
   109  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   110  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   111  	}
   112  
   113  	testCases := map[string]struct {
   114  		args  []string
   115  		valid bool
   116  	}{
   117  		"valid query": {
   118  			[]string{},
   119  			true,
   120  		},
   121  		"wrong number of args": {
   122  			[]string{
   123  				"extra",
   124  			},
   125  			false,
   126  		},
   127  	}
   128  
   129  	for name, tc := range testCases {
   130  		tc := tc
   131  
   132  		s.Run(name, func() {
   133  			cmd := cli.NewQueryCmdFoundationInfo()
   134  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   135  			if !tc.valid {
   136  				s.Require().Error(err)
   137  				return
   138  			}
   139  			s.Require().NoError(err)
   140  
   141  			var actual foundation.QueryFoundationInfoResponse
   142  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   143  		})
   144  	}
   145  }
   146  
   147  func (s *IntegrationTestSuite) TestNewQueryCmdMember() {
   148  	val := s.network.Validators[0]
   149  	commonArgs := []string{
   150  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   151  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   152  	}
   153  
   154  	testCases := map[string]struct {
   155  		args     []string
   156  		valid    bool
   157  		expected *foundation.Member
   158  	}{
   159  		"valid query": {
   160  			[]string{
   161  				s.permanentMember.String(),
   162  			},
   163  			true,
   164  			&foundation.Member{
   165  				Address:  s.permanentMember.String(),
   166  				Metadata: "permanent member",
   167  			},
   168  		},
   169  		"wrong number of args": {
   170  			[]string{
   171  				s.permanentMember.String(),
   172  				"extra",
   173  			},
   174  			false,
   175  			nil,
   176  		},
   177  		"invalid member": {
   178  			[]string{
   179  				"",
   180  			},
   181  			false,
   182  			nil,
   183  		},
   184  	}
   185  
   186  	for name, tc := range testCases {
   187  		tc := tc
   188  
   189  		s.Run(name, func() {
   190  			cmd := cli.NewQueryCmdMember()
   191  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   192  			if !tc.valid {
   193  				s.Require().Error(err)
   194  				return
   195  			}
   196  			s.Require().NoError(err)
   197  
   198  			var actual foundation.QueryMemberResponse
   199  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   200  			s.Require().Equal(tc.expected, actual.Member)
   201  		})
   202  	}
   203  }
   204  
   205  func (s *IntegrationTestSuite) TestNewQueryCmdMembers() {
   206  	val := s.network.Validators[0]
   207  	commonArgs := []string{
   208  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   209  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   210  	}
   211  
   212  	testCases := map[string]struct {
   213  		args  []string
   214  		valid bool
   215  	}{
   216  		"valid query": {
   217  			[]string{},
   218  			true,
   219  		},
   220  		"wrong number of args": {
   221  			[]string{
   222  				"extra",
   223  			},
   224  			false,
   225  		},
   226  	}
   227  
   228  	for name, tc := range testCases {
   229  		tc := tc
   230  
   231  		s.Run(name, func() {
   232  			cmd := cli.NewQueryCmdMembers()
   233  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   234  			if !tc.valid {
   235  				s.Require().Error(err)
   236  				return
   237  			}
   238  			s.Require().NoError(err)
   239  
   240  			var actual foundation.QueryMembersResponse
   241  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   242  		})
   243  	}
   244  }
   245  
   246  func (s *IntegrationTestSuite) TestNewQueryCmdProposal() {
   247  	val := s.network.Validators[0]
   248  	commonArgs := []string{
   249  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   250  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   251  	}
   252  
   253  	testCases := map[string]struct {
   254  		args  []string
   255  		valid bool
   256  	}{
   257  		"valid query": {
   258  			[]string{
   259  				fmt.Sprintf("%d", s.proposalID),
   260  			},
   261  			true,
   262  		},
   263  		"wrong number of args": {
   264  			[]string{
   265  				fmt.Sprintf("%d", s.proposalID),
   266  				"extra",
   267  			},
   268  			false,
   269  		},
   270  		"invalid id": {
   271  			[]string{
   272  				fmt.Sprintf("%d", -1),
   273  			},
   274  			false,
   275  		},
   276  	}
   277  
   278  	for name, tc := range testCases {
   279  		tc := tc
   280  
   281  		s.Run(name, func() {
   282  			cmd := cli.NewQueryCmdProposal()
   283  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   284  			if !tc.valid {
   285  				s.Require().Error(err)
   286  				return
   287  			}
   288  			s.Require().NoError(err)
   289  
   290  			var actual foundation.QueryProposalResponse
   291  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   292  		})
   293  	}
   294  }
   295  
   296  func (s *IntegrationTestSuite) TestNewQueryCmdProposals() {
   297  	val := s.network.Validators[0]
   298  	commonArgs := []string{
   299  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   300  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   301  	}
   302  
   303  	testCases := map[string]struct {
   304  		args  []string
   305  		valid bool
   306  	}{
   307  		"valid query": {
   308  			[]string{},
   309  			true,
   310  		},
   311  		"wrong number of args": {
   312  			[]string{
   313  				"extra",
   314  			},
   315  			false,
   316  		},
   317  	}
   318  
   319  	for name, tc := range testCases {
   320  		tc := tc
   321  
   322  		s.Run(name, func() {
   323  			cmd := cli.NewQueryCmdProposals()
   324  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   325  			if !tc.valid {
   326  				s.Require().Error(err)
   327  				return
   328  			}
   329  			s.Require().NoError(err)
   330  
   331  			var actual foundation.QueryProposalsResponse
   332  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   333  		})
   334  	}
   335  }
   336  
   337  func (s *IntegrationTestSuite) TestNewQueryCmdVote() {
   338  	val := s.network.Validators[0]
   339  	commonArgs := []string{
   340  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   341  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   342  	}
   343  
   344  	testCases := map[string]struct {
   345  		args  []string
   346  		valid bool
   347  	}{
   348  		"valid query": {
   349  			[]string{
   350  				fmt.Sprintf("%d", s.proposalID),
   351  				s.permanentMember.String(),
   352  			},
   353  			true,
   354  		},
   355  		"wrong number of args": {
   356  			[]string{
   357  				fmt.Sprintf("%d", s.proposalID),
   358  				s.permanentMember.String(),
   359  				"extra",
   360  			},
   361  			false,
   362  		},
   363  		"invalid proposal id": {
   364  			[]string{
   365  				fmt.Sprintf("%d", -1),
   366  				s.permanentMember.String(),
   367  			},
   368  			false,
   369  		},
   370  		"invalid voter": {
   371  			[]string{
   372  				fmt.Sprintf("%d", s.proposalID),
   373  				"",
   374  			},
   375  			false,
   376  		},
   377  	}
   378  
   379  	for name, tc := range testCases {
   380  		tc := tc
   381  
   382  		s.Run(name, func() {
   383  			cmd := cli.NewQueryCmdVote()
   384  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   385  			if !tc.valid {
   386  				s.Require().Error(err)
   387  				return
   388  			}
   389  			s.Require().NoError(err)
   390  
   391  			var actual foundation.QueryVoteResponse
   392  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   393  		})
   394  	}
   395  }
   396  
   397  func (s *IntegrationTestSuite) TestNewQueryCmdVotes() {
   398  	val := s.network.Validators[0]
   399  	commonArgs := []string{
   400  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   401  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   402  	}
   403  
   404  	testCases := map[string]struct {
   405  		args  []string
   406  		valid bool
   407  	}{
   408  		"valid query": {
   409  			[]string{
   410  				fmt.Sprintf("%d", s.proposalID),
   411  			},
   412  			true,
   413  		},
   414  		"wrong number of args": {
   415  			[]string{
   416  				fmt.Sprintf("%d", s.proposalID),
   417  				"extra",
   418  			},
   419  			false,
   420  		},
   421  		"invalid proposal id": {
   422  			[]string{
   423  				fmt.Sprintf("%d", -1),
   424  			},
   425  			false,
   426  		},
   427  	}
   428  
   429  	for name, tc := range testCases {
   430  		tc := tc
   431  
   432  		s.Run(name, func() {
   433  			cmd := cli.NewQueryCmdVotes()
   434  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   435  			if !tc.valid {
   436  				s.Require().Error(err)
   437  				return
   438  			}
   439  			s.Require().NoError(err)
   440  
   441  			var actual foundation.QueryVotesResponse
   442  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   443  		})
   444  	}
   445  }
   446  
   447  func (s *IntegrationTestSuite) TestNewQueryCmdTallyResult() {
   448  	val := s.network.Validators[0]
   449  	commonArgs := []string{
   450  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   451  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   452  	}
   453  
   454  	testCases := map[string]struct {
   455  		args  []string
   456  		valid bool
   457  	}{
   458  		"valid query": {
   459  			[]string{
   460  				fmt.Sprintf("%d", s.proposalID),
   461  			},
   462  			true,
   463  		},
   464  		"wrong number of args": {
   465  			[]string{
   466  				fmt.Sprintf("%d", s.proposalID),
   467  				"extra",
   468  			},
   469  			false,
   470  		},
   471  		"invalid proposal id": {
   472  			[]string{
   473  				fmt.Sprintf("%d", -1),
   474  			},
   475  			false,
   476  		},
   477  	}
   478  
   479  	for name, tc := range testCases {
   480  		tc := tc
   481  
   482  		s.Run(name, func() {
   483  			cmd := cli.NewQueryCmdTallyResult()
   484  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   485  			if !tc.valid {
   486  				s.Require().Error(err)
   487  				return
   488  			}
   489  			s.Require().NoError(err)
   490  
   491  			var actual foundation.QueryTallyResultResponse
   492  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   493  		})
   494  	}
   495  }
   496  
   497  func (s *IntegrationTestSuite) TestNewQueryCmdCensorships() {
   498  	val := s.network.Validators[0]
   499  	commonArgs := []string{
   500  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   501  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   502  	}
   503  
   504  	testCases := map[string]struct {
   505  		args     []string
   506  		valid    bool
   507  		expected int
   508  	}{
   509  		"valid query": {
   510  			[]string{},
   511  			true,
   512  			1,
   513  		},
   514  		"wrong number of args": {
   515  			[]string{
   516  				"extra",
   517  			},
   518  			false,
   519  			0,
   520  		},
   521  	}
   522  
   523  	for name, tc := range testCases {
   524  		tc := tc
   525  
   526  		s.Run(name, func() {
   527  			cmd := cli.NewQueryCmdCensorships()
   528  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   529  			if !tc.valid {
   530  				s.Require().Error(err)
   531  				return
   532  			}
   533  			s.Require().NoError(err)
   534  
   535  			var actual foundation.QueryCensorshipsResponse
   536  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   537  			s.Require().Len(actual.Censorships, tc.expected)
   538  		})
   539  	}
   540  }
   541  
   542  func (s *IntegrationTestSuite) TestNewQueryCmdGrants() {
   543  	val := s.network.Validators[0]
   544  	commonArgs := []string{
   545  		fmt.Sprintf("--%s=%d", flags.FlagHeight, s.setupHeight),
   546  		fmt.Sprintf("--%s=json", ostcli.OutputFlag),
   547  	}
   548  
   549  	testCases := map[string]struct {
   550  		args     []string
   551  		valid    bool
   552  		expected int
   553  	}{
   554  		"valid query": {
   555  			[]string{
   556  				s.stranger.String(),
   557  				foundation.ReceiveFromTreasuryAuthorization{}.MsgTypeURL(),
   558  			},
   559  			true,
   560  			1,
   561  		},
   562  		"no msg type url": {
   563  			[]string{
   564  				s.stranger.String(),
   565  			},
   566  			true,
   567  			1,
   568  		},
   569  		"wrong number of args": {
   570  			[]string{
   571  				s.stranger.String(),
   572  				foundation.ReceiveFromTreasuryAuthorization{}.MsgTypeURL(),
   573  				"extra",
   574  			},
   575  			false,
   576  			0,
   577  		},
   578  		"invalid grantee": {
   579  			[]string{
   580  				"",
   581  				foundation.ReceiveFromTreasuryAuthorization{}.MsgTypeURL(),
   582  			},
   583  			false,
   584  			0,
   585  		},
   586  	}
   587  
   588  	for name, tc := range testCases {
   589  		tc := tc
   590  
   591  		s.Run(name, func() {
   592  			cmd := cli.NewQueryCmdGrants()
   593  			out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, append(tc.args, commonArgs...))
   594  			if !tc.valid {
   595  				s.Require().Error(err)
   596  				return
   597  			}
   598  			s.Require().NoError(err)
   599  
   600  			var actual foundation.QueryGrantsResponse
   601  			s.Require().NoError(val.ClientCtx.Codec.UnmarshalJSON(out.Bytes(), &actual), out.String())
   602  			s.Require().Equal(tc.expected, len(actual.Authorizations))
   603  		})
   604  	}
   605  }