Fix tools metadata generation for null provider

environs/tools/simplestreams_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package tools_test
 
 import (
         "flag"
         "fmt"
         "io"
-        "path/filepath"
         "reflect"
         "testing"
 
         "launchpad.net/goamz/aws"
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/environs/filestorage"
         "launchpad.net/juju-core/environs/simplestreams"
         sstesting "launchpad.net/juju-core/environs/simplestreams/testing"
         "launchpad.net/juju-core/environs/storage"
@@ skipping 253 matching lines @@
                 FileType: "tar.gz",
                 SHA256:   "447aeb6a934a5eaec4f703eda4ef2dde",
         }
         c.Assert(err, gc.IsNil)
         c.Assert(toolsMetadata[0], gc.DeepEquals, expectedMetadata)
 }
 
 func assertMetadataMatches(c *gc.C, storageDir string, toolList coretools.List, metadata []*tools.ToolsMetadata) {
         var expectedMetadata []*tools.ToolsMetadata = make([]*tools.ToolsMetadata, len(toolList))
         for i, tool := range toolList {
-                if tool.Size == 0 {
-                        path := filepath.Join(storageDir, tools.StorageName(tool.Version))
-                        size, sha256 := ttesting.SHA256sum(c, path)
-                        tool.SHA256 = sha256
-                        tool.Size = size
-                }
                 expectedMetadata[i] = &tools.ToolsMetadata{
                         Release:  tool.Version.Series,
                         Version:  tool.Version.Number.String(),
                         Arch:     tool.Version.Arch,
                         Size:     tool.Size,
                         Path:     fmt.Sprintf("releases/juju-%s.tgz", tool.Version.String()),
                         FileType: "tar.gz",
                         SHA256:   tool.SHA256,
                 }
         }
         c.Assert(metadata, gc.DeepEquals, expectedMetadata)
 }
 
 func (s *simplestreamsSuite) TestWriteMetadataNoFetch(c *gc.C) {
         toolsList := coretools.List{
                 {
                         Version: version.MustParseBinary("1.2.3-precise-amd64"),
                         Size:    123,
                         SHA256:  "abcd",
                 }, {
                         Version: version.MustParseBinary("2.0.1-raring-amd64"),
                         Size:    456,
                         SHA256:  "xyz",
                 },
         }
         dir := c.MkDir()
         writer, err := filestorage.NewFileStorageWriter(dir, filestorage.UseDefaultTmpDir)
         c.Assert(err, gc.IsNil)
-        err = tools.MergeAndWriteMetadata(writer, toolsList, tools.DontResolve)
+        err = tools.MergeAndWriteMetadata(writer, toolsList)
         c.Assert(err, gc.IsNil)
         metadata := ttesting.ParseMetadata(c, dir)
         assertMetadataMatches(c, dir, toolsList, metadata)
 }
 
 func (s *simplestreamsSuite) TestWriteMetadata(c *gc.C) {
         var versionStrings = []string{
                 "1.2.3-precise-amd64",
                 "2.0.1-raring-amd64",
         }
         dir := c.MkDir()
         ttesting.MakeTools(c, dir, "releases", versionStrings)
 
         toolsList := coretools.List{
                 {
                         // If sha256/size is already known, do not recalculate
                         Version: version.MustParseBinary("1.2.3-precise-amd64"),
                         Size:    123,
                         SHA256:  "abcd",
                 }, {
                         Version: version.MustParseBinary("2.0.1-raring-amd64"),
                         // The URL is not used for generating metadata.
                         URL: "bogus://",
                 },
         }
         writer, err := filestorage.NewFileStorageWriter(dir, filestorage.UseDefaultTmpDir)
         c.Assert(err, gc.IsNil)
-        err = tools.MergeAndWriteMetadata(writer, toolsList, tools.Resolve)
+        err = tools.MergeAndWriteMetadata(writer, toolsList)
         c.Assert(err, gc.IsNil)
         metadata := ttesting.ParseMetadata(c, dir)
         assertMetadataMatches(c, dir, toolsList, metadata)
 }
 
 func (s *simplestreamsSuite) TestWriteMetadataMergeWithExisting(c *gc.C) {
         dir := c.MkDir()
         existingToolsList := coretools.List{
                 {
                         Version: version.MustParseBinary("1.2.3-precise-amd64"),
                         Size:    123,
                         SHA256:  "abc",
                 }, {
                         Version: version.MustParseBinary("2.0.1-raring-amd64"),
                         Size:    456,
                         SHA256:  "xyz",
                 },
         }
         writer, err := filestorage.NewFileStorageWriter(dir, filestorage.UseDefaultTmpDir)
         c.Assert(err, gc.IsNil)
-        err = tools.MergeAndWriteMetadata(writer, existingToolsList, tools.Resolve)
+        err = tools.MergeAndWriteMetadata(writer, existingToolsList)
         c.Assert(err, gc.IsNil)
         newToolsList := coretools.List{
                 existingToolsList[0],
                 {
                         Version: version.MustParseBinary("2.1.0-raring-amd64"),
                         Size:    789,
                         SHA256:  "def",
                 },
         }
-        err = tools.MergeAndWriteMetadata(writer, newToolsList, tools.Resolve)
+        err = tools.MergeAndWriteMetadata(writer, newToolsList)
         c.Assert(err, gc.IsNil)
         requiredToolsList := append(existingToolsList, newToolsList[1])
         metadata := ttesting.ParseMetadata(c, dir)
         assertMetadataMatches(c, dir, requiredToolsList, metadata)
 }
 
 type productSpecSuite struct{}
 
 var _ = gc.Suite(&productSpecSuite{})
 
