LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

feat(group): autocli query support (backport #17006) (#17028)

Browse Source 
Co-authored-by: Julien Robert <julien@rbrt.fr>
This commit is contained in:
mergify[bot]
2023-07-17 13:17:14 +00:00
committed by GitHub
co-authored by Julien Robert
parent 509a228bc4
commit d23caef6f6
9 changed files with 457 additions and 1262 deletions
Download Patch File Download Diff File Expand all files Collapse all files
x/group/client/cli/query.go
-556
View File
@@ -1,556 +0,0 @@
package cli
import (
"strconv"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/x/group"
)
// QueryCmd returns the cli query commands for the group module.
func QueryCmd(name string) *cobra.Command {
queryCmd := &cobra.Command{
Use: name,
Short: "Querying commands for the group module",
DisableFlagParsing: true,
SuggestionsMinimumDistance: 2,
RunE: client.ValidateCmd,
}
queryCmd.AddCommand(
QueryGroupInfoCmd(),
QueryGroupPolicyInfoCmd(),
QueryGroupMembersCmd(),
QueryGroupsByAdminCmd(),
QueryGroupPoliciesByGroupCmd(),
QueryGroupPoliciesByAdminCmd(),
QueryProposalCmd(),
QueryProposalsByGroupPolicyCmd(),
QueryVoteByProposalVoterCmd(),
QueryVotesByProposalCmd(),
QueryVotesByVoterCmd(),
QueryGroupsByMemberCmd(),
QueryTallyResultCmd(),
QueryGroupsCmd(),
)
return queryCmd
}
// QueryGroupsByMemberCmd creates a CLI command for Query/GroupsByMember.
func QueryGroupsByMemberCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "groups-by-member [address]",
Short: "Query for groups by member address with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupsByMember(cmd.Context(), &group.QueryGroupsByMemberRequest{
Address: args[0],
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "groups-by-members")
return cmd
}
// QueryGroupInfoCmd creates a CLI command for Query/GroupInfo.
func QueryGroupInfoCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "group-info [id]",
Short: "Query for group info by group id",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
groupID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupInfo(cmd.Context(), &group.QueryGroupInfoRequest{
GroupId: groupID,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res.Info)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}
// QueryGroupPolicyInfoCmd creates a CLI command for Query/GroupPolicyInfo.
func QueryGroupPolicyInfoCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "group-policy-info [group-policy-account]",
Short: "Query for group policy info by account address of group policy",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupPolicyInfo(cmd.Context(), &group.QueryGroupPolicyInfoRequest{
Address: args[0],
})
if err != nil {
return err
}
return clientCtx.PrintProto(res.Info)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}
// QueryGroupMembersCmd creates a CLI command for Query/GroupMembers.
func QueryGroupMembersCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "group-members [id]",
Short: "Query for group members by group id with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
groupID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupMembers(cmd.Context(), &group.QueryGroupMembersRequest{
GroupId: groupID,
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "group-members")
return cmd
}
// QueryGroupsByAdminCmd creates a CLI command for Query/GroupsByAdmin.
func QueryGroupsByAdminCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "groups-by-admin [admin]",
Short: "Query for groups by admin account address with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupsByAdmin(cmd.Context(), &group.QueryGroupsByAdminRequest{
Admin: args[0],
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "groups-by-admin")
return cmd
}
// QueryGroupPoliciesByGroupCmd creates a CLI command for Query/GroupPoliciesByGroup.
func QueryGroupPoliciesByGroupCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "group-policies-by-group [group-id]",
Short: "Query for group policies by group id with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
groupID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupPoliciesByGroup(cmd.Context(), &group.QueryGroupPoliciesByGroupRequest{
GroupId: groupID,
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "groups-policies-by-group")
return cmd
}
// QueryGroupPoliciesByAdminCmd creates a CLI command for Query/GroupPoliciesByAdmin.
func QueryGroupPoliciesByAdminCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "group-policies-by-admin [admin]",
Short: "Query for group policies by admin account address with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.GroupPoliciesByAdmin(cmd.Context(), &group.QueryGroupPoliciesByAdminRequest{
Admin: args[0],
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "group-policies-by-admin")
return cmd
}
// QueryProposalCmd creates a CLI command for Query/Proposal.
func QueryProposalCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "proposal [id]",
Short: "Query for proposal by id",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
proposalID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.Proposal(cmd.Context(), &group.QueryProposalRequest{
ProposalId: proposalID,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}
// QueryProposalsByGroupPolicyCmd creates a CLI command for Query/ProposalsByGroupPolicy.
func QueryProposalsByGroupPolicyCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "proposals-by-group-policy [group-policy-account]",
Short: "Query for proposals by account address of group policy with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.ProposalsByGroupPolicy(cmd.Context(), &group.QueryProposalsByGroupPolicyRequest{
Address: args[0],
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "proposals-by-group-policy")
return cmd
}
// QueryVoteByProposalVoterCmd creates a CLI command for Query/VoteByProposalVoter.
func QueryVoteByProposalVoterCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "vote [proposal-id] [voter]",
Short: "Query for vote by proposal id and voter account address",
Args: cobra.ExactArgs(2),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
proposalID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.VoteByProposalVoter(cmd.Context(), &group.QueryVoteByProposalVoterRequest{
ProposalId: proposalID,
Voter: args[1],
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}
// QueryVotesByProposalCmd creates a CLI command for Query/VotesByProposal.
func QueryVotesByProposalCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "votes-by-proposal [proposal-id]",
Short: "Query for votes by proposal id with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
proposalID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.VotesByProposal(cmd.Context(), &group.QueryVotesByProposalRequest{
ProposalId: proposalID,
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "votes-by-proposal")
return cmd
}
// QueryTallyResultCmd creates a CLI command for Query/TallyResult.
func QueryTallyResultCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "tally-result [proposal-id]",
Short: "Query tally result of proposal",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
proposalID, err := strconv.ParseUint(args[0], 10, 64)
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.TallyResult(cmd.Context(), &group.QueryTallyResultRequest{
ProposalId: proposalID,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}
// QueryVotesByVoterCmd creates a CLI command for Query/VotesByVoter.
func QueryVotesByVoterCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "votes-by-voter [voter]",
Short: "Query for votes by voter account address with pagination flags",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.VotesByVoter(cmd.Context(), &group.QueryVotesByVoterRequest{
Voter: args[0],
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "votes-by-voter")
return cmd
}
// QueryGroupsCmd creates a CLI command for Query/Groups.
func QueryGroupsCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "groups",
Short: "Query for groups present in the state",
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
pageReq, err := client.ReadPageRequest(cmd.Flags())
if err != nil {
return err
}
queryClient := group.NewQueryClient(clientCtx)
res, err := queryClient.Groups(cmd.Context(), &group.QueryGroupsRequest{
Pagination: pageReq,
})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
flags.AddPaginationFlagsToCmd(cmd, "groups")
return cmd
}
x/group/client/cli/query_test.go
-513
View File
@@ -1,513 +0,0 @@
package cli_test
import (
"context"
"fmt"
"io"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
svrcmd "github.com/cosmos/cosmos-sdk/server/cmd"
"github.com/cosmos/cosmos-sdk/testutil"
"github.com/cosmos/cosmos-sdk/x/group/client/cli"
)
func (s *CLITestSuite) TestQueryGroupInfo() {
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "invalid id",
args: []string{"invalid id"},
expCmdOutput: `[invalid id]`,
},
{
name: "json output",
args: []string{"1", fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: `[1 --output=json]`,
},
{
name: "text output",
args: []string{"1", fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: `[1 --output=text]`,
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupInfoCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "group-info [id] [] [] Query for group info by group id")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryGroupPolicyInfo() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupPolicyInfoCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "group-policy-info [group-policy-account] [] [] Query for group policy info by account address of group policy")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryGroupMembers() {
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{"1", fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: "1 --output=json",
},
{
name: "text output",
args: []string{"1", fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: "1 --output=text",
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupMembersCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "group-members [id] [] [] Query for group members by group id with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryGroupsByAdmin() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupsByAdminCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "groups-by-admin [admin] [] [] Query for groups by admin account address with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryGroupPoliciesByGroup() {
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{"1", fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: "1 --output=json",
},
{
name: "text output",
args: []string{"1", fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: "1 --output=text",
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupPoliciesByGroupCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "group-policies-by-group [group-id] [] [] Query for group policies by group id with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryGroupPoliciesByAdmin() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupPoliciesByAdminCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "group-policies-by-admin [admin] [] [] Query for group policies by admin account address with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryProposal() {
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{"1", fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: "1 --output=json",
},
{
name: "text output",
args: []string{"1", fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: "1 --output=text",
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryProposalCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "proposal [id] [] [] Query for proposal by id")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryProposalsByGroupPolicy() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryProposalsByGroupPolicyCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "proposals-by-group-policy [group-policy-account] [] [] Query for proposals by account address of group policy with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryVoteByProposalVoter() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{"1", accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("1 %s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{"1", accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("1 %s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryVoteByProposalVoterCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "vote [proposal-id] [voter] [] [] Query for vote by proposal id and voter account address")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryVotesByProposal() {
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{"1", fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: "1 --output=json",
},
{
name: "text output",
args: []string{"1", fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: "1 --output=text",
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryVotesByProposalCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "votes-by-proposal [proposal-id] [] [] Query for votes by proposal id with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryTallyResult() {
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{"1", fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: "1 --output=json",
},
{
name: "text output",
args: []string{"1", fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: "1 --output=text",
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryTallyResultCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "tally-result [proposal-id] [] [] Query tally result of proposal")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryVotesByVoter() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryVotesByVoterCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "votes-by-voter [voter] [] [] Query for votes by voter account address with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
func (s *CLITestSuite) TestQueryGroupsByMembers() {
accounts := testutil.CreateKeyringAccounts(s.T(), s.kr, 1)
testCases := []struct {
name string
args []string
expCmdOutput string
}{
{
name: "json output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=json", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=json", accounts[0].Address.String()),
},
{
name: "text output",
args: []string{accounts[0].Address.String(), fmt.Sprintf("--%s=text", flags.FlagOutput)},
expCmdOutput: fmt.Sprintf("%s --output=text", accounts[0].Address.String()),
},
}
for _, tc := range testCases {
s.Run(tc.name, func() {
cmd := cli.QueryGroupsByMemberCmd()
ctx := svrcmd.CreateExecuteContext(context.Background())
cmd.SetOut(io.Discard)
s.Require().NotNil(cmd)
cmd.SetContext(ctx)
cmd.SetArgs(tc.args)
s.Require().NoError(client.SetCmdClientContextHandler(s.baseCtx, cmd))
s.Require().Contains(fmt.Sprint(cmd), "groups-by-member [address] [] [] Query for groups by member address with pagination flags")
s.Require().Contains(fmt.Sprint(cmd), tc.expCmdOutput)
})
}
}
x/group/client/cli/util_test.go
+1 -1
View File
@@ -6,7 +6,7 @@ import (
"github.com/stretchr/testify/require"
)
func Test_ParseCLIProposal(t *testing.T) {
func TestParseCLIProposal(t *testing.T) {
data := []byte(`{
"group_policy_address": "cosmos15r295x4994egvckteam9skazy9kvfvzpak4naf",
"messages": [