cmd/juju: working bootstrap and destroy commands

cmd/juju/main_test.go

 package main_test
 
 import (
         "flag"
         "fmt"
         "io/ioutil"
         . "launchpad.net/gocheck"
         main "launchpad.net/juju/go/cmd/juju"
         "os"
         "os/exec"
@@ skipping 16 matching lines @@
 func TestRunMain(t *testing.T) {
         if *flagRunMain {
                 main.Main(flag.Args())
         }
 }
 
 func badrun(c *C, exit int, cmd ...string) []string {
         args := append([]string{"-test.run", "TestRunMain", "-run-main", "--", "juju"}, cmd...)
         ps := exec.Command(os.Args[0], args...)
         output, err := ps.CombinedOutput()
-        c.Assert(err, ErrorMatches, fmt.Sprintf("exit status %d", exit))
+        if exit != 0 {
+                c.Assert(err, ErrorMatches, fmt.Sprintf("exit status %d", exit))
+        }
         return strings.Split(string(output), "\n")
+}
+
+func assertError(c *C, lines []string, err string) {
+        c.Assert(lines[len(lines)-2], Equals, err)
+        c.Assert(lines[len(lines)-1], Equals, "")
 }
 
 func (s *MainSuite) TestActualRunNoCommand(c *C) {
         // Check error when command not specified
         lines := badrun(c, 2)
-        c.Assert(lines[0], Equals, "no command specified")
-        c.Assert(lines[1], Equals, "usage: juju <command> [options] ...")
+        c.Assert(lines[0], Equals, "usage: juju [options] <command> ...")
+        assertError(c, lines, "error: no command specified")
 }
 
 func (s *MainSuite) TestActualRunBadCommand(c *C) {
         // Check error when command unknown
         lines := badrun(c, 2, "discombobulate")
-        c.Assert(lines[0], Equals, "unrecognised command: juju discombobulate")
-        c.Assert(lines[1], Equals, "usage: juju <command> [options] ...")
+        c.Assert(lines[0], Equals, "usage: juju [options] <command> ...")
+        assertError(c, lines, "error: unrecognised command: juju discombobulate")
 }
 
 func (s *MainSuite) TestActualRunBadJujuArg(c *C) {
         // Check error when unknown option specified before command
         lines := badrun(c, 2, "--cheese", "bootstrap")
-        c.Assert(lines[0], Equals, "flag provided but not defined: --cheese")
-        c.Assert(lines[1], Equals, "usage: juju <command> [options] ...")
+        c.Assert(lines[0], Equals, "usage: juju [options] <command> ...")
+        assertError(c, lines, "error: flag provided but not defined: --cheese")
 }
 
 func (s *MainSuite) TestActualRunBadBootstrapArg(c *C) {
         // Check error when unknown option specified after command
         lines := badrun(c, 2, "bootstrap", "--cheese")
-        c.Assert(lines[0], Equals, "flag provided but not defined: --cheese")
-        c.Assert(lines[1], Equals, "usage: juju bootstrap [options]")
+        c.Assert(lines[0], Equals, "usage: juju bootstrap [options]")
+        assertError(c, lines, "error: flag provided but not defined: --cheese")
 }
 
 func (s *MainSuite) TestActualRunSubcmdArgWorksNotInterspersed(c *C) {
         // Check error when otherwise-valid option specified before command
         lines := badrun(c, 2, "--environment", "erewhon", "bootstrap")
-        c.Assert(lines[0], Equals, "flag provided but not defined: --environment")
-        c.Assert(lines[1], Equals, "usage: juju <command> [options] ...")
+        c.Assert(lines[0], Equals, "usage: juju [options] <command> ...")
+        assertError(c, lines, "error: flag provided but not defined: --environment")
 }
 
 var brokenConfig = `
 environments:
     one:
         type: dummy
         zookeeper: false
         broken: true
 `
 
@@ skipping 13 matching lines @@
         msg := "broken environment"
         return msg, func() { os.Setenv("HOME", home) }
 }
 
 func (s *MainSuite) TestActualRunJujuArgsBeforeCommand(c *C) {
         // Check global args work when specified before command
         msg, unbreak := breakJuju(c)
         defer unbreak()
         logpath := filepath.Join(c.MkDir(), "log")
         lines := badrun(c, 1, "--log-file", logpath, "--verbose", "--debug", "bootstrap")
-        c.Assert(lines[0], Equals, msg)
+        assertError(c, lines, "error: "+msg)
         content, err := ioutil.ReadFile(logpath)
         c.Assert(err, IsNil)
         fullmsg := fmt.Sprintf(`.* JUJU:DEBUG juju bootstrap command failed: %s\n`, msg)
         c.Assert(string(content), Matches, fullmsg)
 }
 
 func (s *MainSuite) TestActualRunJujuArgsAfterCommand(c *C) {
         // Check global args work when specified after command
         msg, unbreak := breakJuju(c)
         defer unbreak()
         logpath := filepath.Join(c.MkDir(), "log")
         lines := badrun(c, 1, "bootstrap", "--log-file", logpath, "--verbose", "--debug")
-        c.Assert(lines[0], Equals, msg)
+        assertError(c, lines, "error: "+msg)
         content, err := ioutil.ReadFile(logpath)
         c.Assert(err, IsNil)
         fullmsg := fmt.Sprintf(`.* JUJU:DEBUG juju bootstrap command failed: %s\n`, msg)
         c.Assert(string(content), Matches, fullmsg)
 }
 
 var commandNames = []string{
         "bootstrap",
         "destroy-environment",
 }
 
 func (s *MainSuite) TestHelp(c *C) {
         // Check that we have correctly registered all the commands
         // by checking the help output.
 
-        lines := badrun(c, 2, "-help")
-        c.Assert(lines[0], Matches, "flag: help requested.*")
+        lines := badrun(c, 0, "-help")
+        c.Assert(lines[0], Matches, `usage: juju .*`)
 
         for ; len(lines) > 0; lines = lines[1:] {
                 if lines[0] == "commands:" {
                         break
                 }
         }
         c.Assert(lines, Not(HasLen), 0)
 
         var names []string
         for lines = lines[1:]; len(lines) > 0; lines = lines[1:] {
                 f := strings.Fields(lines[0])
                 if len(f) == 0 {
                         continue
                 }
                 c.Assert(f, Not(HasLen), 0)
                 names = append(names, f[0])
         }
         sort.Strings(names)
         c.Assert(names, DeepEquals, commandNames)
 }