1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
moby--moby/integration-cli/docker_cli_help_test.go

320 lines
10 KiB
Go
Raw Normal View History

package main
import (
"fmt"
"runtime"
"strings"
"unicode"
"github.com/docker/docker/integration-cli/checker"
"github.com/docker/docker/integration-cli/cli"
"github.com/docker/docker/pkg/homedir"
icmd "github.com/docker/docker/pkg/testutil/cmd"
"github.com/go-check/check"
)
func (s *DockerSuite) TestHelpTextVerify(c *check.C) {
// FIXME(vdemeester) should be a unit test, probably using golden files ?
testRequires(c, DaemonIsLinux)
// Make sure main help text fits within 80 chars and that
// on non-windows system we use ~ when possible (to shorten things).
// Test for HOME set to its default value and set to "/" on linux
// Yes on windows setting up an array and looping (right now) isn't
// necessary because we just have one value, but we'll need the
// array/loop on linux so we might as well set it up so that we can
// test any number of home dirs later on and all we need to do is
// modify the array - the rest of the testing infrastructure should work
homes := []string{homedir.Get()}
// Non-Windows machines need to test for this special case of $HOME
if runtime.GOOS != "windows" {
homes = append(homes, "/")
}
homeKey := homedir.Key()
baseEnvs := appendBaseEnv(true)
// Remove HOME env var from list so we can add a new value later.
for i, env := range baseEnvs {
if strings.HasPrefix(env, homeKey+"=") {
baseEnvs = append(baseEnvs[:i], baseEnvs[i+1:]...)
break
}
}
for _, home := range homes {
// Dup baseEnvs and add our new HOME value
newEnvs := make([]string, len(baseEnvs)+1)
copy(newEnvs, baseEnvs)
newEnvs[len(newEnvs)-1] = homeKey + "=" + home
scanForHome := runtime.GOOS != "windows" && home != "/"
// Check main help text to make sure its not over 80 chars
result := icmd.RunCmd(icmd.Cmd{
Command: []string{dockerBinary, "help"},
Env: newEnvs,
})
result.Assert(c, icmd.Success)
lines := strings.Split(result.Combined(), "\n")
for _, line := range lines {
// All lines should not end with a space
c.Assert(line, checker.Not(checker.HasSuffix), " ", check.Commentf("Line should not end with a space"))
if scanForHome && strings.Contains(line, `=`+home) {
c.Fatalf("Line should use '%q' instead of %q:\n%s", homedir.GetShortcutString(), home, line)
}
if runtime.GOOS != "windows" {
i := strings.Index(line, homedir.GetShortcutString())
if i >= 0 && i != len(line)-1 && line[i+1] != '/' {
c.Fatalf("Main help should not have used home shortcut:\n%s", line)
}
}
}
// Make sure each cmd's help text fits within 90 chars and that
// on non-windows system we use ~ when possible (to shorten things).
// Pull the list of commands from the "Commands:" section of docker help
// FIXME(vdemeester) Why re-run help ?
//helpCmd = exec.Command(dockerBinary, "help")
//helpCmd.Env = newEnvs
//out, _, err = runCommandWithOutput(helpCmd)
//c.Assert(err, checker.IsNil, check.Commentf(out))
i := strings.Index(result.Combined(), "Commands:")
c.Assert(i, checker.GreaterOrEqualThan, 0, check.Commentf("Missing 'Commands:' in:\n%s", result.Combined()))
cmds := []string{}
// Grab all chars starting at "Commands:"
helpOut := strings.Split(result.Combined()[i:], "\n")
// Skip first line, it is just "Commands:"
helpOut = helpOut[1:]
// Create the list of commands we want to test
cmdsToTest := []string{}
for _, cmd := range helpOut {
// Stop on blank line or non-indented line
if cmd == "" || !unicode.IsSpace(rune(cmd[0])) {
break
}
// Grab just the first word of each line
cmd = strings.Split(strings.TrimSpace(cmd), " ")[0]
cmds = append(cmds, cmd) // Saving count for later
cmdsToTest = append(cmdsToTest, cmd)
}
// Add some 'two word' commands - would be nice to automatically
// calculate this list - somehow
cmdsToTest = append(cmdsToTest, "volume create")
cmdsToTest = append(cmdsToTest, "volume inspect")
cmdsToTest = append(cmdsToTest, "volume ls")
cmdsToTest = append(cmdsToTest, "volume rm")
cmdsToTest = append(cmdsToTest, "network connect")
cmdsToTest = append(cmdsToTest, "network create")
cmdsToTest = append(cmdsToTest, "network disconnect")
cmdsToTest = append(cmdsToTest, "network inspect")
cmdsToTest = append(cmdsToTest, "network ls")
cmdsToTest = append(cmdsToTest, "network rm")
if testEnv.ExperimentalDaemon() {
cmdsToTest = append(cmdsToTest, "checkpoint create")
cmdsToTest = append(cmdsToTest, "checkpoint ls")
cmdsToTest = append(cmdsToTest, "checkpoint rm")
}
// Divide the list of commands into go routines and run the func testcommand on the commands in parallel
// to save runtime of test
errChan := make(chan error)
for index := 0; index < len(cmdsToTest); index++ {
go func(index int) {
errChan <- testCommand(cmdsToTest[index], newEnvs, scanForHome, home)
}(index)
}
for index := 0; index < len(cmdsToTest); index++ {
err := <-errChan
if err != nil {
c.Fatal(err)
}
}
}
}
func (s *DockerSuite) TestHelpExitCodesHelpOutput(c *check.C) {
// Test to make sure the exit code and output (stdout vs stderr) of
// various good and bad cases are what we expect
// docker : stdout=all, stderr=empty, rc=0
out := cli.DockerCmd(c).Combined()
// Be really pick
c.Assert(out, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have a blank line at the end of 'docker'\n"))
// docker help: stdout=all, stderr=empty, rc=0
out = cli.DockerCmd(c, "help").Combined()
// Be really pick
c.Assert(out, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have a blank line at the end of 'docker help'\n"))
// docker --help: stdout=all, stderr=empty, rc=0
out = cli.DockerCmd(c, "--help").Combined()
// Be really pick
c.Assert(out, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have a blank line at the end of 'docker --help'\n"))
// docker inspect busybox: stdout=all, stderr=empty, rc=0
// Just making sure stderr is empty on valid cmd
out = cli.DockerCmd(c, "inspect", "busybox").Combined()
// Be really pick
c.Assert(out, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have a blank line at the end of 'docker inspect busyBox'\n"))
// docker rm: stdout=empty, stderr=all, rc!=0
// testing the min arg error msg
cli.Docker(cli.Args("rm")).Assert(c, icmd.Expected{
ExitCode: 1,
Error: "exit status 1",
Out: "",
// Should not contain full help text but should contain info about
// # of args and Usage line
Err: "requires at least 1 argument",
})
// docker rm NoSuchContainer: stdout=empty, stderr=all, rc=0
// testing to make sure no blank line on error
result := cli.Docker(cli.Args("rm", "NoSuchContainer")).Assert(c, icmd.Expected{
ExitCode: 1,
Error: "exit status 1",
Out: "",
})
// Be really picky
c.Assert(len(result.Stderr()), checker.Not(checker.Equals), 0)
c.Assert(result.Stderr(), checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have a blank line at the end of 'docker rm'\n"))
// docker BadCmd: stdout=empty, stderr=all, rc=0
cli.Docker(cli.Args("BadCmd")).Assert(c, icmd.Expected{
ExitCode: 1,
Error: "exit status 1",
Out: "",
Err: "docker: 'BadCmd' is not a docker command.\nSee 'docker --help'\n",
})
}
func testCommand(cmd string, newEnvs []string, scanForHome bool, home string) error {
args := strings.Split(cmd+" --help", " ")
// Check the full usage text
result := icmd.RunCmd(icmd.Cmd{
Command: append([]string{dockerBinary}, args...),
Env: newEnvs,
})
err := result.Error
out := result.Stdout()
stderr := result.Stderr()
if len(stderr) != 0 {
return fmt.Errorf("Error on %q help. non-empty stderr:%q\n", cmd, stderr)
}
if strings.HasSuffix(out, "\n\n") {
return fmt.Errorf("Should not have blank line on %q\n", cmd)
}
if !strings.Contains(out, "--help") {
return fmt.Errorf("All commands should mention '--help'. Command '%v' did not.\n", cmd)
}
if err != nil {
return fmt.Errorf(out)
}
// Check each line for lots of stuff
lines := strings.Split(out, "\n")
for _, line := range lines {
i := strings.Index(line, "~")
if i >= 0 && i != len(line)-1 && line[i+1] != '/' {
return fmt.Errorf("Help for %q should not have used ~:\n%s", cmd, line)
}
// Options should NOT end with a period
if strings.HasPrefix(line, " -") && strings.HasSuffix(line, ".") {
return fmt.Errorf("Help for %q should not end with a period: %s", cmd, line)
}
// Options should NOT end with a space
if strings.HasSuffix(line, " ") {
return fmt.Errorf("Help for %q should not end with a space: %s", cmd, line)
}
}
// For each command make sure we generate an error
// if we give a bad arg
args = strings.Split(cmd+" --badArg", " ")
out, _, err = dockerCmdWithError(args...)
if err == nil {
return fmt.Errorf(out)
}
// Be really picky
if strings.HasSuffix(stderr, "\n\n") {
return fmt.Errorf("Should not have a blank line at the end of 'docker rm'\n")
}
// Now make sure that each command will print a short-usage
// (not a full usage - meaning no opts section) if we
// are missing a required arg or pass in a bad arg
// These commands will never print a short-usage so don't test
noShortUsage := map[string]string{
"images": "",
"login": "",
"logout": "",
"network": "",
"stats": "",
"volume create": "",
}
if _, ok := noShortUsage[cmd]; !ok {
// skipNoArgs are ones that we don't want to try w/o
// any args. Either because it'll hang the test or
// lead to incorrect test result (like false negative).
// Whatever the reason, skip trying to run w/o args and
// jump to trying with a bogus arg.
skipNoArgs := map[string]struct{}{
"daemon": {},
"events": {},
"load": {},
}
var result *icmd.Result
if _, ok := skipNoArgs[cmd]; !ok {
result = dockerCmdWithResult(strings.Split(cmd, " ")...)
}
// If its ok w/o any args then try again with an arg
if result == nil || result.ExitCode == 0 {
result = dockerCmdWithResult(strings.Split(cmd+" badArg", " ")...)
}
if err := result.Compare(icmd.Expected{
Out: icmd.None,
Err: "\nUsage:",
ExitCode: 1,
}); err != nil {
return err
}
stderr := result.Stderr()
// Shouldn't have full usage
if strings.Contains(stderr, "--help=false") {
return fmt.Errorf("Should not have full usage on %q:%v", result.Cmd.Args, stderr)
}
if strings.HasSuffix(stderr, "\n\n") {
return fmt.Errorf("Should not have a blank line on %q\n%v", result.Cmd.Args, stderr)
}
}
return nil
}