github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/environs/config_test.go (about)

     1  // Copyright 2011, 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package environs_test
     5  
     6  import (
     7  	jc "github.com/juju/testing/checkers"
     8  	gc "gopkg.in/check.v1"
     9  
    10  	"github.com/juju/juju/environs"
    11  	"github.com/juju/juju/environs/config"
    12  	"github.com/juju/juju/provider/dummy"
    13  	_ "github.com/juju/juju/provider/manual"
    14  	"github.com/juju/juju/testing"
    15  )
    16  
    17  type suite struct {
    18  	testing.FakeJujuXDGDataHomeSuite
    19  }
    20  
    21  var _ = gc.Suite(&suite{})
    22  
    23  func (s *suite) SetUpTest(c *gc.C) {
    24  	s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
    25  	s.AddCleanup(dummy.Reset)
    26  }
    27  
    28  // dummySampleConfig returns the dummy sample config without
    29  // the controller configured.
    30  // This function also exists in cloudconfig/userdata_test
    31  // Maybe place it in dummy and export it?
    32  func dummySampleConfig() testing.Attrs {
    33  	return dummy.SampleConfig().Merge(testing.Attrs{
    34  		"controller": false,
    35  	})
    36  }
    37  
    38  func inMap(attrs testing.Attrs, attr string) bool {
    39  	_, ok := attrs[attr]
    40  	return ok
    41  }
    42  
    43  func (*suite) TestBootstrapConfig(c *gc.C) {
    44  	attrs := dummySampleConfig().Merge(testing.Attrs{
    45  		"agent-version": "1.2.3",
    46  	})
    47  	c.Assert(inMap(attrs, "secret"), jc.IsTrue)
    48  	c.Assert(inMap(attrs, "ca-private-key"), jc.IsTrue)
    49  	c.Assert(inMap(attrs, "admin-secret"), jc.IsTrue)
    50  
    51  	cfg, err := config.New(config.NoDefaults, attrs)
    52  	c.Assert(err, jc.ErrorIsNil)
    53  	c.Assert(err, jc.ErrorIsNil)
    54  
    55  	cfg1, err := environs.BootstrapConfig(cfg)
    56  	c.Assert(err, jc.ErrorIsNil)
    57  
    58  	expect := cfg.AllAttrs()
    59  	expect["admin-secret"] = ""
    60  	expect["ca-private-key"] = ""
    61  	c.Assert(cfg1.AllAttrs(), gc.DeepEquals, expect)
    62  }
    63  
    64  type dummyProvider struct {
    65  	environs.EnvironProvider
    66  }
    67  
    68  func (s *suite) TestRegisterProvider(c *gc.C) {
    69  	s.PatchValue(environs.Providers, make(map[string]environs.EnvironProvider))
    70  	s.PatchValue(environs.ProviderAliases, make(map[string]string))
    71  	type step struct {
    72  		name    string
    73  		aliases []string
    74  		err     string
    75  	}
    76  	type test []step
    77  
    78  	tests := []test{
    79  		[]step{{
    80  			name: "providerName",
    81  		}},
    82  		[]step{{
    83  			name:    "providerName",
    84  			aliases: []string{"providerName"},
    85  			err:     "juju: duplicate provider alias \"providerName\"",
    86  		}},
    87  		[]step{{
    88  			name:    "providerName",
    89  			aliases: []string{"providerAlias", "providerAlias"},
    90  			err:     "juju: duplicate provider alias \"providerAlias\"",
    91  		}},
    92  		[]step{{
    93  			name:    "providerName",
    94  			aliases: []string{"providerAlias1", "providerAlias2"},
    95  		}},
    96  		[]step{{
    97  			name: "providerName",
    98  		}, {
    99  			name: "providerName",
   100  			err:  "juju: duplicate provider name \"providerName\"",
   101  		}},
   102  		[]step{{
   103  			name: "providerName1",
   104  		}, {
   105  			name:    "providerName2",
   106  			aliases: []string{"providerName"},
   107  		}},
   108  		[]step{{
   109  			name: "providerName1",
   110  		}, {
   111  			name:    "providerName2",
   112  			aliases: []string{"providerName1"},
   113  			err:     "juju: duplicate provider alias \"providerName1\"",
   114  		}},
   115  	}
   116  
   117  	registerProvider := func(name string, aliases []string) (err error) {
   118  		defer func() { err, _ = recover().(error) }()
   119  		registered := &dummyProvider{}
   120  		environs.RegisterProvider(name, registered, aliases...)
   121  		p, err := environs.Provider(name)
   122  		c.Assert(err, jc.ErrorIsNil)
   123  		c.Assert(p, gc.Equals, registered)
   124  		for _, alias := range aliases {
   125  			p, err := environs.Provider(alias)
   126  			c.Assert(err, jc.ErrorIsNil)
   127  			c.Assert(p, gc.Equals, registered)
   128  			c.Assert(p, gc.Equals, registered)
   129  		}
   130  		return nil
   131  	}
   132  	for i, test := range tests {
   133  		c.Logf("test %d: %v", i, test)
   134  		for k := range *environs.Providers {
   135  			delete(*environs.Providers, k)
   136  		}
   137  		for k := range *environs.ProviderAliases {
   138  			delete(*environs.ProviderAliases, k)
   139  		}
   140  		for _, step := range test {
   141  			err := registerProvider(step.name, step.aliases)
   142  			if step.err == "" {
   143  				c.Assert(err, jc.ErrorIsNil)
   144  			} else {
   145  				c.Assert(err, gc.ErrorMatches, step.err)
   146  			}
   147  		}
   148  	}
   149  }