environs: add Environs.Config method

provider/ec2/config_test.go

 // Copyright 2011, 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package ec2
 
 // TODO: Clean this up so it matches environs/openstack/config_test.go.
 
 import (
         "io/ioutil"
         "os"
         "path/filepath"
         "strings"
 
         "launchpad.net/goamz/aws"
         gc "launchpad.net/gocheck"
-        "launchpad.net/goyaml"
 
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/juju/osenv"
         "launchpad.net/juju-core/testing"
 )
 
 // Use local suite since this file lives in the ec2 package
 // for testing internals.
 type ConfigSuite struct {
         testing.LoggingSuite
         savedHome, savedAccessKey, savedSecretKey string
 }
 
 var _ = gc.Suite(&ConfigSuite{})
 
 var configTestRegion = aws.Region{
         Name:        "configtest",
         EC2Endpoint: "testregion.nowhere:1234",
 }
 
 var testAuth = aws.Auth{"gopher", "long teeth"}
 
 // configTest specifies a config parsing test, checking that env when
 // parsed as the ec2 section of a config file matches baseConfigResult
 // when mutated by the mutate function, or that the parse matches the
 // given error.
 type configTest struct {
-        config        attrs
-        change        attrs
-        expect        attrs
+        config        map[string]interface{}
+        change        map[string]interface{}
+        expect        map[string]interface{}
         region        string
         cbucket       string
         pbucket       string
         pbucketRegion string
         accessKey     string
         secretKey     string
         firewallMode  string
         err           string
 }
 
 type attrs map[string]interface{}
 
 func (t configTest) check(c *gc.C) {
-        envs := attrs{
-                "environments": attrs{
-                        "testenv": attrs{
-                                "type":           "ec2",
-                                "ca-cert":        testing.CACert,
-                                "ca-private-key": testing.CAKey,
-                        },
-                },
-        }
-        testenv := envs["environments"].(attrs)["testenv"].(attrs)
-        for k, v := range t.config {
-                testenv[k] = v
-        }
-        if _, ok := testenv["control-bucket"]; !ok {
-                testenv["control-bucket"] = "x"
-        }
-        data, err := goyaml.Marshal(envs)
+        attrs := testing.FakeConfig().Merge(testing.Attrs{
+                "type":           "ec2",
+                "control-bucket": "x",
+        }).Merge(t.config)
+        cfg, err := config.New(config.NoDefaults, attrs)
         c.Assert(err, gc.IsNil)
-
-        es, err := environs.ReadEnvironsBytes(data)
-        c.Check(err, gc.IsNil)
-
-        e, err := es.Open("testenv")
+        e, err := environs.New(cfg)
         if t.change != nil {
                 c.Assert(err, gc.IsNil)
 
                 // Testing a change in configuration.
                 var old, changed, valid *config.Config
                 ec2env := e.(*environ)
                 old = ec2env.ecfg().Config
                 changed, err = old.Apply(t.change)
                 c.Assert(err, gc.IsNil)
 
@@ skipping 159 matching lines @@
                 err: ".*environment has no access-key or secret-key",
         }, {
                 config: attrs{
                         "admin-secret": "Futumpsh",
                 },
         }, {
                 config:       attrs{},
                 firewallMode: config.FwInstance,
         }, {
                 config: attrs{
-                        "firewall-mode": "",
-                },
-                firewallMode: config.FwInstance,
-        }, {
-                config: attrs{
                         "firewall-mode": "instance",
                 },
                 firewallMode: config.FwInstance,
         }, {
                 config: attrs{
                         "firewall-mode": "global",
                 },
                 firewallMode: config.FwGlobal,
         }, {
                 config: attrs{
@@ skipping 63 matching lines @@
 func (s *ConfigSuite) TestMissingAuth(c *gc.C) {
         os.Setenv("AWS_ACCESS_KEY_ID", "")
         os.Setenv("AWS_SECRET_ACCESS_KEY", "")
         // Since r37 goamz uses these as fallbacks, so unset them too.
         os.Setenv("EC2_ACCESS_KEY", "")
         os.Setenv("EC2_SECRET_KEY", "")
         test := configTests[0]
         test.err = "environment has no access-key or secret-key"
         test.check(c)
 }