github.com/cloud-green/juju@v0.0.0-20151002100041-a00291338d3d/apiserver/storage/poollist_test.go (about) 1 // Copyright 2015 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package storage_test 5 6 import ( 7 "fmt" 8 9 "github.com/juju/errors" 10 jc "github.com/juju/testing/checkers" 11 "github.com/juju/utils/set" 12 gc "gopkg.in/check.v1" 13 14 "github.com/juju/juju/apiserver/params" 15 apiserverstorage "github.com/juju/juju/apiserver/storage" 16 "github.com/juju/juju/storage" 17 "github.com/juju/juju/storage/provider" 18 "github.com/juju/juju/storage/provider/registry" 19 ) 20 21 type poolSuite struct { 22 baseStorageSuite 23 } 24 25 var _ = gc.Suite(&poolSuite{}) 26 27 const ( 28 tstName = "testpool" 29 ) 30 31 func (s *poolSuite) createPools(c *gc.C, num int) { 32 var err error 33 for i := 0; i < num; i++ { 34 poolName := fmt.Sprintf("%v%v", tstName, i) 35 s.baseStorageSuite.pools[poolName], err = 36 storage.NewConfig(poolName, provider.LoopProviderType, nil) 37 c.Assert(err, jc.ErrorIsNil) 38 } 39 } 40 41 func (s *poolSuite) TestList(c *gc.C) { 42 s.createPools(c, 1) 43 pools, err := s.api.ListPools(params.StoragePoolFilter{}) 44 c.Assert(err, jc.ErrorIsNil) 45 c.Assert(pools.Results, gc.HasLen, 1) 46 one := pools.Results[0] 47 c.Assert(one.Name, gc.Equals, fmt.Sprintf("%v%v", tstName, 0)) 48 c.Assert(one.Provider, gc.Equals, string(provider.LoopProviderType)) 49 } 50 51 func (s *poolSuite) TestListManyResults(c *gc.C) { 52 s.createPools(c, 2) 53 pools, err := s.api.ListPools(params.StoragePoolFilter{}) 54 c.Assert(err, jc.ErrorIsNil) 55 assertPoolNames(c, pools.Results, 56 "testpool0", "testpool1", 57 "dummy", "loop", 58 "tmpfs", "rootfs") 59 } 60 61 func (s *poolSuite) TestListByName(c *gc.C) { 62 s.createPools(c, 2) 63 tstName := fmt.Sprintf("%v%v", tstName, 1) 64 65 pools, err := s.api.ListPools(params.StoragePoolFilter{ 66 Names: []string{tstName}}) 67 c.Assert(err, jc.ErrorIsNil) 68 c.Assert(pools.Results, gc.HasLen, 1) 69 c.Assert(pools.Results[0].Name, gc.DeepEquals, tstName) 70 } 71 72 func (s *poolSuite) TestListByType(c *gc.C) { 73 s.createPools(c, 2) 74 s.registerProviders(c) 75 tstType := string(provider.TmpfsProviderType) 76 poolName := "rayofsunshine" 77 var err error 78 s.baseStorageSuite.pools[poolName], err = 79 storage.NewConfig(poolName, provider.TmpfsProviderType, nil) 80 c.Assert(err, jc.ErrorIsNil) 81 82 pools, err := s.api.ListPools(params.StoragePoolFilter{ 83 Providers: []string{tstType}}) 84 c.Assert(err, jc.ErrorIsNil) 85 assertPoolNames(c, pools.Results, "rayofsunshine", "tmpfs") 86 } 87 88 func (s *poolSuite) TestListByNameAndTypeAnd(c *gc.C) { 89 s.createPools(c, 2) 90 s.registerProviders(c) 91 tstType := string(provider.TmpfsProviderType) 92 poolName := "rayofsunshine" 93 var err error 94 s.baseStorageSuite.pools[poolName], err = 95 storage.NewConfig(poolName, provider.TmpfsProviderType, nil) 96 c.Assert(err, jc.ErrorIsNil) 97 pools, err := s.api.ListPools(params.StoragePoolFilter{ 98 Providers: []string{tstType}, 99 Names: []string{poolName}}) 100 c.Assert(err, jc.ErrorIsNil) 101 c.Assert(pools.Results, gc.HasLen, 1) 102 c.Assert(pools.Results[0].Provider, gc.DeepEquals, tstType) 103 c.Assert(pools.Results[0].Name, gc.DeepEquals, poolName) 104 } 105 106 func (s *poolSuite) TestListByNamesOr(c *gc.C) { 107 s.createPools(c, 2) 108 s.registerProviders(c) 109 poolName := "rayofsunshine" 110 var err error 111 s.baseStorageSuite.pools[poolName], err = 112 storage.NewConfig(poolName, provider.TmpfsProviderType, nil) 113 c.Assert(err, jc.ErrorIsNil) 114 pools, err := s.api.ListPools(params.StoragePoolFilter{ 115 Names: []string{ 116 fmt.Sprintf("%v%v", tstName, 1), 117 fmt.Sprintf("%v%v", tstName, 0), 118 }}) 119 c.Assert(err, jc.ErrorIsNil) 120 assertPoolNames(c, pools.Results, "testpool0", "testpool1") 121 } 122 123 func assertPoolNames(c *gc.C, results []params.StoragePool, expected ...string) { 124 expectedNames := set.NewStrings(expected...) 125 c.Assert(len(expectedNames), gc.Equals, len(results)) 126 for _, one := range results { 127 c.Assert(expectedNames.Contains(one.Name), jc.IsTrue) 128 } 129 } 130 131 func (s *poolSuite) TestListByTypesOr(c *gc.C) { 132 s.createPools(c, 2) 133 s.registerProviders(c) 134 tstType := string(provider.TmpfsProviderType) 135 poolName := "rayofsunshine" 136 var err error 137 s.baseStorageSuite.pools[poolName], err = 138 storage.NewConfig(poolName, provider.TmpfsProviderType, nil) 139 c.Assert(err, jc.ErrorIsNil) 140 pools, err := s.api.ListPools(params.StoragePoolFilter{ 141 Providers: []string{tstType, string(provider.LoopProviderType)}}) 142 c.Assert(err, jc.ErrorIsNil) 143 assertPoolNames(c, pools.Results, "testpool0", "testpool1", "rayofsunshine", "loop", "tmpfs") 144 } 145 146 func (s *poolSuite) TestListNoPools(c *gc.C) { 147 pools, err := s.api.ListPools(params.StoragePoolFilter{}) 148 c.Assert(err, jc.ErrorIsNil) 149 assertPoolNames(c, pools.Results, "dummy", "rootfs", "loop", "tmpfs") 150 } 151 152 func (s *poolSuite) TestListFilterEmpty(c *gc.C) { 153 valid, err := apiserverstorage.IsValidPoolListFilter(s.api, params.StoragePoolFilter{}) 154 s.assertNoError(c, valid, err) 155 } 156 157 const ( 158 validProvider = string(provider.LoopProviderType) 159 invalidProvider = "invalid" 160 validName = "pool" 161 invalidName = "7ool" 162 ) 163 164 func (s *poolSuite) TestListFilterValidProviders(c *gc.C) { 165 s.registerProviders(c) 166 valid, err := apiserverstorage.ValidateProviders( 167 s.api, 168 []string{validProvider}) 169 s.assertNoError(c, valid, err) 170 } 171 172 func (s *poolSuite) TestListFilterUnregisteredProvider(c *gc.C) { 173 s.state.envName = "noprovidersregistered" 174 valid, err := apiserverstorage.ValidateProviders( 175 s.api, 176 []string{validProvider}) 177 s.assertError(c, valid, err, ".*not supported.*") 178 } 179 180 func (s *poolSuite) TestListFilterUnknownProvider(c *gc.C) { 181 s.registerProviders(c) 182 valid, err := apiserverstorage.ValidateProviders( 183 s.api, 184 []string{invalidProvider}) 185 s.assertError(c, valid, err, ".*not supported.*") 186 } 187 188 func (s *poolSuite) TestListFilterValidNames(c *gc.C) { 189 valid, err := apiserverstorage.ValidateNames( 190 s.api, 191 []string{validName}) 192 s.assertNoError(c, valid, err) 193 } 194 195 func (s *poolSuite) TestListFilterInvalidNames(c *gc.C) { 196 valid, err := apiserverstorage.ValidateNames( 197 s.api, 198 []string{invalidName}) 199 s.assertError(c, valid, err, ".*not valid.*") 200 } 201 202 func (s *poolSuite) TestListFilterValidProvidersAndNames(c *gc.C) { 203 s.registerProviders(c) 204 valid, err := apiserverstorage.IsValidPoolListFilter( 205 s.api, 206 params.StoragePoolFilter{ 207 Providers: []string{validProvider}, 208 Names: []string{validName}}) 209 s.assertNoError(c, valid, err) 210 } 211 212 func (s *poolSuite) TestListFilterValidProvidersAndInvalidNames(c *gc.C) { 213 s.registerProviders(c) 214 valid, err := apiserverstorage.IsValidPoolListFilter( 215 s.api, 216 params.StoragePoolFilter{ 217 Providers: []string{validProvider}, 218 Names: []string{invalidName}}) 219 s.assertError(c, valid, err, ".*not valid.*") 220 } 221 222 func (s *poolSuite) TestListFilterInvalidProvidersAndValidNames(c *gc.C) { 223 valid, err := apiserverstorage.IsValidPoolListFilter( 224 s.api, 225 params.StoragePoolFilter{ 226 Providers: []string{invalidProvider}, 227 Names: []string{validName}}) 228 s.assertError(c, valid, err, ".*not supported.*") 229 } 230 231 func (s *poolSuite) TestListFilterInvalidProvidersAndNames(c *gc.C) { 232 valid, err := apiserverstorage.IsValidPoolListFilter( 233 s.api, 234 params.StoragePoolFilter{ 235 Providers: []string{invalidProvider}, 236 Names: []string{invalidName}}) 237 s.assertError(c, valid, err, ".*not supported.*") 238 } 239 240 func (s *poolSuite) registerProviders(c *gc.C) { 241 registry.RegisterEnvironStorageProviders(s.state.envName, "dummy") 242 } 243 244 func (s *poolSuite) assertNoError(c *gc.C, result bool, err error) { 245 c.Assert(err, jc.ErrorIsNil) 246 c.Assert(result, jc.IsTrue) 247 } 248 249 func (s *poolSuite) assertError(c *gc.C, result bool, err error, msg string) { 250 c.Assert(errors.Cause(err), gc.ErrorMatches, msg) 251 c.Assert(result, jc.IsFalse) 252 }