package subcmd import ( "bytes" "context" "flag" "os" "os/exec" "strings" "testing" "git.sr.ht/~eugenetriguba/checkmate/assert" "git.sr.ht/~eugenetriguba/checkmate/check" ) type mockCommand struct { name string synopsis string usage string exitStatus ExitStatus executed bool flagValue string } func (m *mockCommand) Name() string { return m.name } func (m *mockCommand) Synopsis() string { return m.synopsis } func (m *mockCommand) Usage() string { return m.usage } func (m *mockCommand) SetFlags(f *flag.FlagSet) { f.StringVar(&m.flagValue, "test", "", "test flag") } func (m *mockCommand) Execute(ctx context.Context, f *flag.FlagSet, args ...any) ExitStatus { m.executed = true return m.exitStatus } // setupOsArgs sets up os.Args and flag.CommandLine for testing, // returning a cleanup function that restores the original state. func setupOsArgs(args ...string) func() { oldArgs := os.Args os.Args = args flag.CommandLine = flag.NewFlagSet(args[0], flag.ExitOnError) flag.Parse() return func() { os.Args = oldArgs } } func TestRegistry_Register(t *testing.T) { r := NewRegistry() cmd1 := &mockCommand{name: "test1", synopsis: "Test command 1"} cmd2 := &mockCommand{name: "test2", synopsis: "Test command 2"} r.Register(cmd1, "") r.Register(cmd2, "group1") check.Equal(t, r.Command("test1"), cmd1) check.Equal(t, r.Command("test2"), cmd2) check.Nil(t, r.Command("nonexistent")) } func TestRegistry_Execute_NoSubcommand(t *testing.T) { var buf bytes.Buffer r := NewRegistry(WithOutput(&buf)) cleanup := setupOsArgs("prog") defer cleanup() status := r.Execute(context.Background()) check.Equal(t, status, ExitFailure) output := buf.String() check.Contains(t, output, "Usage: prog ") check.Contains(t, output, "Subcommands:") } func TestRegistry_Execute_UnknownSubcommand(t *testing.T) { var buf bytes.Buffer r := NewRegistry(WithOutput(&buf)) cleanup := setupOsArgs("prog", "unknown") defer cleanup() status := r.Execute(context.Background()) check.Equal(t, status, ExitFailure) check.Contains(t, buf.String(), "Unknown subcommand: unknown") } func TestRegistry_Execute_Success(t *testing.T) { var buf bytes.Buffer cmd := &mockCommand{ name: "test", exitStatus: ExitSuccess, } r := NewRegistry(WithOutput(&buf)) r.Register(cmd, "") cleanup := setupOsArgs("prog", "test") defer cleanup() status := r.Execute(context.Background()) check.Equal(t, status, ExitSuccess) check.Equal(t, cmd.executed, true) } func TestRegistry_Execute_WithFlags(t *testing.T) { var buf bytes.Buffer cmd := &mockCommand{ name: "test", exitStatus: ExitSuccess, } r := NewRegistry(WithOutput(&buf)) r.Register(cmd, "") cleanup := setupOsArgs("prog", "test", "-test=value") defer cleanup() status := r.Execute(context.Background()) check.Equal(t, status, ExitSuccess) check.Equal(t, cmd.flagValue, "value") } func TestRegistry_Execute_HelpFlag(t *testing.T) { var buf bytes.Buffer cmd := &mockCommand{ name: "test", usage: "test:\n This is the test command usage.\n", } r := NewRegistry( WithOutput(&buf), WithErrorHandling(flag.ContinueOnError), ) r.Register(cmd, "") cleanup := setupOsArgs("prog", "test", "-h") defer cleanup() status := r.Execute(context.Background()) check.Equal(t, status, ExitFailure) check.Contains(t, buf.String(), "This is the test command usage.") } func TestRegistry_Commands(t *testing.T) { cmd1 := &mockCommand{name: "aaa", synopsis: "First"} cmd2 := &mockCommand{name: "bbb", synopsis: "Second"} cmd3 := &mockCommand{name: "ccc", synopsis: "Third"} r := NewRegistry() r.Register(cmd2, "group1") r.Register(cmd1, "group1") r.Register(cmd3, "group2") commands := r.Commands() check.Equal(t, len(commands), 2) group1 := commands["group1"] check.Equal(t, len(group1), 2) // Should be in alphabetical order check.Equal(t, group1[0].Name(), "aaa") check.Equal(t, group1[1].Name(), "bbb") group2 := commands["group2"] check.Equal(t, len(group2), 1) } func TestPackageLevelConvienanceFunctionsUseDefaultRegistry(t *testing.T) { cmd := &mockCommand{name: "test", synopsis: "Test"} Register(cmd, "group") check.Equal(t, defaultRegistry.Command("test"), cmd) cleanup := setupOsArgs("prog", "test") defer cleanup() status := Execute(context.Background()) check.Equal(t, status, ExitSuccess) check.Equal(t, cmd.executed, true) } func TestBuiltInCommandNames(t *testing.T) { help := HelpCommand() check.Equal(t, help.Name(), "help") manHelp := ManHelpCommand("myapp") check.Equal(t, manHelp.Name(), "help") commands := CommandsCommand() check.Equal(t, commands.Name(), "commands") flags := FlagsCommand() check.Equal(t, flags.Name(), "flags") } func TestHelpCommand_NoArgs(t *testing.T) { var buf bytes.Buffer cmd1 := &mockCommand{name: "test1", synopsis: "Test command 1"} cmd2 := &mockCommand{name: "test2", synopsis: "Test command 2"} r := NewRegistry(WithOutput(&buf)) r.Register(cmd1, "group1") r.Register(cmd2, "group1") help := &helpCommand{registry: r} r.Register(help, "") fs := flag.NewFlagSet("help", flag.ExitOnError) err := fs.Parse([]string{}) assert.Nil(t, err) status := help.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) output := buf.String() check.Contains(t, output, "Available commands") check.Contains(t, output, "test1") check.Contains(t, output, "test2") check.Contains(t, output, "Test command 1") } func TestHelpCommand_WithArg(t *testing.T) { var buf bytes.Buffer cmd := &mockCommand{ name: "test", usage: "test:\n This is a test command\n", } r := NewRegistry(WithOutput(&buf)) r.Register(cmd, "") help := &helpCommand{registry: r} r.Register(help, "") fs := flag.NewFlagSet("help", flag.ExitOnError) fs.Parse([]string{"test"}) status := help.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) check.Equal(t, buf.String(), cmd.usage+"\n") } func TestHelpCommand_UnknownCommand(t *testing.T) { var buf bytes.Buffer r := NewRegistry(WithOutput(&buf)) help := &helpCommand{registry: r} fs := flag.NewFlagSet("help", flag.ExitOnError) fs.Parse([]string{"unknown"}) status := help.Execute(context.Background(), fs) check.Equal(t, status, ExitFailure) check.Contains(t, buf.String(), "Unknown command: unknown") } func TestManHelpCommand_NoArgs(t *testing.T) { var calledName string var calledArgs []string oldExecCommand := execCommand execCommand = func(name string, args ...string) *exec.Cmd { calledName = name calledArgs = args return exec.Command("true") } defer func() { execCommand = oldExecCommand }() help := ManHelpCommand("myapp") fs := flag.NewFlagSet("help", flag.ExitOnError) fs.Parse([]string{}) status := help.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) check.Equal(t, calledName, "man") check.Equal(t, len(calledArgs), 1) check.Equal(t, calledArgs[0], "myapp") } func TestManHelpCommand_WithSubcommand(t *testing.T) { var calledArgs []string oldExecCommand := execCommand execCommand = func(name string, args ...string) *exec.Cmd { calledArgs = args return exec.Command("true") } defer func() { execCommand = oldExecCommand }() help := ManHelpCommand("myapp") fs := flag.NewFlagSet("help", flag.ExitOnError) fs.Parse([]string{"build"}) status := help.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) check.Equal(t, calledArgs[0], "myapp-build") } func TestCommandsCommand(t *testing.T) { var buf bytes.Buffer r := NewRegistry(WithOutput(&buf)) r.Register(&mockCommand{name: "zzz"}, "") r.Register(&mockCommand{name: "aaa"}, "") r.Register(&mockCommand{name: "mmm"}, "") cmds := &commandsCommand{registry: r} r.Register(cmds, "") fs := flag.NewFlagSet("commands", flag.ExitOnError) status := cmds.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) output := buf.String() lines := strings.Split(strings.TrimSpace(output), "\n") check.Equal(t, len(lines), 4) // Should be sorted alphabetically expected := []string{"aaa", "commands", "mmm", "zzz"} for i, line := range lines { check.Equal(t, line, expected[i]) } } func TestFlagsCommand_NoFlags(t *testing.T) { var buf bytes.Buffer r := NewRegistry(WithOutput(&buf)) flags := &flagsCommand{registry: r} fs := flag.NewFlagSet("flags", flag.ExitOnError) status := flags.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) check.Contains(t, buf.String(), "No top-level flags defined") } func TestFlagsCommand_WithFlags(t *testing.T) { var buf bytes.Buffer r := NewRegistry(WithOutput(&buf)) fs := flag.NewFlagSet("flags", flag.ExitOnError) flag.String("testflag", "default", "test flag description") flags := &flagsCommand{registry: r} status := flags.Execute(context.Background(), fs) check.Equal(t, status, ExitSuccess) output := buf.String() check.Equal( t, output, `Top-level flags: -testflag (default: default) test flag description `) check.Contains(t, output, "testflag") check.Contains(t, output, "test flag description") }