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