~rogpeppe/juju-core/256-more-status

« back to all changes in this revision

Viewing changes to juju/conn_test.go

statecmd: don't use juju.Conn unnecessarily

There's an associated cost when the API uses juju.Conn,
so we want to avoid it when reasonable.
This change moves some operations from juju into
state because they don't require juju.Conn's associated
Environ.

R=fwereade, dimitern
CC=
https://codereview.appspot.com/7945044

Show diffs side-by-side

added added

removed removed

Lines of Context:
387
387
        c.Assert(id0, Not(Equals), id1)
388
388
}
389
389
 
390
 
func (s *ConnSuite) TestDestroyPrincipalUnits(c *C) {
391
 
        // Create 5 principal units.
392
 
        curl := coretesting.Charms.ClonedURL(s.repo.Path, "series", "wordpress")
393
 
        sch, err := s.conn.PutCharm(curl, s.repo, false)
394
 
        wordpress, err := s.conn.State.AddService("wordpress", sch)
395
 
        c.Assert(err, IsNil)
396
 
        for i := 0; i < 5; i++ {
397
 
                _, err = wordpress.AddUnit()
398
 
                c.Assert(err, IsNil)
399
 
        }
400
 
 
401
 
        // Destroy 2 of them; check they become Dying.
402
 
        err = s.conn.DestroyUnits("wordpress/0", "wordpress/1")
403
 
        c.Assert(err, IsNil)
404
 
        s.assertUnitLife(c, "wordpress/0", state.Dying)
405
 
        s.assertUnitLife(c, "wordpress/1", state.Dying)
406
 
 
407
 
        // Try to destroy an Alive one and a Dying one; check
408
 
        // it destroys the Alive one and ignores the Dying one.
409
 
        err = s.conn.DestroyUnits("wordpress/2", "wordpress/0")
410
 
        c.Assert(err, IsNil)
411
 
        s.assertUnitLife(c, "wordpress/2", state.Dying)
412
 
 
413
 
        // Try to destroy an Alive one along with a nonexistent one; check that
414
 
        // the valid instruction is followed but the invalid one is warned about.
415
 
        err = s.conn.DestroyUnits("boojum/123", "wordpress/3")
416
 
        c.Assert(err, ErrorMatches, `some units were not destroyed: unit "boojum/123" does not exist`)
417
 
        s.assertUnitLife(c, "wordpress/3", state.Dying)
418
 
 
419
 
        // Make one Dead, and destroy an Alive one alongside it; check no errors.
420
 
        wp0, err := s.conn.State.Unit("wordpress/0")
421
 
        c.Assert(err, IsNil)
422
 
        err = wp0.EnsureDead()
423
 
        c.Assert(err, IsNil)
424
 
        err = s.conn.DestroyUnits("wordpress/0", "wordpress/4")
425
 
        c.Assert(err, IsNil)
426
 
        s.assertUnitLife(c, "wordpress/0", state.Dead)
427
 
        s.assertUnitLife(c, "wordpress/4", state.Dying)
428
 
}
429
 
 
430
 
