package main
 
 import (

 	"os"

 	"os/exec"

 	"runtime"

 	"strings"

 	"unicode"

 
 	"github.com/docker/docker/pkg/homedir"

 	"github.com/docker/docker/pkg/integration/checker"

 	"github.com/go-check/check"

 )
 

 func (s *DockerSuite) TestHelpTextVerify(c *check.C) {

 	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 := os.Environ()

 	// 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
 		helpCmd := exec.Command(dockerBinary, "help")
 		helpCmd.Env = newEnvs

 		out, _, err := runCommandWithOutput(helpCmd)
 		c.Assert(err, checker.IsNil, check.Commentf(out))

 		lines := strings.Split(out, "\n")
 		for _, line := range lines {

 			c.Assert(len(line), checker.LessOrEqualThan, 80, check.Commentf("Line is too long:\n%s", line))

 			// 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
 		helpCmd = exec.Command(dockerBinary, "help")
 		helpCmd.Env = newEnvs

 		out, _, err = runCommandWithOutput(helpCmd)
 		c.Assert(err, checker.IsNil, check.Commentf(out))

 		i := strings.Index(out, "Commands:")

 		c.Assert(i, checker.GreaterOrEqualThan, 0, check.Commentf("Missing 'Commands:' in:\n%s", out))

 
 		cmds := []string{}

 		// Grab all chars starting at "Commands:"
 		helpOut := strings.Split(out[i:], "\n")
 		// First line is just "Commands:"
 		if isLocalDaemon {
 			// Replace first line with "daemon" command since it's not part of the list of commands.
 			helpOut[0] = " daemon"
 		} else {
 			// Skip first line
 			helpOut = helpOut[1:]
 		}

 		// Create the list of commands we want to test
 		cmdsToTest := []string{}
 		for _, cmd := range helpOut {

 			// Stop on blank line or non-idented 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")
 
 		for _, cmd := range cmdsToTest {
 			var stderr string
 
 			args := strings.Split(cmd+" --help", " ")

 			// Check the full usage text

 			helpCmd := exec.Command(dockerBinary, args...)

 			helpCmd.Env = newEnvs

 			out, stderr, _, err = runCommandWithStdoutStderr(helpCmd)
 			c.Assert(len(stderr), checker.Equals, 0, check.Commentf("Error on %q help. non-empty stderr:%q", cmd, stderr))
 			c.Assert(out, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have blank line on %q\n", cmd))

 			c.Assert(out, checker.Contains, "--help", check.Commentf("All commands should mention '--help'. Command '%v' did not.\n", cmd))

 
 			c.Assert(err, checker.IsNil, check.Commentf(out))

 
 			// Check each line for lots of stuff

 			lines := strings.Split(out, "\n")
 			for _, line := range lines {

 				c.Assert(len(line), checker.LessOrEqualThan, 107, check.Commentf("Help for %q is too long:\n%s", cmd, line))

 				if scanForHome && strings.Contains(line, `"`+home) {

 					c.Fatalf("Help for %q should use ~ instead of %q on:\n%s",

 						cmd, home, line)
 				}
 				i := strings.Index(line, "~")
 				if i >= 0 && i != len(line)-1 && line[i+1] != '/' {

 					c.Fatalf("Help for %q should not have used ~:\n%s", cmd, line)

 				}

 
 				// If a line starts with 4 spaces then assume someone
 				// added a multi-line description for an option and we need
 				// to flag it

 				c.Assert(line, checker.Not(checker.HasPrefix), "    ", check.Commentf("Help for %q should not have a multi-line option", cmd))

 
 				// Options should NOT end with a period
 				if strings.HasPrefix(line, "  -") && strings.HasSuffix(line, ".") {

 					c.Fatalf("Help for %q should not end with a period: %s", cmd, line)

 				}

 				// Options should NOT end with a space

 				c.Assert(line, checker.Not(checker.HasSuffix), " ", check.Commentf("Help for %q should not end with a space", cmd))

 			}

 
 			// For each command make sure we generate an error
 			// if we give a bad arg

 			args = strings.Split(cmd+" --badArg", " ")
 

 			out, _, err = dockerCmdWithError(args...)
 			c.Assert(err, checker.NotNil, check.Commentf(out))

 			// Be really picky

 			c.Assert(stderr, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("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":   "",

 			}
 
 			if _, ok := noShortUsage[cmd]; !ok {
 				// For each command run it w/o any args. It will either return
 				// valid output or print a short-usage
 				var dCmd *exec.Cmd
 				var stdout, stderr string
 				var args []string
 
 				// 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":   {},

 				}
 

 				ec := 0

 				if _, ok := skipNoArgs[cmd]; !ok {

 					args = strings.Split(cmd, " ")

 					dCmd = exec.Command(dockerBinary, args...)
 					stdout, stderr, ec, err = runCommandWithStdoutStderr(dCmd)
 				}
 
 				// If its ok w/o any args then try again with an arg
 				if ec == 0 {

 					args = strings.Split(cmd+" badArg", " ")

 					dCmd = exec.Command(dockerBinary, args...)
 					stdout, stderr, ec, err = runCommandWithStdoutStderr(dCmd)
 				}
 
 				if len(stdout) != 0 || len(stderr) == 0 || ec == 0 || err == nil {
 					c.Fatalf("Bad output from %q\nstdout:%q\nstderr:%q\nec:%d\nerr:%q", args, stdout, stderr, ec, err)
 				}
 				// Should have just short usage

 				c.Assert(stderr, checker.Contains, "\nUsage:\t", check.Commentf("Missing short usage on %q\n", args))

 				// But shouldn't have full usage

 				c.Assert(stderr, checker.Not(checker.Contains), "--help=false", check.Commentf("Should not have full usage on %q\n", args))
 				c.Assert(stderr, checker.Not(checker.HasSuffix), "\n\n", check.Commentf("Should not have a blank line on %q\n", args))

 			}
 

 		}
 

 		// Number of commands for standard release and experimental release

 		standard := 41

 		experimental := 1
 		expected := standard + experimental

 		if isLocalDaemon {
 			expected++ // for the daemon command
 		}

 		c.Assert(len(cmds), checker.LessOrEqualThan, expected, check.Commentf("Wrong # of cmds, it should be: %d\nThe list:\n%q", expected, cmds))

 	}
 

 }

 func (s *DockerSuite) TestHelpExitCodesHelpOutput(c *check.C) {

 	testRequires(c, DaemonIsLinux)

 	// 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, _, err := dockerCmdWithError()
 	c.Assert(err, checker.IsNil, check.Commentf(out))

 	// 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, _, err = dockerCmdWithError("help")
 	c.Assert(err, checker.IsNil, check.Commentf(out))

 	// 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, _, err = dockerCmdWithError("--help")
 	c.Assert(err, checker.IsNil, check.Commentf(out))

 	// 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, _, err = dockerCmdWithError("inspect", "busybox")
 	c.Assert(err, checker.IsNil, check.Commentf(out))

 	// 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

 	cmd := exec.Command(dockerBinary, "rm")
 	stdout, stderr, _, err := runCommandWithStdoutStderr(cmd)
 	c.Assert(err, checker.NotNil)
 	c.Assert(stdout, checker.Equals, "")

 	// Should not contain full help text but should contain info about
 	// # of args and Usage line

 	c.Assert(stderr, checker.Contains, "requires a minimum", check.Commentf("Missing # of args text from 'docker rm'\n"))

 
 	// docker rm NoSuchContainer: stdout=empty, stderr=all, rc=0
 	// testing to make sure no blank line on error
 	cmd = exec.Command(dockerBinary, "rm", "NoSuchContainer")

 	stdout, stderr, _, err = runCommandWithStdoutStderr(cmd)
 	c.Assert(err, checker.NotNil)
 	c.Assert(len(stderr), checker.Not(checker.Equals), 0)
 	c.Assert(stdout, checker.Equals, "")

 	// Be really picky

 	c.Assert(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
 	cmd = exec.Command(dockerBinary, "BadCmd")

 	stdout, stderr, _, err = runCommandWithStdoutStderr(cmd)
 	c.Assert(err, checker.NotNil)
 	c.Assert(stdout, checker.Equals, "")
 	c.Assert(stderr, checker.Equals, "docker: 'BadCmd' is not a docker command.\nSee 'docker --help'.\n", check.Commentf("Unexcepted output for 'docker badCmd'\n"))

 }