environs/config: more restrictive New

provider/openstack/local_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package openstack_test
 
 import (
         "bytes"
         "fmt"
         "io/ioutil"
         "net/http"
@@ skipping 13 matching lines @@
         "launchpad.net/juju-core/environs/imagemetadata"
         "launchpad.net/juju-core/environs/jujutest"
         "launchpad.net/juju-core/environs/simplestreams"
         envtesting "launchpad.net/juju-core/environs/testing"
         "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/juju/testing"
         "launchpad.net/juju-core/provider"
         "launchpad.net/juju-core/provider/openstack"
         coretesting "launchpad.net/juju-core/testing"
+        jc "launchpad.net/juju-core/testing/checkers"
         "launchpad.net/juju-core/version"
 )
 
 type ProviderSuite struct {
         restoreTimeouts func()
 }
 
 var _ = gc.Suite(&ProviderSuite{})
 
 func (s *ProviderSuite) SetUpTest(c *gc.C) {
@@ skipping 425 matching lines @@
         inst1, _, err := provider.StartInstance(s.env, "1", "fake_nonce", series, constraints.Value{}, info, apiInfo)
         c.Assert(err, gc.IsNil)
 
         err = s.env.Destroy(append(insts, inst1))
         c.Assert(err, gc.IsNil)
 
         _, err = provider.LoadState(s.env.Storage())
         c.Assert(err, gc.NotNil)
 }
 
-func (s *localServerSuite) TestGetImageMetadataURLs(c *gc.C) {
-        urls, err := imagemetadata.GetMetadataURLs(s.env)
-        c.Assert(err, gc.IsNil)
-        c.Assert(len(urls), gc.Equals, 3)
+func (s *localServerSuite) TestGetImageMetadataSources(c *gc.C) {
+        sources, err := imagemetadata.GetMetadataSources(s.env)
+        c.Assert(err, gc.IsNil)
+        c.Assert(len(sources), gc.Equals, 4)
+        var urls = make([]string, len(sources))
+        for i, source := range sources {
+                url, err := source.URL("")
+                c.Assert(err, gc.IsNil)
+                urls[i] = url
+        }
+        // The control bucket URL contains the bucket name.
+        c.Check(strings.Contains(urls[0], openstack.ControlBucketName(s.env)), jc.IsTrue)
         // The public bucket URL ends with "/juju-dist/".
-        c.Check(strings.HasSuffix(urls[0], "/juju-dist/"), gc.Equals, true)
+        c.Check(strings.HasSuffix(urls[1], "/juju-dist/"), jc.IsTrue)
         // The product-streams URL ends with "/imagemetadata".
-        c.Check(strings.HasSuffix(urls[1], "/imagemetadata"), gc.Equals, true)
-        c.Assert(urls[2], gc.Equals, imagemetadata.DefaultBaseURL)
-}
-
-func (s *localServerSuite) TestGetToolsMetadataURLs(c *gc.C) {
-        urls, err := tools.GetMetadataURLs(s.env)
-        c.Assert(err, gc.IsNil)
-        c.Assert(len(urls), gc.Equals, 1)
-        _, err = url.Parse(urls[0])
+        c.Check(strings.HasSuffix(urls[2], "/imagemetadata/"), jc.IsTrue)
+        c.Assert(urls[3], gc.Equals, imagemetadata.DefaultBaseURL+"/")
+}
+
+func (s *localServerSuite) TestGetToolsMetadataSources(c *gc.C) {
+        sources, err := tools.GetMetadataSources(s.env)
+        c.Assert(err, gc.IsNil)
+        c.Assert(len(sources), gc.Equals, 2)
+        var urls = make([]string, len(sources))
+        for i, source := range sources {
+                url, err := source.URL("")
+                c.Assert(err, gc.IsNil)
+                urls[i] = url
+        }
+        // The control bucket URL contains the bucket name.
+        c.Check(strings.Contains(urls[0], openstack.ControlBucketName(s.env)+"/tools"), jc.IsTrue)
+        c.Assert(err, gc.IsNil)
+        // Check that the URL from keytone parses.
+        _, err = url.Parse(urls[1])
         c.Assert(err, gc.IsNil)
 }
 
 func (s *localServerSuite) TestFindImageSpecPublicStorage(c *gc.C) {
         spec, err := openstack.FindInstanceSpec(s.Env, "raring", "amd64", "mem=512M")
         c.Assert(err, gc.IsNil)
         c.Assert(spec.Image.Id, gc.Equals, "id-y")
         c.Assert(spec.InstanceType.Name, gc.Equals, "m1.tiny")
 }
 
 func (s *localServerSuite) TestFindImageBadDefaultImage(c *gc.C) {
         // An error occurs if no suitable image is found.
         _, err := openstack.FindInstanceSpec(s.Env, "saucy", "amd64", "mem=8G")
         c.Assert(err, gc.ErrorMatches, `no "saucy" images in some-region with arches \[amd64\]`)
 }
 
 func (s *localServerSuite) TestValidateImageMetadata(c *gc.C) {
         params, err := s.Env.(simplestreams.MetadataValidator).MetadataLookupParams("some-region")
         c.Assert(err, gc.IsNil)
-        params.BaseURLs, err = imagemetadata.GetMetadataURLs(s.Env)
+        params.Sources, err = imagemetadata.GetMetadataSources(s.Env)
         c.Assert(err, gc.IsNil)
         params.Series = "raring"
         image_ids, err := imagemetadata.ValidateImageMetadata(params)
         c.Assert(err, gc.IsNil)
         c.Assert(image_ids, gc.DeepEquals, []string{"id-y"})
 }
 
 func (s *localServerSuite) TestRemoveAll(c *gc.C) {
         storage := s.Env.Storage()
         for _, a := range []byte("abcdefghijklmnopqrstuvwxyz") {
@@ skipping 108 matching lines @@
         config["public-bucket-url"] = ""
         var err error
         s.env, err = environs.NewFromAttrs(config)
         c.Assert(err, gc.IsNil)
         url, err := s.env.PublicStorage().URL("")
         c.Assert(err, gc.IsNil)
         swiftURL, err := openstack.GetSwiftURL(s.env)
         c.Assert(err, gc.IsNil)
         c.Assert(url, gc.Equals, fmt.Sprintf("%s/juju-dist/", swiftURL))
 }