github.com/wallyworld/juju@v0.0.0-20161013125918-6cf1bc9d917a/api/modelmanager/modelmanager_test.go (about) 1 // Copyright 2015 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package modelmanager_test 5 6 import ( 7 jc "github.com/juju/testing/checkers" 8 "github.com/juju/utils" 9 gc "gopkg.in/check.v1" 10 "gopkg.in/juju/names.v2" 11 12 "github.com/juju/juju/api/base" 13 basetesting "github.com/juju/juju/api/base/testing" 14 "github.com/juju/juju/api/modelmanager" 15 "github.com/juju/juju/apiserver/params" 16 "github.com/juju/juju/environs/config" 17 jujutesting "github.com/juju/juju/juju/testing" 18 "github.com/juju/juju/testing" 19 "github.com/juju/juju/testing/factory" 20 ) 21 22 type modelmanagerSuite struct { 23 jujutesting.JujuConnSuite 24 } 25 26 var _ = gc.Suite(&modelmanagerSuite{}) 27 28 func (s *modelmanagerSuite) SetUpTest(c *gc.C) { 29 s.JujuConnSuite.SetUpTest(c) 30 } 31 32 func (s *modelmanagerSuite) OpenAPI(c *gc.C) *modelmanager.Client { 33 return modelmanager.NewClient(s.OpenControllerAPI(c)) 34 } 35 36 func (s *modelmanagerSuite) TestCreateModelBadUser(c *gc.C) { 37 modelManager := s.OpenAPI(c) 38 defer modelManager.Close() 39 _, err := modelManager.CreateModel("mymodel", "not a user", "", "", names.CloudCredentialTag{}, nil) 40 c.Assert(err, gc.ErrorMatches, `invalid owner name "not a user"`) 41 } 42 43 func (s *modelmanagerSuite) TestCreateModel(c *gc.C) { 44 s.testCreateModel(c, "dummy", "dummy-region") 45 } 46 47 func (s *modelmanagerSuite) TestCreateModelCloudDefaultRegion(c *gc.C) { 48 s.testCreateModel(c, "dummy", "") 49 } 50 51 func (s *modelmanagerSuite) TestCreateModelDefaultCloudAndRegion(c *gc.C) { 52 s.testCreateModel(c, "", "") 53 } 54 55 func (s *modelmanagerSuite) testCreateModel(c *gc.C, cloud, region string) { 56 modelManager := s.OpenAPI(c) 57 defer modelManager.Close() 58 user := s.Factory.MakeUser(c, nil) 59 owner := user.UserTag().Id() 60 newModel, err := modelManager.CreateModel("new-model", owner, cloud, region, names.CloudCredentialTag{}, map[string]interface{}{ 61 "authorized-keys": "ssh-key", 62 // dummy needs controller 63 "controller": false, 64 }) 65 c.Assert(err, jc.ErrorIsNil) 66 c.Assert(newModel.Name, gc.Equals, "new-model") 67 c.Assert(newModel.Owner, gc.Equals, user.String()) 68 c.Assert(newModel.CloudRegion, gc.Equals, "dummy-region") 69 c.Assert(utils.IsValidUUIDString(newModel.UUID), jc.IsTrue) 70 } 71 72 func (s *modelmanagerSuite) TestListModelsBadUser(c *gc.C) { 73 modelManager := s.OpenAPI(c) 74 defer modelManager.Close() 75 _, err := modelManager.ListModels("not a user") 76 c.Assert(err, gc.ErrorMatches, `invalid user name "not a user"`) 77 } 78 79 func (s *modelmanagerSuite) TestListModels(c *gc.C) { 80 owner := names.NewUserTag("user@remote") 81 s.Factory.MakeModel(c, &factory.ModelParams{ 82 Name: "first", Owner: owner}).Close() 83 s.Factory.MakeModel(c, &factory.ModelParams{ 84 Name: "second", Owner: owner}).Close() 85 86 modelManager := s.OpenAPI(c) 87 defer modelManager.Close() 88 models, err := modelManager.ListModels("user@remote") 89 c.Assert(err, jc.ErrorIsNil) 90 c.Assert(models, gc.HasLen, 2) 91 92 modelNames := []string{models[0].Name, models[1].Name} 93 c.Assert(modelNames, jc.DeepEquals, []string{"first", "second"}) 94 ownerNames := []string{models[0].Owner, models[1].Owner} 95 c.Assert(ownerNames, jc.DeepEquals, []string{"user@remote", "user@remote"}) 96 } 97 98 func (s *modelmanagerSuite) TestDestroyModel(c *gc.C) { 99 modelManager := s.OpenAPI(c) 100 defer modelManager.Close() 101 var called bool 102 modelmanager.PatchFacadeCall(&s.CleanupSuite, modelManager, 103 func(req string, args interface{}, resp interface{}) error { 104 c.Assert(req, gc.Equals, "DestroyModels") 105 c.Assert(args, jc.DeepEquals, params.Entities{ 106 Entities: []params.Entity{{testing.ModelTag.String()}}, 107 }) 108 results := resp.(*params.ErrorResults) 109 *results = params.ErrorResults{ 110 Results: []params.ErrorResult{{}}, 111 } 112 called = true 113 return nil 114 }) 115 116 err := modelManager.DestroyModel(testing.ModelTag) 117 c.Assert(err, jc.ErrorIsNil) 118 c.Assert(called, jc.IsTrue) 119 } 120 121 func (s *modelmanagerSuite) TestModelDefaults(c *gc.C) { 122 apiCaller := basetesting.APICallerFunc( 123 func(objType string, 124 version int, 125 id, request string, 126 a, result interface{}, 127 ) error { 128 c.Check(objType, gc.Equals, "ModelManager") 129 c.Check(id, gc.Equals, "") 130 c.Check(request, gc.Equals, "ModelDefaults") 131 c.Check(a, gc.IsNil) 132 c.Assert(result, gc.FitsTypeOf, ¶ms.ModelDefaultsResult{}) 133 results := result.(*params.ModelDefaultsResult) 134 results.Config = map[string]params.ModelDefaults{ 135 "foo": {"bar", "model", []params.RegionDefaults{{ 136 "dummy-region", 137 "dummy-value"}}}, 138 } 139 return nil 140 }, 141 ) 142 client := modelmanager.NewClient(apiCaller) 143 result, err := client.ModelDefaults() 144 c.Assert(err, jc.ErrorIsNil) 145 146 c.Assert(result, jc.DeepEquals, config.ModelDefaultAttributes{ 147 "foo": {"bar", "model", []config.RegionDefaultValue{{ 148 "dummy-region", 149 "dummy-value"}}}, 150 }) 151 } 152 153 func (s *modelmanagerSuite) TestSetModelDefaults(c *gc.C) { 154 called := false 155 apiCaller := basetesting.APICallerFunc( 156 func(objType string, 157 version int, 158 id, request string, 159 a, result interface{}, 160 ) error { 161 c.Check(objType, gc.Equals, "ModelManager") 162 c.Check(id, gc.Equals, "") 163 c.Check(request, gc.Equals, "SetModelDefaults") 164 c.Check(a, jc.DeepEquals, params.SetModelDefaults{ 165 Config: []params.ModelDefaultValues{{ 166 CloudTag: "cloud-mycloud", 167 CloudRegion: "region", 168 Config: map[string]interface{}{ 169 "some-name": "value", 170 "other-name": true, 171 }, 172 }}}) 173 c.Assert(result, gc.FitsTypeOf, ¶ms.ErrorResults{}) 174 *(result.(*params.ErrorResults)) = params.ErrorResults{ 175 Results: []params.ErrorResult{{Error: nil}}, 176 } 177 called = true 178 return nil 179 }, 180 ) 181 client := modelmanager.NewClient(apiCaller) 182 err := client.SetModelDefaults("mycloud", "region", map[string]interface{}{ 183 "some-name": "value", 184 "other-name": true, 185 }) 186 c.Assert(err, jc.ErrorIsNil) 187 c.Assert(called, jc.IsTrue) 188 } 189 190 func (s *modelmanagerSuite) TestUnsetModelDefaults(c *gc.C) { 191 called := false 192 apiCaller := basetesting.APICallerFunc( 193 func(objType string, 194 version int, 195 id, request string, 196 a, result interface{}, 197 ) error { 198 c.Check(objType, gc.Equals, "ModelManager") 199 c.Check(id, gc.Equals, "") 200 c.Check(request, gc.Equals, "UnsetModelDefaults") 201 c.Check(a, jc.DeepEquals, params.UnsetModelDefaults{ 202 Keys: []params.ModelUnsetKeys{{ 203 CloudTag: "cloud-mycloud", 204 CloudRegion: "region", 205 Keys: []string{"foo", "bar"}, 206 }}}) 207 c.Assert(result, gc.FitsTypeOf, ¶ms.ErrorResults{}) 208 *(result.(*params.ErrorResults)) = params.ErrorResults{ 209 Results: []params.ErrorResult{{Error: nil}}, 210 } 211 called = true 212 return nil 213 }, 214 ) 215 client := modelmanager.NewClient(apiCaller) 216 err := client.UnsetModelDefaults("mycloud", "region", "foo", "bar") 217 c.Assert(err, jc.ErrorIsNil) 218 c.Assert(called, jc.IsTrue) 219 } 220 221 func (s *modelmanagerSuite) TestModelStatus(c *gc.C) { 222 sysManager := s.OpenAPI(c) 223 defer sysManager.Close() 224 m := s.Factory.MakeMachine(c, nil) 225 id, err := m.InstanceId() 226 c.Assert(err, jc.ErrorIsNil) 227 modelTag := s.State.ModelTag() 228 results, err := sysManager.ModelStatus(modelTag) 229 c.Assert(err, jc.ErrorIsNil) 230 c.Assert(results, jc.DeepEquals, []base.ModelStatus{{ 231 UUID: modelTag.Id(), 232 TotalMachineCount: 1, 233 HostedMachineCount: 1, 234 ServiceCount: 0, 235 Owner: "admin", 236 Life: string(params.Alive), 237 Machines: []base.Machine{{Id: "0", InstanceId: string(id), Status: "pending"}}, 238 }}) 239 } 240 241 type dumpModelSuite struct { 242 testing.BaseSuite 243 } 244 245 var _ = gc.Suite(&dumpModelSuite{}) 246 247 func (s *dumpModelSuite) TestDumpModel(c *gc.C) { 248 expected := map[string]interface{}{ 249 "model-uuid": "some-uuid", 250 "other-key": "special", 251 } 252 results := params.MapResults{Results: []params.MapResult{{ 253 Result: expected, 254 }}} 255 apiCaller := basetesting.APICallerFunc( 256 func(objType string, version int, id, request string, args, result interface{}) error { 257 c.Check(objType, gc.Equals, "ModelManager") 258 c.Check(request, gc.Equals, "DumpModels") 259 in, ok := args.(params.Entities) 260 c.Assert(ok, jc.IsTrue) 261 c.Assert(in, gc.DeepEquals, params.Entities{[]params.Entity{{testing.ModelTag.String()}}}) 262 res, ok := result.(*params.MapResults) 263 c.Assert(ok, jc.IsTrue) 264 *res = results 265 return nil 266 }) 267 client := modelmanager.NewClient(apiCaller) 268 out, err := client.DumpModel(testing.ModelTag) 269 c.Assert(err, jc.ErrorIsNil) 270 c.Assert(out, jc.DeepEquals, expected) 271 } 272 273 func (s *dumpModelSuite) TestDumpModelError(c *gc.C) { 274 results := params.MapResults{Results: []params.MapResult{{ 275 Error: ¶ms.Error{Message: "fake error"}, 276 }}} 277 apiCaller := basetesting.APICallerFunc( 278 func(objType string, version int, id, request string, args, result interface{}) error { 279 res, ok := result.(*params.MapResults) 280 c.Assert(ok, jc.IsTrue) 281 *res = results 282 return nil 283 }) 284 client := modelmanager.NewClient(apiCaller) 285 out, err := client.DumpModel(testing.ModelTag) 286 c.Assert(err, gc.ErrorMatches, "fake error") 287 c.Assert(out, gc.IsNil) 288 } 289 290 func (s *dumpModelSuite) TestDumpModelDB(c *gc.C) { 291 expected := map[string]interface{}{ 292 "models": []map[string]interface{}{{ 293 "name": "admin", 294 "uuid": "some-uuid", 295 }}, 296 "machines": []map[string]interface{}{{ 297 "id": "0", 298 "life": 0, 299 }}, 300 } 301 results := params.MapResults{Results: []params.MapResult{{ 302 Result: expected, 303 }}} 304 apiCaller := basetesting.APICallerFunc( 305 func(objType string, version int, id, request string, args, result interface{}) error { 306 c.Check(objType, gc.Equals, "ModelManager") 307 c.Check(request, gc.Equals, "DumpModelsDB") 308 in, ok := args.(params.Entities) 309 c.Assert(ok, jc.IsTrue) 310 c.Assert(in, gc.DeepEquals, params.Entities{[]params.Entity{{testing.ModelTag.String()}}}) 311 res, ok := result.(*params.MapResults) 312 c.Assert(ok, jc.IsTrue) 313 *res = results 314 return nil 315 }) 316 client := modelmanager.NewClient(apiCaller) 317 out, err := client.DumpModelDB(testing.ModelTag) 318 c.Assert(err, jc.ErrorIsNil) 319 c.Assert(out, jc.DeepEquals, expected) 320 } 321 322 func (s *dumpModelSuite) TestDumpModelDBError(c *gc.C) { 323 results := params.MapResults{Results: []params.MapResult{{ 324 Error: ¶ms.Error{Message: "fake error"}, 325 }}} 326 apiCaller := basetesting.APICallerFunc( 327 func(objType string, version int, id, request string, args, result interface{}) error { 328 res, ok := result.(*params.MapResults) 329 c.Assert(ok, jc.IsTrue) 330 *res = results 331 return nil 332 }) 333 client := modelmanager.NewClient(apiCaller) 334 out, err := client.DumpModelDB(testing.ModelTag) 335 c.Assert(err, gc.ErrorMatches, "fake error") 336 c.Assert(out, gc.IsNil) 337 }