Fix tools metadata generation for null provider

environs/testing/tools.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package testing
 
 import (
         "bytes"
         "os"
         "path"
         "path/filepath"
@@ skipping 94 matching lines @@
         }
         url, err := stor.URL(name)
         if err != nil {
                 return nil, err
         }
         return &coretools.Tools{URL: url, Version: vers, Size: size, SHA256: checksum}, nil
 }
 
 // UploadFakeToolsVersions puts fake tools in the supplied storage for the supplied versions.
 func UploadFakeToolsVersions(stor storage.Storage, versions ...version.Binary) ([]*coretools.Tools, error) {
+        // Leave existing tools alone.
+        existingTools := make(map[version.Binary]*coretools.Tools)
+        existing, _ := envtools.ReadList(stor, 1, -1)
+        for _, tools := range existing {
+                existingTools[tools.Version] = tools
+        }
         var agentTools coretools.List = make(coretools.List, len(versions))
         for i, version := range versions {
-                t, err := uploadFakeToolsVersion(stor, version)
-                if err != nil {
-                        return nil, err
+                if tools, ok := existingTools[version]; ok {
+                        agentTools[i] = tools
+                } else {
+                        t, err := uploadFakeToolsVersion(stor, version)
+                        if err != nil {
+                                return nil, err
+                        }
+                        agentTools[i] = t
                 }
-                agentTools[i] = t
-        }
-        err := envtools.MergeAndWriteMetadata(stor, agentTools, envtools.Resolve)
-        if err != nil {
+        }
+        if err := envtools.MergeAndWriteMetadata(stor, agentTools); err != nil {
                 return nil, err
         }
         return agentTools, nil
 }
 
 // AssertUploadFakeToolsVersions puts fake tools in the supplied storage for the supplied versions.
 func AssertUploadFakeToolsVersions(c *gc.C, stor storage.Storage, versions ...version.Binary) []*coretools.Tools {
         agentTools, err := UploadFakeToolsVersions(stor, versions...)
         c.Assert(err, gc.IsNil)
         return agentTools
 }
 
 // MustUploadFakeToolsVersions acts as UploadFakeToolsVersions, but panics on failure.
 func MustUploadFakeToolsVersions(stor storage.Storage, versions ...version.Binary) []*coretools.Tools {
         var agentTools coretools.List = make(coretools.List, len(versions))
         for i, version := range versions {
                 t, err := uploadFakeToolsVersion(stor, version)
                 if err != nil {
                         panic(err)
                 }
                 agentTools[i] = t
         }
-        err := envtools.MergeAndWriteMetadata(stor, agentTools, envtools.Resolve)
+        err := envtools.MergeAndWriteMetadata(stor, agentTools)
         if err != nil {
                 panic(err)
         }
         return agentTools
 }
 
 func uploadFakeTools(stor storage.Storage) error {
         versions := []version.Binary{version.Current}
         toolsVersion := version.Current
         if toolsVersion.Series != config.DefaultSeries {
@@ skipping 17 matching lines @@
 
 // MustUploadFakeTools acts as UploadFakeTools, but panics on failure.
 func MustUploadFakeTools(stor storage.Storage) {
         if err := uploadFakeTools(stor); err != nil {
                 panic(err)
         }
 }
 
 // RemoveFakeTools deletes the fake tools from the supplied storage.
 func RemoveFakeTools(c *gc.C, stor storage.Storage) {
+        c.Logf("removing fake tools")
         toolsVersion := version.Current
         name := envtools.StorageName(toolsVersion)
         err := stor.Remove(name)
         c.Check(err, gc.IsNil)
         if version.Current.Series != config.DefaultSeries {
                 toolsVersion.Series = config.DefaultSeries
                 name := envtools.StorageName(toolsVersion)
                 err := stor.Remove(name)
                 c.Check(err, gc.IsNil)
         }
@@ skipping 241 matching lines @@
 func SetSSLHostnameVerification(c *gc.C, st *state.State, SSLHostnameVerification bool) {
         envConfig, err := st.EnvironConfig()
         c.Assert(err, gc.IsNil)
         attrs := envConfig.AllAttrs()
         attrs["ssl-hostname-verification"] = SSLHostnameVerification
         newConfig, err := config.New(config.NoDefaults, attrs)
         c.Assert(err, gc.IsNil)
         err = st.SetEnvironConfig(newConfig)
         c.Assert(err, gc.IsNil)
 }