package kit import ( "bytes" "context" "flag" "strings" "testing" "github.com/multiformats/go-multiaddr" "github.com/stretchr/testify/require" lcli "github.com/urfave/cli/v2" "github.com/filecoin-project/lotus/api" ) type MockCLI struct { t *testing.T cmds []*lcli.Command cctx *lcli.Context out *bytes.Buffer } func NewMockCLI(ctx context.Context, t *testing.T, cmds []*lcli.Command, nodeType api.NodeType) *MockCLI { // Create a CLI App with an --api-url flag so that we can specify which node // the command should be executed against app := &lcli.App{ Flags: []lcli.Flag{ &lcli.StringFlag{ Name: "api-url", Hidden: true, }, }, Commands: cmds, } // Set node type api.RunningNodeType = nodeType var out bytes.Buffer app.Writer = &out app.Setup() cctx := lcli.NewContext(app, &flag.FlagSet{}, nil) cctx.Context = ctx return &MockCLI{t: t, cmds: cmds, cctx: cctx, out: &out} } func (c *MockCLI) Client(addr multiaddr.Multiaddr) *MockCLIClient { return &MockCLIClient{t: c.t, cmds: c.cmds, addr: addr, cctx: c.cctx, out: c.out} } // MockCLIClient runs commands against a particular node type MockCLIClient struct { t *testing.T cmds []*lcli.Command addr multiaddr.Multiaddr cctx *lcli.Context out *bytes.Buffer } func (c *MockCLIClient) RunCmd(input ...string) string { out, err := c.RunCmdRaw(input...) require.NoError(c.t, err, "output:\n%s", out) return out } // Given an input, find the corresponding command or sub-command. // eg "paych add-funds" func (c *MockCLIClient) cmdByNameSub(input []string) (*lcli.Command, []string) { name := input[0] for _, cmd := range c.cmds { if cmd.Name == name { return c.findSubcommand(cmd, input[1:]) } } return nil, []string{} } func (c *MockCLIClient) findSubcommand(cmd *lcli.Command, input []string) (*lcli.Command, []string) { // If there are no sub-commands, return the current command if len(cmd.Subcommands) == 0 { return cmd, input } // Check each sub-command for a match against the name subName := input[0] for _, subCmd := range cmd.Subcommands { if subCmd.Name == subName { // Found a match, recursively search for sub-commands return c.findSubcommand(subCmd, input[1:]) } } return nil, []string{} } func (c *MockCLIClient) RunCmdRaw(input ...string) (string, error) { cmd, input := c.cmdByNameSub(input) if cmd == nil { panic("Could not find command " + input[0] + " " + input[1]) } // prepend --api-url=<node api listener address> apiFlag := "--api-url=" + c.addr.String() input = append([]string{apiFlag}, input...) fs := c.flagSet(cmd) err := fs.Parse(input) require.NoError(c.t, err) err = cmd.Action(lcli.NewContext(c.cctx.App, fs, c.cctx)) // Get the output str := strings.TrimSpace(c.out.String()) c.out.Reset() return str, err } func (c *MockCLIClient) flagSet(cmd *lcli.Command) *flag.FlagSet { // Apply app level flags (so we can process --api-url flag) fs := &flag.FlagSet{} for _, f := range c.cctx.App.Flags { err := f.Apply(fs) if err != nil { c.t.Fatal(err) } } // Apply command level flags for _, f := range cmd.Flags { err := f.Apply(fs) if err != nil { c.t.Fatal(err) } } return fs } func (c *MockCLIClient) RunInteractiveCmd(cmd []string, interactive []string) string { c.toStdin(strings.Join(interactive, "\n") + "\n") return c.RunCmd(cmd...) } func (c *MockCLIClient) toStdin(s string) { c.cctx.App.Metadata["stdin"] = bytes.NewBufferString(s) }