Update and Validate Environ Config in State

cmd/juju/upgradejuju_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package main
 
 import (
         "archive/tar"
         "bytes"
         "compress/gzip"
         "io"
         "io/ioutil"
         "strings"
 
+        jc "github.com/juju/testing/checkers"
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/environs/filestorage"
         "launchpad.net/juju-core/environs/storage"
         "launchpad.net/juju-core/environs/sync"
         envtesting "launchpad.net/juju-core/environs/testing"
         envtools "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/juju/testing"
         coretesting "launchpad.net/juju-core/testing"
-        jc "launchpad.net/juju-core/testing/checkers"
-        coretools "launchpad.net/juju-core/tools"
         "launchpad.net/juju-core/version"
 )
 
 type UpgradeJujuSuite struct {
         testing.JujuConnSuite
+        toolsDir string
 }
 
 var _ = gc.Suite(&UpgradeJujuSuite{})
 
 var upgradeJujuTests = []struct {
         about          string
         tools          []string
         currentVersion string
         agentVersion   string
 
@@ skipping 118 matching lines @@
         about:          "specified version missing, but already set",
         currentVersion: "3.0.0-quantal-amd64",
         agentVersion:   "3.0.0",
         args:           []string{"--version", "3.0.0"},
         expectVersion:  "3.0.0",
 }, {
         about:          "specified version, no tools",
         currentVersion: "3.0.0-quantal-amd64",
         agentVersion:   "3.0.0",
         args:           []string{"--version", "3.2.0"},
-        expectErr:      "no matching tools available",
+        expectErr:      "no tools available",
 }, {
         about:          "specified version, no matching major version",
         tools:          []string{"4.2.0-quantal-amd64"},
         currentVersion: "3.0.0-quantal-amd64",
         agentVersion:   "3.0.0",
         args:           []string{"--version", "3.2.0"},
         expectErr:      "no matching tools available",
 }, {
         about:          "specified version, no matching minor version",
         tools:          []string{"3.4.0-quantal-amd64"},
@@ skipping 87 matching lines @@
 }, {
         about:          "upload with explicit version bumps when necessary",
         currentVersion: "2.2.0-quantal-amd64",
         tools:          []string{"2.7.3.1-quantal-amd64"},
         agentVersion:   "2.0.0",
         args:           []string{"--upload-tools", "--version", "2.7.3"},
         expectVersion:  "2.7.3.2",
         expectUploaded: []string{"2.7.3.2-quantal-amd64", "2.7.3.2-precise-amd64", "2.7.3.2-raring-amd64"},
 }}
 
