state: remove ProposedTools.

cmd/juju/cmd_test.go

 package main
 
 import (
         "launchpad.net/gnuflag"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/cmd"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/dummy"
         "launchpad.net/juju-core/juju/testing"
         "launchpad.net/juju-core/version"
         "net/http"
         "os"
         "reflect"
+        "time"
 )
 
 type CmdSuite struct {
         testing.JujuConnSuite
 }
 
 var _ = Suite(&CmdSuite{})
 
 var config = `
 default:
@@ skipping 74 matching lines @@
                 testInit(c, com, append(args, "--environment", "walthamstow"), "")
                 assertConnName(c, com, "walthamstow")
 
                 com, args = cmdFunc()
                 testInit(c, com, append(args, "hotdog"), "unrecognized args.*")
         }
 }
 
 func runCommand(com cmd.Command, args ...string) (opc chan dummy.Operation, errc chan error) {
         errc = make(chan error, 1)
-        opc = make(chan dummy.Operation)
+        opc = make(chan dummy.Operation, 20)
         dummy.Reset()
         dummy.Listen(opc)
         go func() {
                 // signal that we're done with this ops channel.
                 defer dummy.Listen(nil)
 
                 err := com.Init(newFlagSet(), args)
                 if err != nil {
                         errc <- err
                         return
                 }
 
                 err = com.Run(cmd.DefaultContext())
                 errc <- err
         }()
         return
 }
 
 func (*CmdSuite) TestBootstrapCommand(c *C) {
         // normal bootstrap
         opc, errc := runCommand(new(BootstrapCommand))
+        c.Check(<-errc, IsNil)
         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.
+        time.Sleep(500 * time.Millisecond)
         opc, errc = runCommand(new(BootstrapCommand), "--upload-tools")
+        c.Check(<-errc, IsNil)
         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)
 
         oldVarDir := environs.VarDir
         defer func() {
                 environs.VarDir = oldVarDir
         }()
         environs.VarDir = c.MkDir()
 
         tools, err := environs.FindTools(env, version.Current, environs.CompatVersion)
         c.Assert(err, IsNil)
         resp, err := http.Get(tools.URL)
         c.Assert(err, IsNil)
         defer resp.Body.Close()
 
         err = environs.UnpackTools(tools, resp.Body)
         c.Assert(err, IsNil)
 
         // bootstrap with broken environment
         opc, errc = runCommand(new(BootstrapCommand), "-e", "brokenenv")
+        c.Check(<-errc, ErrorMatches, "dummy.Bootstrap is broken")
         c.Check(<-opc, IsNil)
-        c.Check(<-errc, ErrorMatches, "dummy.Bootstrap is broken")
 }
 
 func (*CmdSuite) TestDestroyCommand(c *C) {
         // normal destroy
         opc, errc := runCommand(new(DestroyCommand))
+        c.Check(<-errc, IsNil)
         c.Check((<-opc).(dummy.OpDestroy).Env, Equals, "peckham")
-        c.Check(<-errc, IsNil)
 
         // destroy with broken environment
         opc, errc = runCommand(new(DestroyCommand), "-e", "brokenenv")
+        c.Check(<-errc, ErrorMatches, "dummy.Destroy is broken")
         c.Check(<-opc, IsNil)
-        c.Check(<-errc, ErrorMatches, "dummy.Destroy is broken")
 }
 
 var deployTests = []struct {
         args []string
         com  *DeployCommand
 }{
         {
                 []string{"charm-name"},
                 &DeployCommand{},
         }, {
@@ skipping 98 matching lines @@
         return com, com.Init(newFlagSet(), args)
 }
 
 func (*CmdSuite) TestUnexposeCommandInit(c *C) {
         // missing args
         _, err := initUnexposeCommand()
         c.Assert(err, ErrorMatches, "no service name specified")
 
         // environment tested elsewhere
 }