From cfc22810451affb32ba79e3e5d5992b03f4968ad Mon Sep 17 00:00:00 2001 From: John Coffey Date: Fri, 13 Nov 2026 08:58:03 -0700 Subject: [PATCH] Add shell completions and a man page inbuxa completions bash|zsh|fish writes a completion script, and inbuxa man writes the manual page in roff. Both are generated from one command model that mirrors the commands and their flags, so they stay in step with the binary -- a single static binary writes its own rather than shipping separate files. The completions complete the commands, each command's flags, the relay and cluster subcommands, and the values of the flags that take a fixed set (--server/--console/--webmail, --proxy) or a file. A test parses the real top-level switch in main() and fails if a command is added without a model entry, or the reverse, so the two cannot drift apart. This is the installer's half of the cross-cutting completions-and-man parity the cli and migrate already have. --- README.md | 16 ++ cmd/inbuxa/completions.go | 354 +++++++++++++++++++++++++++++++++ cmd/inbuxa/completions_test.go | 163 +++++++++++++++ cmd/inbuxa/main.go | 6 + cmd/inbuxa/man.go | 115 +++++++++++ cmd/inbuxa/man_test.go | 54 +++++ 6 files changed, 708 insertions(+) create mode 100644 cmd/inbuxa/completions.go create mode 100644 cmd/inbuxa/completions_test.go create mode 100644 cmd/inbuxa/man.go create mode 100644 cmd/inbuxa/man_test.go diff --git a/README.md b/README.md index b6815e4..bbac1bf 100644 --- a/README.md +++ b/README.md @@ -242,6 +242,22 @@ candidate (before 27.1 the tags were dated, `v2026.10.15.2`). builds the same thing locally. A release candidate is published as a pre-release, so `releases/latest` stays on the last final release. +## Shell completions and a man page + +The binary writes its own, so there is nothing extra to download. For +completion of the commands, flags and their values: + + inbuxa completions bash | sudo tee /etc/bash_completion.d/inbuxa >/dev/null + inbuxa completions zsh > "${fpath[1]}/_inbuxa" # a directory on your $fpath + inbuxa completions fish > ~/.config/fish/completions/inbuxa.fish + +For the manual page: + + inbuxa man | sudo tee /usr/share/man/man1/inbuxa.1 >/dev/null + man inbuxa + +Both are generated from the command list, so they match the binary you have. + ## Building and testing go build ./cmd/inbuxa diff --git a/cmd/inbuxa/completions.go b/cmd/inbuxa/completions.go new file mode 100644 index 0000000..97adadc --- /dev/null +++ b/cmd/inbuxa/completions.go @@ -0,0 +1,354 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package main + +import ( + "fmt" + "os" + "strings" +) + +// The command model below is the one source the completion scripts and the +// man page are generated from, so a new command or flag reaches both at once. +// It mirrors the flags each command's FlagSet defines in this file; +// completions_test.go checks the top-level list against the usage text, which +// catches a command added without a model entry. + +type command struct { + name string + desc string // one line, for the shell's menu and the man page + arg string // a positional the command takes: "url", "component", "shell"; "" for none + flags []string // long flag names, without the leading dashes + subs []command // subcommands, for relay and cluster +} + +// commands is every top-level command, in the order the usage text lists them. +func commands() []command { + install := []string{ + "domain", "mail-host", "console-host", "webmail-host", "email", + "server", "console", "webmail", "proxy", "dir", "local", + "acme-directory", "acme-ca-root", "install-deps", "key", + "dry-run", "yes", "answers", + } + join := []string{ + "key", "console", "webmail", "domain", "console-host", "webmail-host", + "email", "proxy", "dir", "local", "install-deps", "replace", + "exempt-address", "acme-directory", "acme-ca-root", "dry-run", "yes", + } + return []command{ + {name: "install", desc: "Install or converge the suite on this machine", flags: install}, + {name: "join", desc: "Install the console and webmail here for a server at URL", arg: "url", flags: join}, + {name: "survey", desc: "Report what this machine is, as the installer sees it"}, + {name: "deps", desc: "Report what a shape needs, and with --install fix it", flags: []string{"server", "console", "webmail", "install"}}, + {name: "plan", desc: "Show what a topology file would change here", flags: []string{"f", "machine", "yes", "install-deps", "key"}}, + {name: "apply", desc: "Make this machine match a topology file", flags: []string{"f", "machine", "yes", "install-deps", "key"}}, + {name: "export", desc: "Write a topology file from what is here", flags: []string{"o"}}, + {name: "status", desc: "Report what is installed here, and whether it agrees"}, + {name: "doctor", desc: "Run a read-only health check of this install", flags: []string{"timeout"}}, + {name: "backup", desc: "Archive this machine's mail server to /backups", flags: []string{"yes"}}, + {name: "upgrade", desc: "Move what is here to the releases this installer installs", arg: "component", flags: []string{"dry-run", "yes", "no-backup", "check"}}, + {name: "uninstall", desc: "Remove the programs, keep the data", flags: []string{"dry-run", "yes", "purge"}}, + {name: "certs", desc: "Inspect or renew the mail server's certificate", flags: []string{"key", "mail-host", "email", "acme-directory", "dry-run"}}, + {name: "dns", desc: "Print the DNS records the domain needs", flags: []string{"refresh", "key", "domain"}}, + {name: "relay", desc: "Manage inbuxa Relay on a machine of its own", subs: []command{ + {name: "install", desc: "Install the relay here", flags: []string{"token", "dry-run", "yes"}}, + {name: "status", desc: "Report the relay's status (needs root)"}, + {name: "uninstall", desc: "Remove the relay", flags: []string{"purge", "discard-held", "dry-run", "yes"}}, + }}, + {name: "cluster", desc: "Join a cluster's data layer, or check it can be reached", subs: []command{ + {name: "doctor", desc: "Check this node can reach a cluster's data layer", flags: []string{"pg", "nats", "etcd", "patroni", "s3", "timeout"}}, + {name: "join", desc: "Point this node's server at a cluster's shared store", arg: "file", flags: []string{"f", "machine", "dry-run", "yes"}}, + }}, + {name: "version", desc: "Print this program's version"}, + {name: "completions", desc: "Output a shell completion script (bash, zsh or fish)", arg: "shell"}, + {name: "man", desc: "Output the manual page, in roff"}, + {name: "help", desc: "Show the help"}, + } +} + +// Flags whose value is one of a small fixed set, or a file, so the scripts can +// offer the right thing after the flag. +var ( + shapeFlags = map[string]bool{"server": true, "console": true, "webmail": true} + proxyFlag = "proxy" + fileFlags = map[string]bool{"f": true, "o": true, "answers": true, "acme-ca-root": true, "dir": true} +) + +const ( + shapeValues = "skip container host" + proxyValues = "caddy snippets none" + shellValues = "bash zsh fish" +) + +// flagToken renders a flag as it is typed: -f for a one-letter flag, --name +// otherwise. Go's flag package accepts either form, but this matches the docs. +func flagToken(name string) string { + if len(name) == 1 { + return "-" + name + } + return "--" + name +} + +func flagTokens(names []string) []string { + out := make([]string, len(names)) + for i, n := range names { + out[i] = flagToken(n) + } + return out +} + +// completionsCmd writes a shell completion script to standard output. The +// shell is given as the one argument; the script is generated from the command +// model so it stays in step with the commands and flags. +func completionsCmd(args []string) int { + if len(args) != 1 || args[0] == "-h" || args[0] == "--help" { + fmt.Fprintln(os.Stderr, "usage: inbuxa completions bash|zsh|fish") + fmt.Fprintln(os.Stderr, "\nInstall, for the current shell, with e.g.:") + fmt.Fprintln(os.Stderr, " inbuxa completions bash | sudo tee /etc/bash_completion.d/inbuxa") + fmt.Fprintln(os.Stderr, " inbuxa completions zsh > \"${fpath[1]}/_inbuxa\"") + fmt.Fprintln(os.Stderr, " inbuxa completions fish > ~/.config/fish/completions/inbuxa.fish") + if len(args) == 1 && (args[0] == "-h" || args[0] == "--help") { + return 0 + } + return 2 + } + var s string + switch args[0] { + case "bash": + s = bashCompletion() + case "zsh": + s = zshCompletion() + case "fish": + s = fishCompletion() + default: + fmt.Fprintf(os.Stderr, "inbuxa has no completions for %q: bash, zsh or fish\n", args[0]) + return 2 + } + fmt.Print(s) + return 0 +} + +func topNames() []string { + cs := commands() + out := make([]string, len(cs)) + for i, c := range cs { + out[i] = c.name + } + return out +} + +// ---- bash ---- + +func bashCompletion() string { + var b strings.Builder + p := func(format string, a ...any) { fmt.Fprintf(&b, format+"\n", a...) } + + p("# bash completion for inbuxa -- generated by `inbuxa completions bash`") + p("_inbuxa() {") + p(" local cur prev cmd sub i") + p(" cur=\"${COMP_WORDS[COMP_CWORD]}\"") + p(" prev=\"${COMP_WORDS[COMP_CWORD-1]}\"") + p("") + p(" # a value for the flag just typed") + p(" case \"$prev\" in") + p(" --server|--console|--webmail) COMPREPLY=( $(compgen -W %q -- \"$cur\") ); return;;", shapeValues) + p(" --proxy) COMPREPLY=( $(compgen -W %q -- \"$cur\") ); return;;", proxyValues) + p(" -f|-o|--answers|--acme-ca-root|--dir) COMPREPLY=( $(compgen -f -- \"$cur\") ); return;;") + p(" esac") + p("") + p(" # the first word that is not a flag is the command") + p(" cmd=\"\"") + p(" for (( i=1; i 0 { + p(" %s)", c.name) + p(" sub=\"\"") + p(" for (( i=2; i 0 { + p(" %s)", c.name) + p(" local -a subs") + p(" subs=(") + for _, s := range c.subs { + p(" %s", zshDescribe(s.name, s.desc)) + } + p(" )") + p(" sub=\"\"") + p(" for (( i=3; i<=CURRENT; i++ )); do case \"${words[i]}\" in -*) ;; \"\") ;; *) sub=\"${words[i]}\"; break;; esac; done") + p(" case \"$sub\" in") + for _, s := range c.subs { + if len(s.flags) == 0 { + p(" %s) ;;", s.name) + } else { + p(" %s) compadd -- %s ;;", s.name, strings.Join(flagTokens(s.flags), " ")) + } + } + p(" *) _describe -t commands '%s command' subs ;;", c.name) + p(" esac ;;") + continue + } + if c.arg == "shell" { + p(" %s) compadd bash zsh fish ;;", c.name) + continue + } + if len(c.flags) == 0 { + p(" %s) ;;", c.name) + } else { + p(" %s) compadd -- %s ;;", c.name, strings.Join(flagTokens(c.flags), " ")) + } + } + p(" esac") + p("}") + p("_inbuxa \"$@\"") + return b.String() +} + +// zshDescribe renders one 'name:description' entry for _describe. The colon in +// the description is escaped so zsh does not read it as the separator, and the +// whole is single-quoted with any apostrophe escaped the POSIX way ('\”) so a +// word like "machine's" does not end the quote. +func zshDescribe(name, desc string) string { + body := name + ":" + strings.ReplaceAll(desc, ":", "\\:") + return "'" + strings.ReplaceAll(body, "'", `'\''`) + "'" +} + +// ---- fish ---- + +func fishCompletion() string { + var b strings.Builder + p := func(format string, a ...any) { fmt.Fprintf(&b, format+"\n", a...) } + + p("# fish completion for inbuxa -- generated by `inbuxa completions fish`") + p("complete -c inbuxa -f") + p("") + p("# top-level commands") + for _, c := range commands() { + p("complete -c inbuxa -n __fish_use_subcommand -a %s -d %s", c.name, fishQuote(c.desc)) + } + for _, c := range commands() { + if len(c.subs) > 0 { + p("") + p("# %s subcommands", c.name) + p("complete -c inbuxa -n '__fish_seen_subcommand_from %s; and not __fish_seen_subcommand_from %s' -a '%s'", c.name, subNames(c), subNames(c)) + for _, s := range c.subs { + for _, fl := range s.flags { + p("complete -c inbuxa -n '__fish_seen_subcommand_from %s; and __fish_seen_subcommand_from %s' %s", c.name, s.name, fishFlag(fl)) + } + } + continue + } + if c.arg == "shell" { + p("complete -c inbuxa -n '__fish_seen_subcommand_from %s' -a 'bash zsh fish'", c.name) + continue + } + if len(c.flags) == 0 { + continue + } + p("") + p("# %s flags", c.name) + for _, fl := range c.flags { + p("complete -c inbuxa -n '__fish_seen_subcommand_from %s' %s", c.name, fishFlag(fl)) + } + } + return b.String() +} + +// fishFlag renders one flag for `complete`, with a value hint where the value +// is a known set or a file. +func fishFlag(name string) string { + var spec string + if len(name) == 1 { + spec = "-s " + name + } else { + spec = "-l " + name + } + switch { + case shapeFlags[name]: + return spec + " -x -a 'skip container host'" + case name == proxyFlag: + return spec + " -x -a 'caddy snippets none'" + case fileFlags[name]: + return spec + " -r -F" + } + return spec +} + +func fishQuote(s string) string { + return "'" + strings.ReplaceAll(s, "'", "\\'") + "'" +} diff --git a/cmd/inbuxa/completions_test.go b/cmd/inbuxa/completions_test.go new file mode 100644 index 0000000..ecb6721 --- /dev/null +++ b/cmd/inbuxa/completions_test.go @@ -0,0 +1,163 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package main + +import ( + "os" + "regexp" + "strings" + "testing" +) + +// TestModelMatchesSwitch guards against a top-level command being added to the +// dispatch in main() without a matching entry in the completion model (which +// would leave it out of the scripts and the man page), and the reverse. It +// reads the real `switch os.Args[1]` block, so the two cannot drift apart +// unnoticed. +func TestModelMatchesSwitch(t *testing.T) { + src, err := os.ReadFile("main.go") + if err != nil { + t.Fatal(err) + } + lines := strings.Split(string(src), "\n") + start := -1 + for i, l := range lines { + if strings.Contains(l, "switch os.Args[1] {") { + start = i + break + } + } + if start < 0 { + t.Fatal("could not find the top-level switch in main.go") + } + caseRe := regexp.MustCompile(`"([^"]+)"`) + inSwitch := map[string]bool{} + for _, l := range lines[start+1:] { + if l == "\t}" { // the switch's own closing brace, at one tab + break + } + if !strings.HasPrefix(strings.TrimLeft(l, " "), "case ") && !strings.HasPrefix(l, "\tcase ") { + continue + } + for _, m := range caseRe.FindAllStringSubmatch(l, -1) { + tok := m[1] + switch tok { + case "-h", "--help": // these fold into "help" + default: + inSwitch[tok] = true + } + } + } + if len(inSwitch) == 0 { + t.Fatal("parsed no cases from the top-level switch") + } + + inModel := map[string]bool{} + for _, c := range commands() { + inModel[c.name] = true + } + for name := range inSwitch { + if !inModel[name] { + t.Errorf("command %q is dispatched in main() but missing from the completion model", name) + } + } + for name := range inModel { + if !inSwitch[name] { + t.Errorf("command %q is in the completion model but not dispatched in main()", name) + } + } +} + +func TestBashCompletion(t *testing.T) { + s := bashCompletion() + for _, want := range []string{ + "complete -F _inbuxa inbuxa", + "install join survey", // the top-level list + "--domain", // an install flag + "--token", // a relay install flag + "skip container host", // shape values + "caddy snippets none", // proxy values + "bash zsh fish", // completions' own argument + } { + if !strings.Contains(s, want) { + t.Errorf("bash completion is missing %q", want) + } + } +} + +func TestZshCompletion(t *testing.T) { + s := zshCompletion() + for _, want := range []string{ + "#compdef inbuxa", + "_describe", + "compadd skip container host", + "--exempt-address", // a join flag + "--pg", // a cluster doctor flag + } { + if !strings.Contains(s, want) { + t.Errorf("zsh completion is missing %q", want) + } + } + // A description's colon must be escaped so zsh does not split on it. + if strings.Contains(zshDescribe("x", "a:b"), ":b") && !strings.Contains(zshDescribe("x", "a:b"), "a\\:b") { + t.Errorf("zshDescribe did not escape the colon: %q", zshDescribe("x", "a:b")) + } +} + +func TestFishCompletion(t *testing.T) { + s := fishCompletion() + for _, want := range []string{ + "complete -c inbuxa -f", + "__fish_use_subcommand -a install", + "__fish_seen_subcommand_from relay", // relay sub gating + "-a 'install status uninstall'", // relay subcommands + "-l server -x -a 'skip container host'", // shape value hint + "-l answers -r -F", // a file flag + } { + if !strings.Contains(s, want) { + t.Errorf("fish completion is missing %q", want) + } + } +} + +// Every command and flag in the model must appear somewhere in each script, so +// nothing the model knows about is silently dropped by a generator. +func TestEveryCommandAndFlagInEachScript(t *testing.T) { + scripts := map[string]string{ + "bash": bashCompletion(), + "zsh": zshCompletion(), + "fish": fishCompletion(), + } + for shell, s := range scripts { + for _, c := range commands() { + if !strings.Contains(s, c.name) { + t.Errorf("%s completion is missing command %q", shell, c.name) + } + for _, fl := range c.flags { + if !strings.Contains(s, strings.TrimLeft(flagToken(fl), "-")) { + t.Errorf("%s completion is missing flag %q of %q", shell, fl, c.name) + } + } + for _, sub := range c.subs { + if !strings.Contains(s, sub.name) { + t.Errorf("%s completion is missing %q subcommand %q", shell, c.name, sub.name) + } + } + } + } +} + +func TestCompletionsCmdArgs(t *testing.T) { + if code := completionsCmd(nil); code != 2 { + t.Errorf("no shell should exit 2, got %d", code) + } + if code := completionsCmd([]string{"powershell"}); code != 2 { + t.Errorf("an unsupported shell should exit 2, got %d", code) + } + for _, sh := range []string{"bash", "zsh", "fish"} { + if code := completionsCmd([]string{sh}); code != 0 { + t.Errorf("%s should exit 0, got %d", sh, code) + } + } +} diff --git a/cmd/inbuxa/main.go b/cmd/inbuxa/main.go index 3acad04..c22aa91 100644 --- a/cmd/inbuxa/main.go +++ b/cmd/inbuxa/main.go @@ -81,6 +81,8 @@ const usage = `inbuxa -- install the inbuxa suite on this machine inbuxa cluster join -f FILE point this node's server at the shared store in the file's cluster block and give it its role + inbuxa completions SHELL a completion script for bash, zsh or fish + inbuxa man the manual page, in roff (inbuxa man > inbuxa.1) inbuxa version this program's version install flags: @@ -235,6 +237,10 @@ func main() { os.Exit(relayCmd(os.Args[2:])) case "cluster": os.Exit(clusterCmd(os.Args[2:])) + case "completions": + os.Exit(completionsCmd(os.Args[2:])) + case "man": + os.Exit(manCmd(os.Args[2:])) case "version": fmt.Println(version) case "-h", "--help", "help": diff --git a/cmd/inbuxa/man.go b/cmd/inbuxa/man.go new file mode 100644 index 0000000..75c4036 --- /dev/null +++ b/cmd/inbuxa/man.go @@ -0,0 +1,115 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package main + +import ( + "fmt" + "os" + "strings" + "time" +) + +// manCmd writes the manual page, in roff, to standard output. It is generated +// from the same command model as the completions, so `inbuxa man > inbuxa.1` +// at release time stays in step with the commands. Install it with, e.g., +// `inbuxa man | sudo tee /usr/share/man/man1/inbuxa.1`. +func manCmd(args []string) int { + if len(args) > 0 && (args[0] == "-h" || args[0] == "--help") { + fmt.Fprintln(os.Stderr, "usage: inbuxa man # writes the manual page in roff to stdout") + return 0 + } + if len(args) > 0 { + fmt.Fprintln(os.Stderr, "inbuxa man takes no arguments") + return 2 + } + fmt.Print(manPage()) + return 0 +} + +func manPage() string { + var b strings.Builder + p := func(format string, a ...any) { fmt.Fprintf(&b, format+"\n", a...) } + + date := time.Now().UTC().Format("2006-01-02") + p(".TH INBUXA 1 %q %q \"inbuxa manual\"", date, "inbuxa "+version) + p(".SH NAME") + p("inbuxa \\- install the inbuxa mail suite on this machine") + p(".SH SYNOPSIS") + p(".B inbuxa") + p("[\\fICOMMAND\\fR] [\\fIFLAGS\\fR]") + p(".SH DESCRIPTION") + p("Run with no arguments, \\fBinbuxa\\fR opens an interface that fills in the") + p("machine's own facts in front of you. Run with a command it does the same") + p("work without asking. It installs the server, the console and the webmail,") + p("each in a container or on the host, and looks after certificates, DNS and") + p("upgrades afterwards.") + p(".SH COMMANDS") + for _, c := range commands() { + head := c.name + if c.arg == "url" { + head += " URL" + } + if c.arg == "component" { + head += " [component...]" + } + if len(c.subs) > 0 { + head += " " + subBar(c) + } else if len(c.flags) > 0 { + head += " [flags]" + } + p(".TP") + p(".B %s", roff(head)) + p("%s.", roff(strings.TrimRight(c.desc, "."))) + if len(c.subs) > 0 { + p(".RS") + for _, s := range c.subs { + p(".TP") + p(".B %s", roff(s.name)) + desc := roff(strings.TrimRight(s.desc, ".")) + if len(s.flags) > 0 { + desc += ". Flags: " + roff(strings.Join(flagTokens(s.flags), ", ")) + } else { + desc += "." + } + p("%s", desc) + } + p(".RE") + } else if len(c.flags) > 0 { + p(".br") + p("Flags: %s", roff(strings.Join(flagTokens(c.flags), ", "))) + } + } + p(".SH FILES") + p(".TP") + p(".I /etc/inbuxa/install.json") + p("What is installed on this machine, as inbuxa recorded it.") + p(".SH SEE ALSO") + p(".BR inbuxa\\-cli (1),") + p(".BR inbuxa\\-migrate (1)") + p(".PP") + p("Full documentation at \\fIhttps://docs.inbuxa.org/\\fR, and verifying a") + p("download at \\fIhttps://docs.inbuxa.org/install/verifying/\\fR.") + p(".SH COPYRIGHT") + p("Copyright \\(co 2026 Coffey Labs LLC. License AGPL\\-3.0\\-or\\-later.") + return b.String() +} + +func subBar(c command) string { + out := make([]string, len(c.subs)) + for i, s := range c.subs { + out[i] = s.name + } + return strings.Join(out, "|") +} + +// roff escapes text for a roff line: a backslash becomes \e, and a leading dash +// of an option is written \- so it renders as a minus. Hyphens inside a word +// render as hyphens, which is what we want for names like mail-host. +func roff(s string) string { + s = strings.ReplaceAll(s, "\\", "\\e") + // Escape the leading dashes of option tokens so mandoc is happy. + s = strings.ReplaceAll(s, "--", "\\-\\-") + s = strings.ReplaceAll(s, " -", " \\-") + return s +} diff --git a/cmd/inbuxa/man_test.go b/cmd/inbuxa/man_test.go new file mode 100644 index 0000000..415622a --- /dev/null +++ b/cmd/inbuxa/man_test.go @@ -0,0 +1,54 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: AGPL-3.0-or-later + +package main + +import ( + "strings" + "testing" +) + +func TestManPage(t *testing.T) { + m := manPage() + for _, want := range []string{ + ".TH INBUXA 1 ", + ".SH NAME", + "inbuxa \\- install the inbuxa mail suite", + ".SH SYNOPSIS", + ".SH DESCRIPTION", + ".SH COMMANDS", + ".SH FILES", + "/etc/inbuxa/install.json", + ".SH SEE ALSO", + "inbuxa\\-cli (1)", + "AGPL\\-3.0\\-or\\-later", + } { + if !strings.Contains(m, want) { + t.Errorf("man page is missing %q", want) + } + } + // Every command gets a .TP entry; check a representative spread. + for _, name := range []string{"install", "join", "backup", "cluster", "relay", "completions", "man"} { + if !strings.Contains(m, ".B "+name) { + t.Errorf("man page has no entry for %q", name) + } + } + // Option dashes are escaped for roff. + if !strings.Contains(m, "\\-\\-domain") { + t.Errorf("man page did not escape the dashes of --domain") + } + // No control line may start with a bare backslash-less stray; the page + // must at least be non-trivial. + if strings.Count(m, "\n") < 40 { + t.Errorf("man page looks too short: %d lines", strings.Count(m, "\n")) + } +} + +func TestManCmdArgs(t *testing.T) { + if code := manCmd(nil); code != 0 { + t.Errorf("man with no args should exit 0, got %d", code) + } + if code := manCmd([]string{"extra"}); code != 2 { + t.Errorf("man with an argument should exit 2, got %d", code) + } +} -- 2.54.0