func (s *ConnSuite) TestDestroySubordinateUnits(c *C) {
431
 
        // Create a principal and a subordinate.
432
 
        wpcurl := coretesting.Charms.ClonedURL(s.repo.Path, "series", "wordpress")
433
 
        wpsch, err := s.conn.PutCharm(wpcurl, s.repo, false)
434
 
        wordpress, err := s.conn.State.AddService("wordpress", wpsch)
435
 
        c.Assert(err, IsNil)
436
 
        wordpress0, err := wordpress.AddUnit()
437
 
        c.Assert(err, IsNil)
438
 
        lgcurl := coretesting.Charms.ClonedURL(s.repo.Path, "series", "logging")
439
 
        lgsch, err := s.conn.PutCharm(lgcurl, s.repo, false)
440
 
        _, err = s.conn.State.AddService("logging", lgsch)
441
 
        c.Assert(err, IsNil)
442
 
        eps, err := s.conn.State.InferEndpoints([]string{"logging", "wordpress"})
443
 
        c.Assert(err, IsNil)
444
 
        rel, err := s.conn.State.AddRelation(eps...)
445
 
        c.Assert(err, IsNil)
446
 
        ru, err := rel.Unit(wordpress0)
447
 
        c.Assert(err, IsNil)
448
 
        err = ru.EnterScope(nil)
449
 
        c.Assert(err, IsNil)
450
 
 
451
 
        // Try to destroy the subordinate alone; check it fails.
452
 
        err = s.conn.DestroyUnits("logging/0")
453
 
        c.Assert(err, ErrorMatches, `no units were destroyed: unit "logging/0" is a subordinate`)
454
 
        s.assertUnitLife(c, "logging/0", state.Alive)
455
 
 
456
 
        // Try to destroy the principal and the subordinate together; check it warns
457
 
        // about the subordinate, but destroys the one it can. (The principal unit
458
 
        // agent will be resposible for destroying the subordinate.)
459
 
        err = s.conn.DestroyUnits("wordpress/0", "logging/0")
460
 
        c.Assert(err, ErrorMatches, `some units were not destroyed: unit "logging/0" is a subordinate`)
461
 
        s.assertUnitLife(c, "wordpress/0", state.Dying)
462
 
        s.assertUnitLife(c, "logging/0", state.Alive)
463
 
}
464
 
 
465
 
func (s *ConnSuite) assertUnitLife(c *C, name string, life state.Life) {
466
 
        unit, err := s.conn.State.Unit(name)
467
 
        c.Assert(err, IsNil)
468
 
        c.Assert(unit.Refresh(), IsNil)
469
 
        c.Assert(unit.Life(), Equals, life)
470
 
}
471
 
 
472
 
func (s *ConnSuite) TestDestroyMachines(c *C) {
473
 
        m0, err := s.conn.State.AddMachine("series", state.JobManageEnviron)
474
 
        c.Assert(err, IsNil)
475
 
        m1, err := s.conn.State.AddMachine("series", state.JobHostUnits)
476
 
        c.Assert(err, IsNil)
477
 
        m2, err := s.conn.State.AddMachine("series", state.JobHostUnits)
478
 
        c.Assert(err, IsNil)
479
 
 
480
 
        curl := coretesting.Charms.ClonedURL(s.repo.Path, "series", "wordpress")
481
 
        sch, err := s.conn.PutCharm(curl, s.repo, false)
482
 
        wordpress, err := s.conn.State.AddService("wordpress", sch)
483
 
        c.Assert(err, IsNil)
484
 
        u, err := wordpress.AddUnit()
485
 
        c.Assert(err, IsNil)
486
 
        err = u.AssignToMachine(m1)
487
 
        c.Assert(err, IsNil)
488
 
 
489
 
        err = s.conn.DestroyMachines("0", "1", "2")
490
 
        c.Assert(err, ErrorMatches, `some machines were not destroyed: machine 0 is required by the environment; machine 1 has unit "wordpress/0" assigned`)
491
 
        assertLife := func(m *state.Machine, life state.Life) {
492
 
                err := m.Refresh()
493
 
                c.Assert(err, IsNil)
494
 
                c.Assert(m.Life(), Equals, life)
495
 
        }
496
 
        assertLife(m0, state.Alive)
497
 
        assertLife(m1, state.Alive)
498
 
        assertLife(m2, state.Dying)
499
 
 
500
 
        err = u.UnassignFromMachine()
501
 
        c.Assert(err, IsNil)
502
 
        err = s.conn.DestroyMachines("0", "1", "2")
503
 
        c.Assert(err, ErrorMatches, `some machines were not destroyed: machine 0 is required by the environment`)
504
 
        assertLife(m0, state.Alive)
505
 
        assertLife(m1, state.Dying)
506
 
        assertLife(m2, state.Dying)
507
 
}
508
 
 
509
390
func (s *ConnSuite) TestResolved(c *C) {
510
391
        curl := coretesting.Charms.ClonedURL(s.repo.Path, "series", "riak")
511
392
        sch, err := s.conn.PutCharm(curl, s.repo, false)