github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/environs/configstore/interface_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package configstore_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/configstore"
    12  	"github.com/juju/juju/feature"
    13  	"github.com/juju/juju/testing"
    14  )
    15  
    16  // interfaceSuite defines a set of tests on a ConfigStorage
    17  // implementation, independent of the implementation itself.
    18  // The NewStore field must be set up to return a ConfigStorage
    19  // instance of the type to be tested.
    20  type interfaceSuite struct {
    21  	testing.BaseSuite
    22  	NewStore func(c *gc.C) configstore.Storage
    23  }
    24  
    25  func (s *interfaceSuite) TestCreate(c *gc.C) {
    26  	store := s.NewStore(c)
    27  	info := store.CreateInfo("someenv")
    28  	c.Assert(info.APIEndpoint(), gc.DeepEquals, configstore.APIEndpoint{})
    29  	c.Assert(info.APICredentials(), gc.DeepEquals, configstore.APICredentials{})
    30  	c.Assert(info.Initialized(), jc.IsFalse)
    31  
    32  	// The info isn't written until you call Write
    33  	_, err := store.ReadInfo("someenv")
    34  	c.Assert(err, gc.ErrorMatches, `environment "someenv" not found`)
    35  
    36  	err = info.Write()
    37  	c.Assert(err, jc.ErrorIsNil)
    38  
    39  	// Check that we can read it again.
    40  	info, err = store.ReadInfo("someenv")
    41  	c.Assert(err, jc.ErrorIsNil)
    42  
    43  	// Now that it exists, we cannot write a newly created info again.
    44  	info = store.CreateInfo("someenv")
    45  	err = info.Write()
    46  	c.Assert(errors.Cause(err), gc.Equals, configstore.ErrEnvironInfoAlreadyExists)
    47  }
    48  
    49  func (s *interfaceSuite) createInitialisedEnvironment(c *gc.C, store configstore.Storage, envName, envUUID, serverUUID string) {
    50  	info := store.CreateInfo(envName)
    51  	info.SetAPIEndpoint(configstore.APIEndpoint{
    52  		Addresses:   []string{"localhost"},
    53  		CACert:      testing.CACert,
    54  		EnvironUUID: envUUID,
    55  		ServerUUID:  serverUUID,
    56  	})
    57  	err := info.Write()
    58  	c.Assert(err, jc.ErrorIsNil)
    59  }
    60  
    61  func (s *interfaceSuite) TestList(c *gc.C) {
    62  	store := s.NewStore(c)
    63  	s.createInitialisedEnvironment(c, store, "enva", "enva-uuid", "")
    64  	s.createInitialisedEnvironment(c, store, "envb", "envb-uuid", "")
    65  
    66  	s.SetFeatureFlags(feature.JES)
    67  	s.createInitialisedEnvironment(c, store, "envc", "envc-uuid", "envc-uuid")
    68  	s.createInitialisedEnvironment(c, store, "system", "", "system-uuid")
    69  
    70  	environs, err := store.List()
    71  	c.Assert(err, jc.ErrorIsNil)
    72  	c.Assert(environs, jc.SameContents, []string{"enva", "envb", "envc"})
    73  }
    74  
    75  func (s *interfaceSuite) TestListSystems(c *gc.C) {
    76  	store := s.NewStore(c)
    77  	s.createInitialisedEnvironment(c, store, "enva", "enva-uuid", "")
    78  	s.createInitialisedEnvironment(c, store, "envb", "envb-uuid", "")
    79  
    80  	s.SetFeatureFlags(feature.JES)
    81  	s.createInitialisedEnvironment(c, store, "envc", "envc-uuid", "envc-uuid")
    82  	s.createInitialisedEnvironment(c, store, "envd", "envd-uuid", "envc-uuid")
    83  	s.createInitialisedEnvironment(c, store, "system", "", "system-uuid")
    84  
    85  	environs, err := store.ListSystems()
    86  	c.Assert(err, jc.ErrorIsNil)
    87  	c.Assert(environs, jc.SameContents, []string{"enva", "envb", "envc", "system"})
    88  }
    89  
    90  func (s *interfaceSuite) TestSetAPIEndpointAndCredentials(c *gc.C) {
    91  	store := s.NewStore(c)
    92  
    93  	info := store.CreateInfo("someenv")
    94  
    95  	expectEndpoint := configstore.APIEndpoint{
    96  		Addresses:   []string{"0.1.2.3"},
    97  		Hostnames:   []string{"example.com"},
    98  		CACert:      "a cert",
    99  		EnvironUUID: "dead-beef",
   100  	}
   101  	info.SetAPIEndpoint(expectEndpoint)
   102  	c.Assert(info.APIEndpoint(), gc.DeepEquals, expectEndpoint)
   103  
   104  	expectCreds := configstore.APICredentials{
   105  		User:     "foobie",
   106  		Password: "bletch",
   107  	}
   108  	info.SetAPICredentials(expectCreds)
   109  	c.Assert(info.APICredentials(), gc.DeepEquals, expectCreds)
   110  }
   111  
   112  func (s *interfaceSuite) TestWrite(c *gc.C) {
   113  	store := s.NewStore(c)
   114  
   115  	// Create the info.
   116  	info := store.CreateInfo("someenv")
   117  
   118  	// Set it up with some actual data and write it out.
   119  	expectCreds := configstore.APICredentials{
   120  		User:     "foobie",
   121  		Password: "bletch",
   122  	}
   123  	info.SetAPICredentials(expectCreds)
   124  
   125  	expectEndpoint := configstore.APIEndpoint{
   126  		Addresses:   []string{"0.1.2.3"},
   127  		Hostnames:   []string{"example.invalid"},
   128  		CACert:      "a cert",
   129  		EnvironUUID: "dead-beef",
   130  	}
   131  	info.SetAPIEndpoint(expectEndpoint)
   132  
   133  	err := info.Write()
   134  	c.Assert(err, jc.ErrorIsNil)
   135  	c.Assert(info.Initialized(), jc.IsTrue)
   136  
   137  	// Check we can read the information back
   138  	info, err = store.ReadInfo("someenv")
   139  	c.Assert(err, jc.ErrorIsNil)
   140  	c.Assert(info.APICredentials(), gc.DeepEquals, expectCreds)
   141  	c.Assert(info.APIEndpoint(), gc.DeepEquals, expectEndpoint)
   142  
   143  	// Change the information and write it again.
   144  	expectCreds.User = "arble"
   145  	info.SetAPICredentials(expectCreds)
   146  	err = info.Write()
   147  	c.Assert(err, jc.ErrorIsNil)
   148  
   149  	// Check we can read the information back
   150  	info, err = store.ReadInfo("someenv")
   151  	c.Assert(err, jc.ErrorIsNil)
   152  	c.Assert(info.APICredentials(), gc.DeepEquals, expectCreds)
   153  }
   154  
   155  func (s *interfaceSuite) TestWriteTwice(c *gc.C) {
   156  	store := s.NewStore(c)
   157  
   158  	// Create the info.
   159  	info := store.CreateInfo("someenv")
   160  
   161  	// Set it up with some actual data and write it out.
   162  	expectCreds := configstore.APICredentials{
   163  		User:     "foobie",
   164  		Password: "bletch",
   165  	}
   166  	info.SetAPICredentials(expectCreds)
   167  	err := info.Write()
   168  	c.Assert(err, jc.ErrorIsNil)
   169  
   170  	expectEndpoint := configstore.APIEndpoint{
   171  		Addresses:   []string{"0.1.2.3"},
   172  		Hostnames:   []string{"example.invalid"},
   173  		CACert:      "a cert",
   174  		EnvironUUID: "dead-beef",
   175  	}
   176  	info.SetAPIEndpoint(expectEndpoint)
   177  	err = info.Write()
   178  	c.Assert(err, jc.ErrorIsNil)
   179  
   180  	// Check we can read the information back
   181  	again, err := store.ReadInfo("someenv")
   182  	c.Assert(err, jc.ErrorIsNil)
   183  	c.Assert(again.APICredentials(), gc.DeepEquals, expectCreds)
   184  	c.Assert(again.APIEndpoint(), gc.DeepEquals, expectEndpoint)
   185  }
   186  
   187  func (s *interfaceSuite) TestDestroy(c *gc.C) {
   188  	store := s.NewStore(c)
   189  
   190  	info := store.CreateInfo("someenv")
   191  	// Destroying something that hasn't been written is fine.
   192  	err := info.Destroy()
   193  	c.Assert(err, jc.ErrorIsNil)
   194  
   195  	err = info.Write()
   196  	c.Assert(err, jc.ErrorIsNil)
   197  
   198  	err = info.Destroy()
   199  	c.Assert(err, jc.ErrorIsNil)
   200  
   201  	err = info.Destroy()
   202  	c.Assert(err, gc.ErrorMatches, "environment info has already been removed")
   203  }
   204  
   205  func (s *interfaceSuite) TestNoBleedThrough(c *gc.C) {
   206  	store := s.NewStore(c)
   207  
   208  	info := store.CreateInfo("someenv")
   209  
   210  	info.SetAPICredentials(configstore.APICredentials{User: "foo"})
   211  	info.SetAPIEndpoint(configstore.APIEndpoint{CACert: "blah"})
   212  	attrs := map[string]interface{}{"foo": "bar"}
   213  	info.SetBootstrapConfig(attrs)
   214  
   215  	err := info.Write()
   216  	c.Assert(err, jc.ErrorIsNil)
   217  
   218  	attrs["foo"] = "different"
   219  
   220  	info1, err := store.ReadInfo("someenv")
   221  	c.Assert(err, jc.ErrorIsNil)
   222  	c.Assert(info1.Initialized(), jc.IsTrue)
   223  	c.Assert(info1.BootstrapConfig(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
   224  }
   225  
   226  func (s *interfaceSuite) TestSetBootstrapConfigPanicsWhenNotCreated(c *gc.C) {
   227  	store := s.NewStore(c)
   228  
   229  	info := store.CreateInfo("someenv")
   230  	info.SetBootstrapConfig(map[string]interface{}{"foo": "bar"})
   231  	err := info.Write()
   232  	c.Assert(err, jc.ErrorIsNil)
   233  
   234  	info, err = store.ReadInfo("someenv")
   235  	c.Assert(err, jc.ErrorIsNil)
   236  	c.Assert(func() { info.SetBootstrapConfig(nil) }, gc.PanicMatches, "bootstrap config set on environment info that has not just been created")
   237  }