github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/storage/poolmanager/poolmanager_test.go (about)

     1  // Copyright 2015 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package poolmanager_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/state"
    12  	statetesting "github.com/juju/juju/state/testing"
    13  	"github.com/juju/juju/storage"
    14  	"github.com/juju/juju/storage/poolmanager"
    15  )
    16  
    17  type poolSuite struct {
    18  	// TODO - don't use state directly, mock it out and add feature tests.
    19  	statetesting.StateSuite
    20  	poolManager poolmanager.PoolManager
    21  	settings    poolmanager.SettingsManager
    22  }
    23  
    24  var _ = gc.Suite(&poolSuite{})
    25  
    26  var poolAttrs = map[string]interface{}{
    27  	"name": "testpool", "type": "loop", "foo": "bar",
    28  }
    29  
    30  func (s *poolSuite) SetUpTest(c *gc.C) {
    31  	s.StateSuite.SetUpTest(c)
    32  	s.settings = state.NewStateSettings(s.State)
    33  	s.poolManager = poolmanager.New(s.settings)
    34  }
    35  
    36  func (s *poolSuite) createSettings(c *gc.C) {
    37  	err := s.settings.CreateSettings("pool#testpool", poolAttrs)
    38  	c.Assert(err, jc.ErrorIsNil)
    39  	// Create settings that isn't a pool.
    40  	err = s.settings.CreateSettings("r#1", nil)
    41  	c.Assert(err, jc.ErrorIsNil)
    42  }
    43  
    44  func (s *poolSuite) TestList(c *gc.C) {
    45  	s.createSettings(c)
    46  	pools, err := s.poolManager.List()
    47  	c.Assert(err, jc.ErrorIsNil)
    48  	c.Assert(pools, gc.HasLen, 1)
    49  	c.Assert(pools[0].Attrs(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
    50  	c.Assert(pools[0].Name(), gc.Equals, "testpool")
    51  	c.Assert(pools[0].Provider(), gc.Equals, storage.ProviderType("loop"))
    52  }
    53  
    54  func (s *poolSuite) TestListManyResults(c *gc.C) {
    55  	s.createSettings(c)
    56  	err := s.settings.CreateSettings("pool#testpool2", map[string]interface{}{
    57  		"name": "testpool2", "type": "loop", "foo2": "bar2",
    58  	})
    59  	c.Assert(err, jc.ErrorIsNil)
    60  	pools, err := s.poolManager.List()
    61  	c.Assert(err, jc.ErrorIsNil)
    62  	c.Assert(pools, gc.HasLen, 2)
    63  	poolCfgs := make(map[string]map[string]interface{})
    64  	for _, p := range pools {
    65  		poolCfgs[p.Name()] = p.Attrs()
    66  	}
    67  	c.Assert(poolCfgs, jc.DeepEquals, map[string]map[string]interface{}{
    68  		"testpool":  {"foo": "bar"},
    69  		"testpool2": {"foo2": "bar2"},
    70  	})
    71  }
    72  
    73  func (s *poolSuite) TestListNoPools(c *gc.C) {
    74  	pools, err := s.poolManager.List()
    75  	c.Assert(err, jc.ErrorIsNil)
    76  	c.Assert(pools, gc.HasLen, 0)
    77  }
    78  
    79  func (s *poolSuite) TestPool(c *gc.C) {
    80  	s.createSettings(c)
    81  	p, err := s.poolManager.Get("testpool")
    82  	c.Assert(err, jc.ErrorIsNil)
    83  	c.Assert(p.Attrs(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
    84  	c.Assert(p.Name(), gc.Equals, "testpool")
    85  	c.Assert(p.Provider(), gc.Equals, storage.ProviderType("loop"))
    86  }
    87  
    88  func (s *poolSuite) TestCreate(c *gc.C) {
    89  	created, err := s.poolManager.Create("testpool", storage.ProviderType("loop"), map[string]interface{}{"foo": "bar"})
    90  	c.Assert(err, jc.ErrorIsNil)
    91  	p, err := s.poolManager.Get("testpool")
    92  	c.Assert(created, gc.DeepEquals, p)
    93  	c.Assert(err, jc.ErrorIsNil)
    94  	c.Assert(p.Attrs(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
    95  	c.Assert(p.Name(), gc.Equals, "testpool")
    96  	c.Assert(p.Provider(), gc.Equals, storage.ProviderType("loop"))
    97  }
    98  
    99  func (s *poolSuite) TestCreateAlreadyExists(c *gc.C) {
   100  	_, err := s.poolManager.Create("testpool", storage.ProviderType("loop"), map[string]interface{}{"foo": "bar"})
   101  	c.Assert(err, jc.ErrorIsNil)
   102  	_, err = s.poolManager.Create("testpool", storage.ProviderType("loop"), map[string]interface{}{"foo": "bar"})
   103  	c.Assert(err, gc.ErrorMatches, ".*cannot overwrite.*")
   104  }
   105  
   106  func (s *poolSuite) TestCreateMissingName(c *gc.C) {
   107  	_, err := s.poolManager.Create("", "loop", map[string]interface{}{"foo": "bar"})
   108  	c.Assert(err, gc.ErrorMatches, "pool name is missing")
   109  }
   110  
   111  func (s *poolSuite) TestCreateMissingType(c *gc.C) {
   112  	_, err := s.poolManager.Create("testpool", "", map[string]interface{}{"foo": "bar"})
   113  	c.Assert(err, gc.ErrorMatches, "provider type is missing")
   114  }
   115  
   116  func (s *poolSuite) TestCreateInvalidConfig(c *gc.C) {
   117  	_, err := s.poolManager.Create("testpool", storage.ProviderType("loop"), map[string]interface{}{"persistent": true})
   118  	c.Assert(err, gc.ErrorMatches, `validating storage provider config: machine scoped storage provider "testpool" does not support persistent storage`)
   119  }
   120  
   121  func (s *poolSuite) TestDelete(c *gc.C) {
   122  	s.createSettings(c)
   123  	err := s.poolManager.Delete("testpool")
   124  	c.Assert(err, jc.ErrorIsNil)
   125  	_, err = s.poolManager.Get("testpool")
   126  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
   127  	// Delete again, no error.
   128  	err = s.poolManager.Delete("testpool")
   129  	c.Assert(err, jc.ErrorIsNil)
   130  }