Usable, if incomplete, deploy command

cmd/juju/cmd_test.go

 package main
 
 import (
         "io/ioutil"
         "launchpad.net/gnuflag"
         . "launchpad.net/gocheck"
-        "launchpad.net/juju-core/juju/cmd"
-        "launchpad.net/juju-core/juju/environs"
-        "launchpad.net/juju-core/juju/environs/dummy"
-        "launchpad.net/juju-core/juju/testing"
+        "launchpad.net/juju-core/cmd"
+        "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/dummy"
+        "launchpad.net/juju-core/testing"
         "os"
         "path/filepath"
         "reflect"
 )
 
-type envFixture struct {

[niemeyer, 2012/06/25 23:19:22]

Let's please continue using the Suite suffix until we explicitly agree with
everyone to do otherwise in well defined cases and replace all instances
matching the well defined case at once. Otherwise we'll be sitting in the
middle, as that kind of change generally goes.

[fwereade, 2012/06/26 10:10:44]

Done.

+type envSuite struct {
         home string
 }
 
-func (f *envFixture) SetUp(c *C, config string) {
+func (f *envSuite) SetUpTest(c *C, config string) {
         // Arrange so that the "home" directory points
         // to a temporary directory containing the config file.
         f.home = os.Getenv("HOME")
         dir := c.MkDir()
         os.Setenv("HOME", dir)
         err := os.Mkdir(filepath.Join(dir, ".juju"), 0777)
         c.Assert(err, IsNil)
         err = ioutil.WriteFile(filepath.Join(dir, ".juju", "environments.yaml"), []byte(config), 0666)
         c.Assert(err, IsNil)
 }
 
-func (f *envFixture) TearDown(c *C) {
+func (f *envSuite) TearDownTest(c *C) {
         os.Setenv("HOME", f.home)
         dummy.Reset()
 }
 
 type cmdSuite struct {
         testing.LoggingSuite
-        envFixture
+        envSuite
 }
 
 var _ = Suite(&cmdSuite{})
 
 // N.B. Barking is broken.
 var config = `
 default:
     peckham
 environments:
     peckham:
         type: dummy
         zookeeper: false
     walthamstow:
         type: dummy
         zookeeper: false
     barking:
         type: dummy
         broken: true
         zookeeper: false
 `
 
 func (s *cmdSuite) SetUpTest(c *C) {
         s.LoggingSuite.SetUpTest(c)

[niemeyer, 2012/06/25 23:19:22]

And here is the proof. :-)

-        s.envFixture.SetUp(c, config)
+        s.envSuite.SetUpTest(c, config)
 }
 
 func (s *cmdSuite) TearDownTest(c *C) {
-        s.envFixture.TearDown(c)
+        s.envSuite.TearDownTest(c)
         s.LoggingSuite.TearDownTest(c)
 }
 
 func newFlagSet() *gnuflag.FlagSet {
         return gnuflag.NewFlagSet("", gnuflag.ContinueOnError)
 }
 
 // testInit checks that a command initialises correctly
 // with the given set of arguments.
 func testInit(c *C, com cmd.Command, args []string, errPat string) {
@@ skipping 63 matching lines @@
                         errc <- err
                         return
                 }
 
                 err = com.Run(cmd.DefaultContext())
                 errc <- err
         }()
         return
 }
 
-func op(kind dummy.OperationKind, name string) dummy.Operation {
-        return dummy.Operation{
-                Env:  name,
-                Kind: kind,
-        }
-}
-
 func (*cmdSuite) TestBootstrapCommand(c *C) {
         // normal bootstrap
         opc, errc := runCommand(new(BootstrapCommand))
-        c.Check(<-opc, Equals, op(dummy.OpBootstrap, "peckham"))
+        c.Check((<-opc).(dummy.OpBootstrap).Env, Equals, "peckham")
         c.Check(<-errc, IsNil)
 
         // bootstrap with tool uploading - checking that a file
         // is uploaded should be sufficient, as the detailed semantics
         // of UploadTools are tested in environs.
         opc, errc = runCommand(new(BootstrapCommand), "--upload-tools")
-        c.Check(<-opc, Equals, op(dummy.OpPutFile, "peckham"))
-        c.Check(<-opc, Equals, op(dummy.OpBootstrap, "peckham"))
+        c.Check((<-opc).(dummy.OpPutFile).Env, Equals, "peckham")
+        c.Check((<-opc).(dummy.OpBootstrap).Env, Equals, "peckham")
         c.Check(<-errc, IsNil)
 
         envs, err := environs.ReadEnvirons("")
         c.Assert(err, IsNil)
         env, err := envs.Open("peckham")
         c.Assert(err, IsNil)
         dir := c.MkDir()
         err = environs.GetTools(env, dir)
         c.Assert(err, IsNil)
 
         // bootstrap with broken environment
         opc, errc = runCommand(new(BootstrapCommand), "-e", "barking")
-        c.Check((<-opc).Kind, Equals, dummy.OpNone)
+        c.Check(<-opc, IsNil)
         c.Check(<-errc, ErrorMatches, `broken environment`)
 }
 
 func (*cmdSuite) TestDestroyCommand(c *C) {
         // normal destroy
         opc, errc := runCommand(new(DestroyCommand))
-        c.Check(<-opc, Equals, op(dummy.OpDestroy, "peckham"))
+        c.Check((<-opc).(dummy.OpDestroy).Env, Equals, "peckham")
         c.Check(<-errc, IsNil)
 
         // destroy with broken environment
         opc, errc = runCommand(new(DestroyCommand), "-e", "barking")
-        c.Check((<-opc).Kind, Equals, dummy.OpNone)
+        c.Check(<-opc, IsNil)
         c.Check(<-errc, ErrorMatches, `broken environment`)
 }
 
 var deployTests = []struct {
         args []string
         com  *DeployCommand
 }{
         {
                 []string{"charm-name"},
                 &DeployCommand{},
         }, {
                 []string{"charm-name", "service-name"},
                 &DeployCommand{ServiceName: "service-name"},
         }, {
                 []string{"--config", "/path/to/config.yaml", "charm-name"},
                 &DeployCommand{ConfPath: "/path/to/config.yaml"},
         }, {
                 []string{"--repository", "/path/to/another-repo", "charm-name"},
                 &DeployCommand{RepoPath: "/path/to/another-repo"},
         }, {
                 []string{"--upgrade", "charm-name"},
-                &DeployCommand{Upgrade: true},
+                &DeployCommand{BumpRevision: true},
         }, {
                 []string{"-u", "charm-name"},
-                &DeployCommand{Upgrade: true},
+                &DeployCommand{BumpRevision: true},
         }, {
                 []string{"--num-units", "33", "charm-name"},
                 &DeployCommand{NumUnits: 33},
         }, {
                 []string{"-n", "104", "charm-name"},
                 &DeployCommand{NumUnits: 104},
         },
 }
 
 func initExpectations(com *DeployCommand) {
@@ skipping 27 matching lines @@
         // missing args
         _, err := initDeployCommand()
         c.Assert(err, ErrorMatches, "no charm specified")
 
         // bad unit count
         _, err = initDeployCommand("charm-name", "--num-units", "0")
         c.Assert(err, ErrorMatches, "must deploy at least one unit")
 
         // environment tested elsewhere
 }