help_test.go

package verbs

import (
	"strings"
	"testing"
)

func interceptHelp(cli *CLI) *string {
	helpText := new(string)
	cli.OnHelp = func(ht string) {
		*helpText = ht
	}
	return helpText
}

func expectHelpContains(t *testing.T, helpText, expectedHelpText string) {
	if !strings.Contains(helpText, expectedHelpText) {
		t.Fatalf("Expected the help text to contain \"%s\", "+
			"got \"%s\"", expectedHelpText, helpText)
	}
}

func TestHelpCommandErrors(t *testing.T) {
	cli := setupGitCLI()
	errorMessage := interceptErrors(cli)
	parser := NewParser(cli)

	parser.Parse(strings.Split("git help --unknown", " "))
	expectError(t, *errorMessage, "unknown option '--unknown'")

	parser.Parse(strings.Split("git help --force", " "))
	expectError(t, *errorMessage, "option '--force' is not expected here")

	parser.Parse(strings.Split("git help unknown", " "))
	expectError(t, *errorMessage, "unrecognized name 'unknown'")

	parser.Parse(strings.Split("git help remote add unknown", " "))
	expectError(t, *errorMessage, "unexpected argument 'unknown'")
}

func TestHelpTopic(t *testing.T) {
	cli := setupGitCLI()
	cli.HelpTopics = []*HelpTopic{{
		Keyword: "tutorial",
		Text:    "This is a tutorial on how to use git.",
	}}
	helpText := interceptHelp(cli)
	parser := NewParser(cli)
	parser.Parse(strings.Split("git help tutorial", " "))
	expectHelpContains(t, *helpText, "how to use git")
}

func TestHelpScreenArgumentOnly(t *testing.T) {
	cli := setupGrepCLI()

	var helpText string
	cli.OnHelp = func(text string) {
		helpText = text
	}

	args := []string{"grep", "--help"}
	NewParser(cli).Parse(args)

	// Check for key elements
	if !strings.Contains(helpText, "Usage:\n"+
		"  grep [options] PATTERN [FILE...]") {
		t.Error("Help text should contain usage line")
	}
	if !strings.Contains(helpText, "Search for patterns in files") {
		t.Error("Help text should contain summary")
	}
	if !strings.Contains(helpText, "Options:") {
		t.Error("Help text should contain options section")
	}
	if !strings.Contains(helpText, "--ignore-case") {
		t.Error("Help text should contain option names")
	}
}

func TestHelpScreenCommandDriven(t *testing.T) {
	cli := &CLI{
		ProgramName: "git",
		Summary:     "Version control system",
		Description: "Git is a distributed version control system.",
		Commands: []*Command{
			{
				Name:        "add",
				Summary:     "Add files to the index",
				Description: "This command updates the index.",
				Options: []*Option{
					{
						Name:        "f|force",
						Description: "Force add",
					},
				},
				Args: []*Arg{
					{
						Name:        "FILE",
						Occurrence:  ZeroOrMore,
						Description: "Files to add",
					},
				},
			},
			{
				Name:    "commit",
				Summary: "Record changes",
			},
		},
	}

	var helpText string
	cli.OnHelp = func(text string) {
		helpText = text
	}

	args := []string{"git", "--help"}
	NewParser(cli).Parse(args)

	// Check for key elements
	if !strings.Contains(helpText, "Usage:\n  git") {
		t.Error("Help text should contain usage line")
	}
	if !strings.Contains(helpText, "add") {
		t.Error("Help text should contain command names")
	}
	if !strings.Contains(helpText, "commit") {
		t.Error("Help text should contain all commands")
	}
}

func TestHelpScreenCommandSpecific(t *testing.T) {
	cli := setupGitCLI()

	var helpText string
	cli.OnHelp = func(text string) {
		helpText = text
	}

	args := strings.Split("git help remote add", " ")
	result := NewParser(cli).Parse(args)

	if result.Command != nil {
		t.Errorf("Expected nil command, got %v", result.Command)
	}
	if len(result.OptsAndArgs) != 0 {
		t.Errorf("Expected 0 parsed items, got %d",
			len(result.OptsAndArgs))
	}

	// Check for command-specific help
	if !strings.Contains(helpText, "Add a remote repository") {
		t.Error("Help text should contain command summary")
	}
	if !strings.Contains(helpText, "Usage:\n  git remote add") {
		t.Error("Help text should contain usage")
	}
	if !strings.Contains(helpText, "-f") {
		t.Error("Help text should contain command options")
	}
}

