github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/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  	"github.com/juju/errors"
     8  	jc "github.com/juju/testing/checkers"
     9  	gc "gopkg.in/check.v1"
    10  
    11  	"github.com/juju/juju/environs"
    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  type dummyProvider struct {
    39  	environs.CloudEnvironProvider
    40  }
    41  
    42  func (s *suite) TestRegisterProvider(c *gc.C) {
    43  	s.PatchValue(environs.Providers, make(map[string]environs.EnvironProvider))
    44  	s.PatchValue(environs.ProviderAliases, make(map[string]string))
    45  	type step struct {
    46  		name    string
    47  		aliases []string
    48  		err     string
    49  	}
    50  	type test []step
    51  
    52  	tests := []test{
    53  		[]step{{
    54  			name: "providerName",
    55  		}},
    56  		[]step{{
    57  			name:    "providerName",
    58  			aliases: []string{"providerName"},
    59  			err:     "juju: duplicate provider alias \"providerName\"",
    60  		}},
    61  		[]step{{
    62  			name:    "providerName",
    63  			aliases: []string{"providerAlias", "providerAlias"},
    64  			err:     "juju: duplicate provider alias \"providerAlias\"",
    65  		}},
    66  		[]step{{
    67  			name:    "providerName",
    68  			aliases: []string{"providerAlias1", "providerAlias2"},
    69  		}},
    70  		[]step{{
    71  			name: "providerName",
    72  		}, {
    73  			name: "providerName",
    74  			err:  "juju: duplicate provider name \"providerName\"",
    75  		}},
    76  		[]step{{
    77  			name: "providerName1",
    78  		}, {
    79  			name:    "providerName2",
    80  			aliases: []string{"providerName"},
    81  		}},
    82  		[]step{{
    83  			name: "providerName1",
    84  		}, {
    85  			name:    "providerName2",
    86  			aliases: []string{"providerName1"},
    87  			err:     "juju: duplicate provider alias \"providerName1\"",
    88  		}},
    89  	}
    90  
    91  	registerProvider := func(name string, aliases []string) (err error) {
    92  		defer func() { err, _ = recover().(error) }()
    93  		registered := &dummyProvider{}
    94  		environs.RegisterProvider(name, registered, aliases...)
    95  		p, err := environs.Provider(name)
    96  		c.Assert(err, jc.ErrorIsNil)
    97  		c.Assert(p, gc.Equals, registered)
    98  		for _, alias := range aliases {
    99  			p, err := environs.Provider(alias)
   100  			c.Assert(err, jc.ErrorIsNil)
   101  			c.Assert(p, gc.Equals, registered)
   102  			c.Assert(p, gc.Equals, registered)
   103  		}
   104  		return nil
   105  	}
   106  	for i, test := range tests {
   107  		c.Logf("test %d: %v", i, test)
   108  		for k := range *environs.Providers {
   109  			delete(*environs.Providers, k)
   110  		}
   111  		for k := range *environs.ProviderAliases {
   112  			delete(*environs.ProviderAliases, k)
   113  		}
   114  		for _, step := range test {
   115  			err := registerProvider(step.name, step.aliases)
   116  			if step.err == "" {
   117  				c.Assert(err, jc.ErrorIsNil)
   118  			} else {
   119  				c.Assert(err, gc.ErrorMatches, step.err)
   120  			}
   121  		}
   122  	}
   123  }
   124  
   125  func (s *suite) TestUnregisterProvider(c *gc.C) {
   126  	s.PatchValue(environs.Providers, make(map[string]environs.EnvironProvider))
   127  	s.PatchValue(environs.ProviderAliases, make(map[string]string))
   128  	registered := &dummyProvider{}
   129  	unreg := environs.RegisterProvider("test", registered, "alias1", "alias2")
   130  	unreg()
   131  	_, err := environs.Provider("test")
   132  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
   133  	_, err = environs.Provider("alias1")
   134  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
   135  	_, err = environs.Provider("alias2")
   136  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
   137  }