@@ skipping 188 matching lines @@
                 Version: "1.2.3",
                 Arch:    "amd64",
                 Path:    "path3",
         }
 
         withSize := func(md *tools.ToolsMetadata, size int64) *tools.ToolsMetadata {
                 clone := *md
                 clone.Size = size
                 return &clone
         }
+        withSHA256 := func(md *tools.ToolsMetadata, sha256 string) *tools.ToolsMetadata {
+                clone := *md
+                clone.SHA256 = sha256
+                return &clone
+        }
 
         type mdlist []*tools.ToolsMetadata
         type test struct {
                 name             string
                 lhs, rhs, merged []*tools.ToolsMetadata
+                err              string
         }
         tests := []test{{
                 name:   "non-empty lhs, empty rhs",
                 lhs:    mdlist{md1},
                 rhs:    nil,
                 merged: mdlist{md1},
         }, {
                 name:   "empty lhs, non-empty rhs",
                 lhs:    nil,
                 rhs:    mdlist{md2},
@@ skipping 12 matching lines @@
                 name:   "same tools in lhs and rhs, only lhs has a size: prefer lhs",
                 lhs:    mdlist{withSize(md1, 123)},
                 rhs:    mdlist{md2},
                 merged: mdlist{withSize(md1, 123)},
         }, {
                 name:   "same tools in lhs and rhs, only rhs has a size: prefer rhs",
                 lhs:    mdlist{md1},
                 rhs:    mdlist{withSize(md2, 123)},
                 merged: mdlist{withSize(md2, 123)},
         }, {
-                name:   "same tools in lhs and rhs, both have a size: prefer lhs",
+                name:   "same tools in lhs and rhs, both have the same size: prefer lhs",
                 lhs:    mdlist{withSize(md1, 123)},
-                rhs:    mdlist{withSize(md2, 456)},
+                rhs:    mdlist{withSize(md2, 123)},
                 merged: mdlist{withSize(md1, 123)},
+        }, {
+                name: "same tools in lhs and rhs, both have different sizes: error",
+                lhs:  mdlist{withSize(md1, 123)},
+                rhs:  mdlist{withSize(md2, 456)},
+                err:  "metadata mismatch for 1\\.2\\.3-precise-amd64: sizes=\\(123,456\\) sha256=\\(,\\)",
+        }, {
+                name: "same tools in lhs and rhs, both have same size but different sha256: error",
+                lhs:  mdlist{withSHA256(withSize(md1, 123), "a")},
+                rhs:  mdlist{withSHA256(withSize(md2, 123), "b")},
+                err:  "metadata mismatch for 1\\.2\\.3-precise-amd64: sizes=\\(123,123\\) sha256=\\(a,b\\)",
         }, {
                 name:   "lhs is a proper superset of rhs: union of lhs and rhs",
                 lhs:    mdlist{md1, md3},
                 rhs:    mdlist{md1},
                 merged: mdlist{md1, md3},
         }, {
                 name:   "rhs is a proper superset of lhs: union of lhs and rhs",
                 lhs:    mdlist{md1},
                 rhs:    mdlist{md1, md3},
                 merged: mdlist{md1, md3},
         }}
         for i, test := range tests {
                 c.Logf("test %d: %s", i, test.name)
-                merged := tools.MergeMetadata(test.lhs, test.rhs)
-                c.Assert(merged, gc.DeepEquals, test.merged)

[rog, 2013/10/09 16:29:42]

Thanks - I find this much easier to follow (and it's easier to change if we
decide to change the semantics of MergeMetadata)

+                merged, err := tools.MergeMetadata(test.lhs, test.rhs)
+                if test.err == "" {
+                        c.Assert(err, gc.IsNil)
+                        c.Assert(merged, gc.DeepEquals, test.merged)
+                } else {
+                        c.Assert(err, gc.ErrorMatches, test.err)
+                        c.Assert(merged, gc.IsNil)
+                }
         }
 }
 
 func (*metadataHelperSuite) TestReadWriteMetadata(c *gc.C) {
         metadata := []*tools.ToolsMetadata{{
                 Release: "precise",
                 Version: "1.2.3",
                 Arch:    "amd64",
                 Path:    "path1",
         }, {
@@ skipping 11 matching lines @@
         err = tools.WriteMetadata(stor, metadata)
         c.Assert(err, gc.IsNil)
         out, err = tools.ReadMetadata(stor)
         for _, md := range out {
                 // FullPath is set by ReadMetadata.
                 c.Assert(md.FullPath, gc.Not(gc.Equals), "")
                 md.FullPath = ""
         }
         c.Assert(out, gc.DeepEquals, metadata)
 }