func TestHelpScreenWithNamespaces(t *testing.T) {
	cli := &CLI{
		ProgramName: "git",
		Summary:     "Version control",
		Namespaces: []*Namespace{
			{
				Name:    "remote",
				Summary: "Manage remotes",
				Commands: []*Command{
					{Name: "add", Summary: "Add a remote"},
					{Name: "remove", Summary: "Remove a remote"},
				},
			},
		},
	}

	var helpText string
	cli.OnHelp = func(text string) {
		helpText = text
	}

	args := []string{"git", "--help"}
	NewParser(cli).Parse(args)

	// Namespaces should appear in help
	if !strings.Contains(helpText, "remote") {
		t.Error("Help text should contain namespace names")
	}
}

func TestArgumentFormatting(t *testing.T) {
	t.Run("Required and OneOrMore arguments", func(t *testing.T) {
		cli := &CLI{
			ProgramName: "test",
			Args: []*Arg{
				{
					Name:        "CMD",
					Description: "The command to run",
					Occurrence:  Optional,
				},
				{
					Name:        "ARG",
					Description: "Command arguments",
					Occurrence:  ZeroOrMore,
				},
			},
		}
		helpText := interceptHelp(cli)
		NewParser(cli).Parse([]string{"test", "--help"})
		expectHelpContains(t, *helpText,
			"Usage:\n  test [CMD] [ARG...]\n")
		expectHelpContains(t, *helpText, "\n  [CMD]    ")
		expectHelpContains(t, *helpText, "\n  [ARG...]    ")
	})
	t.Run("Optional and OneOrMore arguments", func(t *testing.T) {
		cli := &CLI{
			ProgramName: "test",
			Args: []*Arg{
				{
					Name:        "FILE",
					Description: "The files to copy",
					Occurrence:  OneOrMore,
				},
				{
					Name:        "DIR",
					Description: "The directory to copy to",
					Occurrence:  Required,
				},
			},
		}
		helpText := interceptHelp(cli)
		NewParser(cli).Parse([]string{"test", "--help"})
		expectHelpContains(t, *helpText, "Usage:\n  test FILE... DIR\n")
		expectHelpContains(t, *helpText, "\n  FILE...    ")
		expectHelpContains(t, *helpText, "\n  DIR    ")
	})
}

func TestVersionHandling(t *testing.T) {
	cli := &CLI{ProgramName: "test", Version: "1.2.3"}
	helpText := interceptHelp(cli)

	t.Run("version option", func(t *testing.T) {
		NewParser(cli).Parse([]string{"test", "--version"})
		expectHelpContains(t, *helpText, "1.2.3")
	})
	t.Run("version prompt", func(t *testing.T) {
		NewParser(cli).Parse([]string{"test", "--help"})
		expectHelpContains(t, *helpText,
			"Run 'test --version' for version info.")
	})
}

func TestWordWrapping(t *testing.T) {
	var helpText string

	cli := &CLI{
		ProgramName: "test",
		Summary: "A very long summary that should be wrapped " +
			"properly when it exceeds the help text width limit",
		HelpTextWidth: 40,
		OnHelp: func(text string) {
			helpText = text
		},
	}

	args := []string{"test", "--help"}
	NewParser(cli).Parse(args)

	if helpText == "" {
		t.Fatal("Expected help text, got empty string")
	}

	// Check that lines are wrapped (rough check)
	for _, line := range strings.Split(helpText, "\n") {
		// With width 40, most lines should be wrapped
		// This is a basic check - more sophisticated
		// tests would verify exact wrapping
		if len(line) > 40 {
			t.Error("Line should be wrapped")
		}
	}
}

func TestOptionAliases(t *testing.T) {
	cli := &CLI{
		ProgramName: "test",
		Options: []*Option{
			{Name: "v|verbose|debug", Description: "Be verbose"},
		},
	}

	var helpText string
	cli.OnHelp = func(text string) {
		helpText = text
	}

	args := []string{"test", "--help"}
	NewParser(cli).Parse(args)

	// Check that aliases are shown
	if !strings.Contains(helpText, "--verbose") {
		t.Error("Help should show option aliases")
	}
	if !strings.Contains(helpText, "--debug") {
		t.Error("Help should show all option aliases")
	}
}