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