github.com/mwhudson/juju@v0.0.0-20160512215208-90ff01f3497f/testing/factory/factory_test.go (about) 1 // Copyright 2014 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package factory_test 5 6 import ( 7 "fmt" 8 "regexp" 9 "time" 10 11 "github.com/juju/errors" 12 "github.com/juju/names" 13 jc "github.com/juju/testing/checkers" 14 "github.com/juju/utils" 15 gc "gopkg.in/check.v1" 16 "gopkg.in/juju/charm.v6-unstable" 17 18 "github.com/juju/juju/instance" 19 "github.com/juju/juju/state" 20 statetesting "github.com/juju/juju/state/testing" 21 "github.com/juju/juju/storage/provider" 22 "github.com/juju/juju/storage/provider/registry" 23 "github.com/juju/juju/testing" 24 "github.com/juju/juju/testing/factory" 25 ) 26 27 type factorySuite struct { 28 statetesting.StateSuite 29 Factory *factory.Factory 30 } 31 32 var _ = gc.Suite(&factorySuite{}) 33 34 func (s *factorySuite) SetUpTest(c *gc.C) { 35 s.Policy = new(statetesting.MockPolicy) 36 s.StateSuite.SetUpTest(c) 37 s.Factory = factory.NewFactory(s.State) 38 } 39 40 func (s *factorySuite) TestMakeUserNil(c *gc.C) { 41 user := s.Factory.MakeUser(c, nil) 42 c.Assert(user.IsDisabled(), jc.IsFalse) 43 44 saved, err := s.State.User(user.UserTag()) 45 c.Assert(err, jc.ErrorIsNil) 46 c.Assert(saved.Tag(), gc.Equals, user.Tag()) 47 c.Assert(saved.Name(), gc.Equals, user.Name()) 48 c.Assert(saved.DisplayName(), gc.Equals, user.DisplayName()) 49 c.Assert(saved.CreatedBy(), gc.Equals, user.CreatedBy()) 50 c.Assert(saved.DateCreated(), gc.Equals, user.DateCreated()) 51 c.Assert(saved.IsDisabled(), gc.Equals, user.IsDisabled()) 52 53 savedLastLogin, err := saved.LastLogin() 54 c.Assert(err, jc.Satisfies, state.IsNeverLoggedInError) 55 lastLogin, err := user.LastLogin() 56 c.Assert(err, jc.Satisfies, state.IsNeverLoggedInError) 57 c.Assert(savedLastLogin, gc.Equals, lastLogin) 58 } 59 60 func (s *factorySuite) TestMakeUserParams(c *gc.C) { 61 username := "bob" 62 displayName := "Bob the Builder" 63 creator := s.Factory.MakeUser(c, nil) 64 password := "sekrit" 65 user := s.Factory.MakeUser(c, &factory.UserParams{ 66 Name: username, 67 DisplayName: displayName, 68 Creator: creator.Tag(), 69 Password: password, 70 }) 71 c.Assert(user.IsDisabled(), jc.IsFalse) 72 c.Assert(user.Name(), gc.Equals, username) 73 c.Assert(user.DisplayName(), gc.Equals, displayName) 74 c.Assert(user.CreatedBy(), gc.Equals, creator.UserTag().Name()) 75 c.Assert(user.PasswordValid(password), jc.IsTrue) 76 77 saved, err := s.State.User(user.UserTag()) 78 c.Assert(err, jc.ErrorIsNil) 79 c.Assert(saved.Tag(), gc.Equals, user.Tag()) 80 c.Assert(saved.Name(), gc.Equals, user.Name()) 81 c.Assert(saved.DisplayName(), gc.Equals, user.DisplayName()) 82 c.Assert(saved.CreatedBy(), gc.Equals, user.CreatedBy()) 83 c.Assert(saved.DateCreated(), gc.Equals, user.DateCreated()) 84 c.Assert(saved.IsDisabled(), gc.Equals, user.IsDisabled()) 85 86 savedLastLogin, err := saved.LastLogin() 87 c.Assert(err, jc.Satisfies, state.IsNeverLoggedInError) 88 lastLogin, err := user.LastLogin() 89 c.Assert(err, jc.Satisfies, state.IsNeverLoggedInError) 90 c.Assert(savedLastLogin, gc.Equals, lastLogin) 91 92 _, err = s.State.ModelUser(user.UserTag()) 93 c.Assert(err, jc.ErrorIsNil) 94 } 95 96 func (s *factorySuite) TestMakeUserInvalidCreator(c *gc.C) { 97 invalidFunc := func() { 98 s.Factory.MakeUser(c, &factory.UserParams{ 99 Name: "bob", 100 DisplayName: "Bob", 101 Creator: names.NewMachineTag("0"), 102 Password: "bob", 103 }) 104 } 105 106 c.Assert(invalidFunc, gc.PanicMatches, `interface conversion: .*`) 107 saved, err := s.State.User(names.NewUserTag("bob")) 108 c.Assert(err, jc.Satisfies, errors.IsNotFound) 109 c.Assert(saved, gc.IsNil) 110 } 111 112 func (s *factorySuite) TestMakeUserNoModelUser(c *gc.C) { 113 username := "bob" 114 displayName := "Bob the Builder" 115 creator := names.NewLocalUserTag("eric") 116 password := "sekrit" 117 user := s.Factory.MakeUser(c, &factory.UserParams{ 118 Name: username, 119 DisplayName: displayName, 120 Creator: creator, 121 Password: password, 122 NoModelUser: true, 123 }) 124 125 _, err := s.State.User(user.UserTag()) 126 c.Assert(err, jc.ErrorIsNil) 127 _, err = s.State.ModelUser(user.UserTag()) 128 c.Assert(err, jc.Satisfies, errors.IsNotFound) 129 } 130 131 func (s *factorySuite) TestMakeModelUserNil(c *gc.C) { 132 modelUser := s.Factory.MakeModelUser(c, nil) 133 saved, err := s.State.ModelUser(modelUser.UserTag()) 134 c.Assert(err, jc.ErrorIsNil) 135 c.Assert(saved.ModelTag().Id(), gc.Equals, modelUser.ModelTag().Id()) 136 c.Assert(saved.UserName(), gc.Equals, modelUser.UserName()) 137 c.Assert(saved.DisplayName(), gc.Equals, modelUser.DisplayName()) 138 c.Assert(saved.CreatedBy(), gc.Equals, modelUser.CreatedBy()) 139 } 140 141 func (s *factorySuite) TestMakeModelUserPartialParams(c *gc.C) { 142 s.Factory.MakeUser(c, &factory.UserParams{Name: "foobar123", NoModelUser: true}) 143 modelUser := s.Factory.MakeModelUser(c, &factory.ModelUserParams{ 144 User: "foobar123"}) 145 146 saved, err := s.State.ModelUser(modelUser.UserTag()) 147 c.Assert(err, jc.ErrorIsNil) 148 c.Assert(saved.ModelTag().Id(), gc.Equals, modelUser.ModelTag().Id()) 149 c.Assert(saved.UserName(), gc.Equals, "foobar123@local") 150 c.Assert(saved.DisplayName(), gc.Equals, modelUser.DisplayName()) 151 c.Assert(saved.CreatedBy(), gc.Equals, modelUser.CreatedBy()) 152 } 153 154 func (s *factorySuite) TestMakeModelUserParams(c *gc.C) { 155 s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"}) 156 s.Factory.MakeUser(c, &factory.UserParams{ 157 Name: "foobar", 158 Creator: names.NewUserTag("createdby"), 159 NoModelUser: true, 160 }) 161 162 modelUser := s.Factory.MakeModelUser(c, &factory.ModelUserParams{ 163 User: "foobar", 164 CreatedBy: names.NewUserTag("createdby"), 165 DisplayName: "Foo Bar", 166 }) 167 168 saved, err := s.State.ModelUser(modelUser.UserTag()) 169 c.Assert(err, jc.ErrorIsNil) 170 c.Assert(saved.ModelTag().Id(), gc.Equals, modelUser.ModelTag().Id()) 171 c.Assert(saved.UserName(), gc.Equals, "foobar@local") 172 c.Assert(saved.CreatedBy(), gc.Equals, "createdby@local") 173 c.Assert(saved.DisplayName(), gc.Equals, "Foo Bar") 174 } 175 176 func (s *factorySuite) TestMakeModelUserInvalidCreatedBy(c *gc.C) { 177 invalidFunc := func() { 178 s.Factory.MakeModelUser(c, &factory.ModelUserParams{ 179 User: "bob", 180 CreatedBy: names.NewMachineTag("0"), 181 }) 182 } 183 184 c.Assert(invalidFunc, gc.PanicMatches, `interface conversion: .*`) 185 saved, err := s.State.ModelUser(names.NewLocalUserTag("bob")) 186 c.Assert(err, jc.Satisfies, errors.IsNotFound) 187 c.Assert(saved, gc.IsNil) 188 } 189 190 func (s *factorySuite) TestMakeModelUserNonLocalUser(c *gc.C) { 191 creator := s.Factory.MakeUser(c, &factory.UserParams{Name: "created-by"}) 192 modelUser := s.Factory.MakeModelUser(c, &factory.ModelUserParams{ 193 User: "foobar@ubuntuone", 194 DisplayName: "Foo Bar", 195 CreatedBy: creator.UserTag(), 196 }) 197 198 saved, err := s.State.ModelUser(modelUser.UserTag()) 199 c.Assert(err, jc.ErrorIsNil) 200 c.Assert(saved.ModelTag().Id(), gc.Equals, modelUser.ModelTag().Id()) 201 c.Assert(saved.UserName(), gc.Equals, "foobar@ubuntuone") 202 c.Assert(saved.DisplayName(), gc.Equals, "Foo Bar") 203 c.Assert(saved.CreatedBy(), gc.Equals, creator.UserTag().Canonical()) 204 } 205 206 func (s *factorySuite) TestMakeMachineNil(c *gc.C) { 207 machine, password := s.Factory.MakeMachineReturningPassword(c, nil) 208 c.Assert(machine, gc.NotNil) 209 210 saved, err := s.State.Machine(machine.Id()) 211 c.Assert(err, jc.ErrorIsNil) 212 213 c.Assert(saved.Series(), gc.Equals, machine.Series()) 214 c.Assert(saved.Id(), gc.Equals, machine.Id()) 215 c.Assert(saved.Series(), gc.Equals, machine.Series()) 216 c.Assert(saved.Tag(), gc.Equals, machine.Tag()) 217 c.Assert(saved.Life(), gc.Equals, machine.Life()) 218 c.Assert(saved.Jobs(), gc.DeepEquals, machine.Jobs()) 219 c.Assert(saved.PasswordValid(password), jc.IsTrue) 220 savedInstanceId, err := saved.InstanceId() 221 c.Assert(err, jc.ErrorIsNil) 222 machineInstanceId, err := machine.InstanceId() 223 c.Assert(err, jc.ErrorIsNil) 224 c.Assert(savedInstanceId, gc.Equals, machineInstanceId) 225 c.Assert(saved.Clean(), gc.Equals, machine.Clean()) 226 } 227 228 func (s *factorySuite) TestMakeMachine(c *gc.C) { 229 registry.RegisterEnvironStorageProviders("someprovider", provider.LoopProviderType) 230 series := "quantal" 231 jobs := []state.MachineJob{state.JobManageModel} 232 password, err := utils.RandomPassword() 233 c.Assert(err, jc.ErrorIsNil) 234 nonce := "some-nonce" 235 id := instance.Id("some-id") 236 volumes := []state.MachineVolumeParams{{Volume: state.VolumeParams{Size: 1024}}} 237 filesystems := []state.MachineFilesystemParams{{ 238 Filesystem: state.FilesystemParams{Pool: "loop", Size: 2048}, 239 }} 240 241 machine, pwd := s.Factory.MakeMachineReturningPassword(c, &factory.MachineParams{ 242 Series: series, 243 Jobs: jobs, 244 Password: password, 245 Nonce: nonce, 246 InstanceId: id, 247 Volumes: volumes, 248 Filesystems: filesystems, 249 }) 250 c.Assert(machine, gc.NotNil) 251 c.Assert(pwd, gc.Equals, password) 252 253 c.Assert(machine.Series(), gc.Equals, series) 254 c.Assert(machine.Jobs(), gc.DeepEquals, jobs) 255 machineInstanceId, err := machine.InstanceId() 256 c.Assert(err, jc.ErrorIsNil) 257 c.Assert(machineInstanceId, gc.Equals, id) 258 c.Assert(machine.CheckProvisioned(nonce), jc.IsTrue) 259 c.Assert(machine.PasswordValid(password), jc.IsTrue) 260 261 assertVolume := func(name string, size uint64) { 262 volume, err := s.State.Volume(names.NewVolumeTag(name)) 263 c.Assert(err, jc.ErrorIsNil) 264 volParams, ok := volume.Params() 265 c.Assert(ok, jc.IsTrue) 266 c.Assert(volParams, jc.DeepEquals, state.VolumeParams{Pool: "loop", Size: size}) 267 volAttachments, err := s.State.VolumeAttachments(volume.VolumeTag()) 268 c.Assert(err, jc.ErrorIsNil) 269 c.Assert(volAttachments, gc.HasLen, 1) 270 c.Assert(volAttachments[0].Machine(), gc.Equals, machine.Tag()) 271 } 272 assertVolume(machine.Id()+"/0", 2048) // backing the filesystem 273 assertVolume(machine.Id()+"/1", 1024) 274 275 filesystem, err := s.State.Filesystem(names.NewFilesystemTag(machine.Id() + "/0")) 276 c.Assert(err, jc.ErrorIsNil) 277 fsParams, ok := filesystem.Params() 278 c.Assert(ok, jc.IsTrue) 279 c.Assert(fsParams, jc.DeepEquals, state.FilesystemParams{Pool: "loop", Size: 2048}) 280 fsAttachments, err := s.State.MachineFilesystemAttachments(machine.Tag().(names.MachineTag)) 281 c.Assert(err, jc.ErrorIsNil) 282 c.Assert(fsAttachments, gc.HasLen, 1) 283 c.Assert(fsAttachments[0].Machine(), gc.Equals, machine.Tag()) 284 285 saved, err := s.State.Machine(machine.Id()) 286 c.Assert(err, jc.ErrorIsNil) 287 288 c.Assert(saved.Id(), gc.Equals, machine.Id()) 289 c.Assert(saved.Series(), gc.Equals, machine.Series()) 290 c.Assert(saved.Tag(), gc.Equals, machine.Tag()) 291 c.Assert(saved.Life(), gc.Equals, machine.Life()) 292 c.Assert(saved.Jobs(), gc.DeepEquals, machine.Jobs()) 293 savedInstanceId, err := saved.InstanceId() 294 c.Assert(err, jc.ErrorIsNil) 295 c.Assert(savedInstanceId, gc.Equals, machineInstanceId) 296 c.Assert(saved.Clean(), gc.Equals, machine.Clean()) 297 } 298 299 func (s *factorySuite) TestMakeCharmNil(c *gc.C) { 300 charm := s.Factory.MakeCharm(c, nil) 301 c.Assert(charm, gc.NotNil) 302 303 saved, err := s.State.Charm(charm.URL()) 304 c.Assert(err, jc.ErrorIsNil) 305 306 c.Assert(saved.URL(), gc.DeepEquals, charm.URL()) 307 c.Assert(saved.Meta(), gc.DeepEquals, charm.Meta()) 308 c.Assert(saved.StoragePath(), gc.Equals, charm.StoragePath()) 309 c.Assert(saved.BundleSha256(), gc.Equals, charm.BundleSha256()) 310 } 311 312 func (s *factorySuite) TestMakeCharm(c *gc.C) { 313 series := "quantal" 314 name := "wordpress" 315 revision := 13 316 url := fmt.Sprintf("cs:%s/%s-%d", series, name, revision) 317 ch := s.Factory.MakeCharm(c, &factory.CharmParams{ 318 Name: name, 319 URL: url, 320 }) 321 c.Assert(ch, gc.NotNil) 322 323 c.Assert(ch.URL(), gc.DeepEquals, charm.MustParseURL(url)) 324 325 saved, err := s.State.Charm(ch.URL()) 326 c.Assert(err, jc.ErrorIsNil) 327 328 c.Assert(saved.URL(), gc.DeepEquals, ch.URL()) 329 c.Assert(saved.Meta(), gc.DeepEquals, ch.Meta()) 330 c.Assert(saved.Meta().Name, gc.Equals, name) 331 c.Assert(saved.StoragePath(), gc.Equals, ch.StoragePath()) 332 c.Assert(saved.BundleSha256(), gc.Equals, ch.BundleSha256()) 333 } 334 335 func (s *factorySuite) TestMakeServiceNil(c *gc.C) { 336 service := s.Factory.MakeService(c, nil) 337 c.Assert(service, gc.NotNil) 338 339 saved, err := s.State.Service(service.Name()) 340 c.Assert(err, jc.ErrorIsNil) 341 342 c.Assert(saved.Name(), gc.Equals, service.Name()) 343 c.Assert(saved.Tag(), gc.Equals, service.Tag()) 344 c.Assert(saved.Life(), gc.Equals, service.Life()) 345 } 346 347 func (s *factorySuite) TestMakeService(c *gc.C) { 348 charm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "wordpress"}) 349 creator := s.Factory.MakeUser(c, &factory.UserParams{Name: "bill"}).Tag() 350 service := s.Factory.MakeService(c, &factory.ServiceParams{ 351 Charm: charm, 352 Creator: creator, 353 }) 354 c.Assert(service, gc.NotNil) 355 356 c.Assert(service.Name(), gc.Equals, "wordpress") 357 c.Assert(service.GetOwnerTag(), gc.Equals, creator.String()) 358 curl, _ := service.CharmURL() 359 c.Assert(curl, gc.DeepEquals, charm.URL()) 360 361 saved, err := s.State.Service(service.Name()) 362 c.Assert(err, jc.ErrorIsNil) 363 364 c.Assert(saved.Name(), gc.Equals, service.Name()) 365 c.Assert(saved.Tag(), gc.Equals, service.Tag()) 366 c.Assert(saved.Life(), gc.Equals, service.Life()) 367 } 368 369 func (s *factorySuite) TestMakeServiceInvalidCreator(c *gc.C) { 370 serviceName := "mysql" 371 invalidFunc := func() { 372 s.Factory.MakeService(c, &factory.ServiceParams{ 373 Name: serviceName, 374 Creator: names.NewMachineTag("0"), 375 }) 376 } 377 c.Assert(invalidFunc, gc.PanicMatches, `interface conversion: .*`) 378 saved, err := s.State.Service(serviceName) 379 c.Assert(err, jc.Satisfies, errors.IsNotFound) 380 c.Assert(saved, gc.IsNil) 381 } 382 383 func (s *factorySuite) TestMakeUnitNil(c *gc.C) { 384 unit := s.Factory.MakeUnit(c, nil) 385 c.Assert(unit, gc.NotNil) 386 387 saved, err := s.State.Unit(unit.Name()) 388 c.Assert(err, jc.ErrorIsNil) 389 390 c.Assert(saved.Name(), gc.Equals, unit.Name()) 391 c.Assert(saved.ServiceName(), gc.Equals, unit.ServiceName()) 392 c.Assert(saved.Series(), gc.Equals, unit.Series()) 393 c.Assert(saved.Life(), gc.Equals, unit.Life()) 394 } 395 396 func (s *factorySuite) TestMakeUnit(c *gc.C) { 397 service := s.Factory.MakeService(c, nil) 398 unit := s.Factory.MakeUnit(c, &factory.UnitParams{ 399 Service: service, 400 SetCharmURL: true, 401 }) 402 c.Assert(unit, gc.NotNil) 403 404 c.Assert(unit.ServiceName(), gc.Equals, service.Name()) 405 406 saved, err := s.State.Unit(unit.Name()) 407 c.Assert(err, jc.ErrorIsNil) 408 409 c.Assert(saved.Name(), gc.Equals, unit.Name()) 410 c.Assert(saved.ServiceName(), gc.Equals, unit.ServiceName()) 411 c.Assert(saved.Series(), gc.Equals, unit.Series()) 412 c.Assert(saved.Life(), gc.Equals, unit.Life()) 413 414 serviceCharmURL, _ := service.CharmURL() 415 unitCharmURL, _ := saved.CharmURL() 416 c.Assert(unitCharmURL, gc.DeepEquals, serviceCharmURL) 417 } 418 419 func (s *factorySuite) TestMakeRelationNil(c *gc.C) { 420 relation := s.Factory.MakeRelation(c, nil) 421 c.Assert(relation, gc.NotNil) 422 423 saved, err := s.State.Relation(relation.Id()) 424 c.Assert(err, jc.ErrorIsNil) 425 426 c.Assert(saved.Id(), gc.Equals, relation.Id()) 427 c.Assert(saved.Tag(), gc.Equals, relation.Tag()) 428 c.Assert(saved.Life(), gc.Equals, relation.Life()) 429 c.Assert(saved.Endpoints(), gc.DeepEquals, relation.Endpoints()) 430 } 431 432 func (s *factorySuite) TestMakeRelation(c *gc.C) { 433 s1 := s.Factory.MakeService(c, &factory.ServiceParams{ 434 Name: "service1", 435 Charm: s.Factory.MakeCharm(c, &factory.CharmParams{ 436 Name: "wordpress", 437 }), 438 }) 439 e1, err := s1.Endpoint("db") 440 c.Assert(err, jc.ErrorIsNil) 441 442 s2 := s.Factory.MakeService(c, &factory.ServiceParams{ 443 Name: "service2", 444 Charm: s.Factory.MakeCharm(c, &factory.CharmParams{ 445 Name: "mysql", 446 }), 447 }) 448 e2, err := s2.Endpoint("server") 449 c.Assert(err, jc.ErrorIsNil) 450 451 relation := s.Factory.MakeRelation(c, &factory.RelationParams{ 452 Endpoints: []state.Endpoint{e1, e2}, 453 }) 454 c.Assert(relation, gc.NotNil) 455 456 saved, err := s.State.Relation(relation.Id()) 457 c.Assert(err, jc.ErrorIsNil) 458 459 c.Assert(saved.Id(), gc.Equals, relation.Id()) 460 c.Assert(saved.Tag(), gc.Equals, relation.Tag()) 461 c.Assert(saved.Life(), gc.Equals, relation.Life()) 462 c.Assert(saved.Endpoints(), gc.DeepEquals, relation.Endpoints()) 463 } 464 465 func (s *factorySuite) TestMakeMetricNil(c *gc.C) { 466 metric := s.Factory.MakeMetric(c, nil) 467 c.Assert(metric, gc.NotNil) 468 469 saved, err := s.State.MetricBatch(metric.UUID()) 470 c.Assert(err, jc.ErrorIsNil) 471 472 c.Assert(saved.UUID(), gc.Equals, metric.UUID()) 473 c.Assert(saved.Unit(), gc.Equals, metric.Unit()) 474 c.Assert(saved.Sent(), gc.Equals, metric.Sent()) 475 c.Assert(saved.CharmURL(), gc.Equals, metric.CharmURL()) 476 c.Assert(saved.Sent(), gc.Equals, metric.Sent()) 477 c.Assert(saved.Metrics(), gc.HasLen, 1) 478 c.Assert(saved.Metrics()[0].Key, gc.Equals, metric.Metrics()[0].Key) 479 c.Assert(saved.Metrics()[0].Value, gc.Equals, metric.Metrics()[0].Value) 480 c.Assert(saved.Metrics()[0].Time.Equal(metric.Metrics()[0].Time), jc.IsTrue) 481 } 482 483 func (s *factorySuite) TestMakeMetric(c *gc.C) { 484 now := time.Now().Round(time.Second).UTC() 485 meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "cs:quantal/metered"}) 486 meteredService := s.Factory.MakeService(c, &factory.ServiceParams{Charm: meteredCharm}) 487 unit := s.Factory.MakeUnit(c, &factory.UnitParams{Service: meteredService, SetCharmURL: true}) 488 metric := s.Factory.MakeMetric(c, &factory.MetricParams{ 489 Unit: unit, 490 Time: &now, 491 Sent: true, 492 Metrics: []state.Metric{{"pings", "1", now}}, 493 }) 494 c.Assert(metric, gc.NotNil) 495 496 saved, err := s.State.MetricBatch(metric.UUID()) 497 c.Assert(err, jc.ErrorIsNil) 498 499 c.Assert(saved.UUID(), gc.Equals, metric.UUID()) 500 c.Assert(saved.Unit(), gc.Equals, metric.Unit()) 501 c.Assert(saved.CharmURL(), gc.Equals, metric.CharmURL()) 502 c.Assert(metric.Sent(), jc.IsTrue) 503 c.Assert(saved.Sent(), jc.IsTrue) 504 c.Assert(saved.Metrics(), gc.HasLen, 1) 505 c.Assert(saved.Metrics()[0].Key, gc.Equals, "pings") 506 c.Assert(saved.Metrics()[0].Value, gc.Equals, "1") 507 c.Assert(saved.Metrics()[0].Time.Equal(now), jc.IsTrue) 508 } 509 510 func (s *factorySuite) TestMakeModelNil(c *gc.C) { 511 st := s.Factory.MakeModel(c, nil) 512 defer st.Close() 513 514 env, err := st.Model() 515 c.Assert(err, jc.ErrorIsNil) 516 re := regexp.MustCompile(`^testenv-\d+$`) 517 c.Assert(re.MatchString(env.Name()), jc.IsTrue) 518 c.Assert(env.UUID() == s.State.ModelUUID(), jc.IsFalse) 519 origEnv, err := s.State.Model() 520 c.Assert(err, jc.ErrorIsNil) 521 c.Assert(env.Owner(), gc.Equals, origEnv.Owner()) 522 523 cfg, err := st.ModelConfig() 524 c.Assert(err, jc.ErrorIsNil) 525 c.Assert(cfg.AllAttrs()["default-series"], gc.Equals, "xenial") 526 } 527 528 func (s *factorySuite) TestMakeModel(c *gc.C) { 529 owner := s.Factory.MakeUser(c, &factory.UserParams{ 530 Name: "owner", 531 }) 532 params := &factory.ModelParams{ 533 Name: "foo", 534 Owner: owner.UserTag(), 535 ConfigAttrs: testing.Attrs{"default-series": "precise"}, 536 } 537 538 st := s.Factory.MakeModel(c, params) 539 defer st.Close() 540 541 env, err := st.Model() 542 c.Assert(err, jc.ErrorIsNil) 543 c.Assert(env.Name(), gc.Equals, "foo") 544 c.Assert(env.UUID() == s.State.ModelUUID(), jc.IsFalse) 545 c.Assert(env.Owner(), gc.Equals, owner.UserTag()) 546 547 cfg, err := st.ModelConfig() 548 c.Assert(err, jc.ErrorIsNil) 549 c.Assert(cfg.AllAttrs()["default-series"], gc.Equals, "precise") 550 }