-// mockUploadTools simulates the effect of tools.Upload, but skips the time-
-// consuming build from source.
-// TODO(fwereade) better factor agent/tools such that build logic is
-// exposed and can itself be neatly mocked?
-func mockUploadTools(stor storage.Storage, forceVersion *version.Number, series ...string) (*coretools.Tools, error) {
-        vers := version.Current
-        if forceVersion != nil {
-                vers.Number = *forceVersion
+// getMockBuildTools returns a sync.BuildToolsTarballFunc implementation which generates
+// a fake tools tarball.
+func (s *UpgradeJujuSuite) getMockBuildTools(c *gc.C) sync.BuildToolsTarballFunc {
+        return func(forceVersion *version.Number) (*sync.BuiltTools, error) {
+                // UploadFakeToolsVersions requires a storage to write to.
+                stor, err := filestorage.NewFileStorageWriter(s.toolsDir)
+                c.Assert(err, gc.IsNil)
+                vers := version.Current
+                if forceVersion != nil {
+                        vers.Number = *forceVersion
+                }
+                versions := []version.Binary{vers}
+                uploadedTools, err := envtesting.UploadFakeToolsVersions(stor, versions...)
+                c.Assert(err, gc.IsNil)
+                agentTools := uploadedTools[0]
+                return &sync.BuiltTools{
+                        Dir:         s.toolsDir,
+                        StorageName: envtools.StorageName(vers),
+                        Version:     vers,
+                        Size:        agentTools.Size,
+                        Sha256Hash:  agentTools.SHA256,
+                }, nil
         }
-        versions := []version.Binary{vers}
-        for _, series := range series {
-                if series != version.Current.Series {
-                        newVers := vers
-                        newVers.Series = series
-                        versions = append(versions, newVers)
-                }
-        }
-        agentTools, err := envtesting.UploadFakeToolsVersions(stor, versions...)
-        if err != nil {
-                return nil, err
-        }
-        return agentTools[0], nil
 }
 
 func (s *UpgradeJujuSuite) TestUpgradeJuju(c *gc.C) {
-        s.PatchValue(&sync.Upload, mockUploadTools)
+        s.PatchValue(&sync.BuildToolsTarball, s.getMockBuildTools(c))
         oldVersion := version.Current
         defer func() {
                 version.Current = oldVersion
         }()
 
         for i, test := range upgradeJujuTests {
                 c.Logf("\ntest %d: %s", i, test.about)
                 s.Reset(c)
 
                 // Set up apparent CLI version and initialize the command.
                 version.Current = version.MustParseBinary(test.currentVersion)
                 com := &UpgradeJujuCommand{}
                 if err := coretesting.InitCommand(com, test.args); err != nil {
                         if test.expectInitErr != "" {
                                 c.Check(err, gc.ErrorMatches, test.expectInitErr)
                         } else {
                                 c.Check(err, gc.IsNil)
                         }
                         continue
                 }
 
                 // Set up state and environ, and run the command.
                 toolsDir := c.MkDir()
                 updateAttrs := map[string]interface{}{
                         "agent-version":      test.agentVersion,
                         "tools-metadata-url": "file://" + toolsDir,
                 }
-                err := s.State.UpdateEnvironConfig(updateAttrs, []string{})
+                err := s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
                 c.Assert(err, gc.IsNil)
                 versions := make([]version.Binary, len(test.tools))
                 for i, v := range test.tools {
                         versions[i] = version.MustParseBinary(v)
                 }
-                envtesting.MustUploadFakeToolsVersions(s.Conn.Environ.Storage(), versions...)
-                stor, err := filestorage.NewFileStorageWriter(toolsDir)
-                c.Assert(err, gc.IsNil)
-                envtesting.MustUploadFakeToolsVersions(stor, versions...)
+                if len(versions) > 0 {
+                        envtesting.MustUploadFakeToolsVersions(s.Conn.Environ.Storage(), versions...)
+                        stor, err := filestorage.NewFileStorageWriter(toolsDir)
+                        c.Assert(err, gc.IsNil)
+                        envtesting.MustUploadFakeToolsVersions(stor, versions...)
+                }
+
                 err = com.Run(coretesting.Context(c))
                 if test.expectErr != "" {
                         c.Check(err, gc.ErrorMatches, test.expectErr)
                         continue
                 } else if !c.Check(err, gc.IsNil) {
                         continue
                 }
 
                 // Check expected changes to environ/state.
                 cfg, err := s.State.EnvironConfig()
                 c.Check(err, gc.IsNil)
                 agentVersion, ok := cfg.AgentVersion()
                 c.Check(ok, gc.Equals, true)
                 c.Check(agentVersion, gc.Equals, version.MustParse(test.expectVersion))
 
                 for _, uploaded := range test.expectUploaded {
                         vers := version.MustParseBinary(uploaded)
                         r, err := storage.Get(s.Conn.Environ.Storage(), envtools.StorageName(vers))
                         if !c.Check(err, gc.IsNil) {
                                 continue
                         }
                         data, err := ioutil.ReadAll(r)
                         r.Close()
                         c.Check(err, gc.IsNil)
-                        checkToolsContent(c, data, "jujud contents "+uploaded)
+                        expectContent := version.Current
+                        expectContent.Number = agentVersion
+                        checkToolsContent(c, data, "jujud contents "+expectContent.String())
                 }
         }
 }
 
 func checkToolsContent(c *gc.C, data []byte, uploaded string) {
         zr, err := gzip.NewReader(bytes.NewReader(data))
         c.Check(err, gc.IsNil)
         defer zr.Close()
         tr := tar.NewReader(zr)
         found := false
@@ skipping 21 matching lines @@
 // tools to the environment's storage. We don't want
 // 'em there; but we do want a consistent default-series
 // in the environment state.
 func (s *UpgradeJujuSuite) Reset(c *gc.C) {
         s.JujuConnSuite.Reset(c)
         envtesting.RemoveTools(c, s.Conn.Environ.Storage())
         updateAttrs := map[string]interface{}{
                 "default-series": "raring",
                 "agent-version":  "1.2.3",
         }
-        err := s.State.UpdateEnvironConfig(updateAttrs, []string{})
+        err := s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
         c.Assert(err, gc.IsNil)
+        s.toolsDir = c.MkDir()
 }
 
 func (s *UpgradeJujuSuite) TestUpgradeJujuWithRealUpload(c *gc.C) {
         s.Reset(c)
         _, err := coretesting.RunCommand(c, &UpgradeJujuCommand{}, []string{"--upload-tools"})
         c.Assert(err, gc.IsNil)
         vers := version.Current
         vers.Build = 1
         tools, err := envtools.FindInstanceTools(s.Conn.Environ, vers.Number, vers.Series, &vers.Arch)
         c.Assert(err, gc.IsNil)
         c.Assert(len(tools), gc.Equals, 1)
 }