state: drop kill and Die method names

state/service_test.go

 package state_test
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/state"
         "sort"
         "time"
 )
@@ skipping 15 matching lines @@
 }
 
 func (s *ServiceSuite) TestServiceCharm(c *C) {
         ch, force, err := s.service.Charm()
         c.Assert(err, IsNil)
         c.Assert(ch.URL(), DeepEquals, s.charm.URL())
         c.Assert(force, Equals, false)
 
         // TODO: SetCharm must validate the change (version, relations, etc)
         wp := s.AddTestingCharm(c, "wordpress")
+        err = s.service.SetCharm(wp, true)
+        ch, force, err1 := s.service.Charm()
+        c.Assert(err1, IsNil)
+        c.Assert(ch.URL(), DeepEquals, wp.URL())
+        c.Assert(force, Equals, true)
 
         testWhenDying(c, s.service, notAliveErr, notAliveErr, func() error {
-                err := s.service.SetCharm(wp, true)
-                if err == nil {
-                        ch, force, err1 := s.service.Charm()
-                        c.Assert(err1, IsNil)
-                        c.Assert(ch.URL(), DeepEquals, wp.URL())
-                        c.Assert(force, Equals, true)
-                }
-                return err
+                return s.service.SetCharm(wp, true)
         })
 }
 
 func (s *ServiceSuite) TestServiceRefesh(c *C) {
         s1, err := s.State.Service(s.service.Name())
         c.Assert(err, IsNil)
 
         err = s.service.SetCharm(s.charm, true)
         c.Assert(err, IsNil)
 
@@ skipping 61 matching lines @@
         // not alive.
         testWhenDying(c, principalUnit, errPat, errPat, func() error {
                 _, err := loggingService.AddUnitSubordinateTo(principalUnit)
                 return err
         })
 
         // Test that AddUnitSubordinateTo fails when the service is
         // not alive.
         principalUnit, err = principalService.AddUnit()
         c.Assert(err, IsNil)
+        removeAllUnits(c, loggingService)
         testWhenDying(c, loggingService, errPat, errPat, func() error {
                 _, err := loggingService.AddUnitSubordinateTo(principalUnit)
                 return err
         })
 }
 
 func (s *ServiceSuite) TestAddUnit(c *C) {
+        c.Assert(s.service.UnitCount(), Equals, 0)
         // Check that principal units can be added on their own.
         unitZero, err := s.service.AddUnit()
         c.Assert(err, IsNil)
+        c.Assert(s.service.UnitCount(), Equals, 1)
         c.Assert(unitZero.Name(), Equals, "mysql/0")
         principal := unitZero.IsPrincipal()
         c.Assert(principal, Equals, true)
         unitOne, err := s.service.AddUnit()
         c.Assert(err, IsNil)
         c.Assert(unitOne.Name(), Equals, "mysql/1")
         principal = unitOne.IsPrincipal()
         c.Assert(principal, Equals, true)
 
         // Check that principal units cannot be added to principal units.
@@ skipping 24 matching lines @@
         c.Assert(id, Equals, m.Id())
 
         // Check that subordinate units must be added to other units.
         _, err = logging.AddUnit()
         c.Assert(err, ErrorMatches, `cannot add unit to service "logging": unit is a subordinate`)
 
         // Check that subordinate units cannnot be added to subordinate units.
         _, err = logging.AddUnitSubordinateTo(subZero)
         c.Assert(err, ErrorMatches, `cannot add unit to service "logging" as a subordinate of "logging/0": unit is not a principal`)
 
+        removeAllUnits(c, s.service)
         const errPat = ".*: service is not alive"
         testWhenDying(c, s.service, errPat, errPat, func() error {
                 _, err = s.service.AddUnit()
                 return err
         })
 }
 
 func (s *ServiceSuite) TestReadUnit(c *C) {
         _, err := s.service.AddUnit()
         c.Assert(err, IsNil)
@@ skipping 36 matching lines @@
         // BUG(aram): use error strings from state.
         unit, err = s.service.Unit("wordpress/0")
         c.Assert(err, ErrorMatches, `cannot get unit "wordpress/0" from service "mysql": .*`)
 
         units, err := s.service.AllUnits()
         c.Assert(err, IsNil)
         c.Assert(sortedUnitNames(units), DeepEquals, []string{"mysql/0", "mysql/1"})
 }
 
 func (s *ServiceSuite) TestReadUnitWhenDying(c *C) {
-        // Test that we can read units from the service whatever
-        // their life state.
-        _, err := s.service.AddUnit()
+        // Test that we can still read units when the service is Dying...
+        unit, err := s.service.AddUnit()
         c.Assert(err, IsNil)
-        checkAllUnits := func() error {
-                // Check that retrieving all units works.
+        err = s.service.EnsureDying()
+        c.Assert(err, IsNil)
+        _, err = s.service.AllUnits()
+        c.Assert(err, IsNil)
+        _, err = s.service.Unit("mysql/0")
+        c.Assert(err, IsNil)
+
+        // ...and when those units are Dying or Dead...

[niemeyer, 2012/09/21 16:57:37]

Doesn't that cover also what's done above?

[fwereade, 2012/09/21 17:43:48]

No :).

+        testWhenDying(c, unit, noErr, noErr, func() error {
                 _, err := s.service.AllUnits()
                 return err
-        }
-        checkUnit := func() error {
+        }, func() error {
                 _, err := s.service.Unit("mysql/0")
                 return err
-        }
+        })
 
-        testWhenDying(c, s.service, noErr, noErr, checkAllUnits, checkUnit)
-
-        unit0, err := s.service.Unit("mysql/0")
+        // ...and that we can even read the empty list of units once the
+        // service itself is Dead.
+        removeAllUnits(c, s.service)
+        err = s.service.EnsureDead()
+        _, err = s.service.AllUnits()
         c.Assert(err, IsNil)
-        testWhenDying(c, unit0, noErr, noErr, checkAllUnits, checkUnit)
 }
 
 func (s *ServiceSuite) TestRemoveUnit(c *C) {
         _, err := s.service.AddUnit()
         c.Assert(err, IsNil)
         _, err = s.service.AddUnit()
         c.Assert(err, IsNil)
+        c.Assert(s.service.UnitCount(), Equals, 2)
 
         // Check that removing a unit works.
         unit, err := s.service.Unit("mysql/0")
         c.Assert(err, IsNil)
         err = s.service.RemoveUnit(unit)
         c.Assert(err, ErrorMatches, `cannot remove unit "mysql/0": unit is not dead`)
-        err = unit.Die()
+        err = unit.EnsureDead()
         c.Assert(err, IsNil)
         err = s.service.RemoveUnit(unit)
         c.Assert(err, IsNil)
 
         units, err := s.service.AllUnits()
         c.Assert(err, IsNil)
         c.Assert(units, HasLen, 1)
         c.Assert(units[0].Name(), Equals, "mysql/1")
+        c.Assert(s.service.UnitCount(), Equals, 1)
 
         err = s.service.RemoveUnit(unit)
         c.Assert(err, IsNil)
+        c.Assert(s.service.UnitCount(), Equals, 1)
 }
 
+func (s *ServiceSuite) TestLifeWithUnits(c *C) {
+        unit, err := s.service.AddUnit()
+        c.Assert(err, IsNil)
+        err = s.service.EnsureDying()
+        c.Assert(err, IsNil)
+        err = s.service.EnsureDead()
+        c.Assert(err, ErrorMatches, `cannot set life to Dead for service "mysql": service still has units`)
+        err = unit.EnsureDead()
+        c.Assert(err, IsNil)

[niemeyer, 2012/09/21 16:57:37]

One more time here?

err = s.service.EnsureDead()
c.Assert(err, ErrorMatches, `cannot set life to Dead for service "mysql":
service still has units`)

[fwereade, 2012/09/21 17:43:48]

Done.

+        err = s.service.RemoveUnit(unit)
+        c.Assert(err, IsNil)
+        err = s.service.EnsureDead()
+        c.Assert(err, IsNil)
+}
+
 func (s *ServiceSuite) TestReadUnitWithChangingState(c *C) {
         // Check that reading a unit after removing the service
         // fails nicely.
         err := s.State.RemoveService(s.service)
         c.Assert(err, ErrorMatches, `cannot remove service "mysql": service is not dead`)
-        err = s.service.Die()
+        err = s.service.EnsureDead()
         c.Assert(err, IsNil)
         err = s.State.RemoveService(s.service)
         c.Assert(err, IsNil)
         _, err = s.State.Unit("mysql/0")
         c.Assert(err, ErrorMatches, `cannot get unit "mysql/0": not found`)
 }
 
 func (s *ServiceSuite) TestServiceConfig(c *C) {
         env, err := s.service.Config()
         c.Assert(err, IsNil)
@@ skipping 42 matching lines @@
                         c.Assert(err, IsNil)
                         _, err = service.AddUnit()
                         c.Assert(err, IsNil)
                 },
                 added: []string{"mysql/2", "mysql/3"},
         },
         {
                 test: func(c *C, s *state.State, service *state.Service) {
                         unit3, err := service.Unit("mysql/3")
                         c.Assert(err, IsNil)
-                        err = unit3.Die()
+                        err = unit3.EnsureDead()
                         c.Assert(err, IsNil)
                         err = service.RemoveUnit(unit3)
                         c.Assert(err, IsNil)
                 },
                 removed: []string{"mysql/3"},
         },
         {
                 test: func(c *C, s *state.State, service *state.Service) {
                         unit0, err := service.Unit("mysql/0")
                         c.Assert(err, IsNil)
-                        err = unit0.Die()
+                        err = unit0.EnsureDead()
                         c.Assert(err, IsNil)
                         err = service.RemoveUnit(unit0)
                         c.Assert(err, IsNil)
                         unit2, err := service.Unit("mysql/2")
                         c.Assert(err, IsNil)
-                        err = unit2.Die()
+                        err = unit2.EnsureDead()
                         c.Assert(err, IsNil)
                         err = service.RemoveUnit(unit2)
                         c.Assert(err, IsNil)
                 },
                 removed: []string{"mysql/0", "mysql/2"},
         },
         {
                 test: func(c *C, s *state.State, service *state.Service) {
                         _, err := service.AddUnit()
                         c.Assert(err, IsNil)
                         unit1, err := service.Unit("mysql/1")
                         c.Assert(err, IsNil)
-                        err = unit1.Die()
+                        err = unit1.EnsureDead()
                         c.Assert(err, IsNil)
                         err = service.RemoveUnit(unit1)
                         c.Assert(err, IsNil)
                 },
                 added:   []string{"mysql/4"},
                 removed: []string{"mysql/1"},
         },
         {
                 test: func(c *C, s *state.State, service *state.Service) {
                         units := [20]*state.Unit{}
                         var err error
                         for i := 0; i < len(units); i++ {
                                 units[i], err = service.AddUnit()
                                 c.Assert(err, IsNil)
                         }
                         for i := 10; i < len(units); i++ {
-                                err = units[i].Die()
+                                err = units[i].EnsureDead()
                                 c.Assert(err, IsNil)
                                 err = service.RemoveUnit(units[i])
                                 c.Assert(err, IsNil)
                         }
                 },
                 added: []string{"mysql/10", "mysql/11", "mysql/12", "mysql/13", "mysql/14", "mysql/5", "mysql/6", "mysql/7", "mysql/8", "mysql/9"},
         },
         {
                 test: func(c *C, s *state.State, service *state.Service) {
                         _, err := service.AddUnit()
                         c.Assert(err, IsNil)
                         unit9, err := service.Unit("mysql/9")
                         c.Assert(err, IsNil)
-                        err = unit9.Die()
+                        err = unit9.EnsureDead()
                         c.Assert(err, IsNil)
                         err = service.RemoveUnit(unit9)
                         c.Assert(err, IsNil)
                 },
                 added:   []string{"mysql/25"},
                 removed: []string{"mysql/9"},
         },
         {
                 test: func(c *C, s *state.State, service *state.Service) {
                         _, err := service.AddUnit()
                         c.Assert(err, IsNil)
                         _, err = service.AddUnit()
                         c.Assert(err, IsNil)
                         ch, _, err := service.Charm()
                         c.Assert(err, IsNil)
                         svc, err := s.AddService("bacon", ch)
                         c.Assert(err, IsNil)
                         _, err = svc.AddUnit()
                         c.Assert(err, IsNil)
                         _, err = svc.AddUnit()
                         c.Assert(err, IsNil)
                         unit14, err := service.Unit("mysql/14")
                         c.Assert(err, IsNil)
-                        err = unit14.Die()
+                        err = unit14.EnsureDead()
                         c.Assert(err, IsNil)
                         err = service.RemoveUnit(unit14)
                         c.Assert(err, IsNil)
                 },
                 added:   []string{"mysql/26", "mysql/27"},
                 removed: []string{"mysql/14"},
         },
 }
 
 func (s *ServiceSuite) TestWatchUnits(c *C) {
@@ skipping 125 matching lines @@
         // Add another relation; check change.
         wp2ep := state.RelationEndpoint{"wp2", "ifce", "baz", state.RoleRequirer, charm.ScopeGlobal}
         _, err = s.State.AddRelation(mysqlep, wp2ep)
         c.Assert(err, IsNil)
         s.State.StartSync()
         assertChange([]int{1}, nil)
         assertNoChange()
 
         s.State.StartSync()
         // Remove a relation; check change.
-        err = rel.Die()
+        err = rel.EnsureDead()
         c.Assert(err, IsNil)
         err = s.State.RemoveRelation(rel)
         c.Assert(err, IsNil)
         s.State.StartSync()
         assertChange(nil, []int{0})
 
         // Stop watcher; check change chan is closed.
         err = relationsWatcher.Stop()
         c.Assert(err, IsNil)
         assertClosed := func() {
@@ skipping 40 matching lines @@
         var err error
         mysqlep := state.RelationEndpoint{"mysql", "ifce", "foo", state.RoleProvider, charm.ScopeGlobal}
 
         for i := 0; i < 5; i++ {
                 _, err := s.State.AddService("wp"+fmt.Sprint(i), s.charm)
                 c.Assert(err, IsNil)
                 endpoints[i] = state.RelationEndpoint{"wp" + fmt.Sprint(i), "ifce", "spam" + fmt.Sprint(i), state.RoleRequirer, charm.ScopeGlobal}
                 relations[i], err = s.State.AddRelation(mysqlep, endpoints[i])
                 c.Assert(err, IsNil)
         }
-        err = relations[4].Die()
+        err = relations[4].EnsureDead()
         c.Assert(err, IsNil)
         err = s.State.RemoveRelation(relations[4])
         c.Assert(err, IsNil)
         relations[4] = nil
         want = &state.RelationsChange{Added: relations[:4]}
         s.State.StartSync()
         got := &state.RelationsChange{}
         for {
                 select {
                 case new, ok := <-relationsWatcher.Changes():
                         c.Assert(ok, Equals, true)
                         addRelationChanges(got, new)
                         if moreRelationsRequired(got, want) {
                                 continue
                         }
                         c.Assert(got, DeepEquals, want)
                 case <-time.After(500 * time.Millisecond):
                         c.Fatalf("didn't get change: %#v", want)
                 }
                 break
         }
 
         for i := 0; i < 4; i++ {
-                err = relations[i].Die()
+                err = relations[i].EnsureDead()
                 c.Assert(err, IsNil)
         }
         want.Removed = relations[:4]
         for i := 0; i < 4; i++ {
                 err = s.State.RemoveRelation(relations[i])
                 c.Assert(err, IsNil)
         }
         _, err = s.State.AddService("wp", s.charm)
         ep := state.RelationEndpoint{"wp", "ifce", "spam", state.RoleRequirer, charm.ScopeGlobal}
         rel, err := s.State.AddRelation(mysqlep, ep)
@@ skipping 26 matching lines @@
 
 func moreRelationsRequired(got, want *state.RelationsChange) bool {
         return len(got.Added)+len(got.Removed) < len(want.Added)+len(want.Removed)
 }
 
 func addRelationChanges(changes *state.RelationsChange, more *state.RelationsChange) {
         changes.Added = append(changes.Added, more.Added...)
         changes.Removed = append(changes.Removed, more.Removed...)
 }
 
+func removeAllUnits(c *C, s *state.Service) {
+        us, err := s.AllUnits()
+        c.Assert(err, IsNil)
+        for _, u := range us {
+                err = u.EnsureDead()
+                c.Assert(err, IsNil)
+                err = s.RemoveUnit(u)
+                c.Assert(err, IsNil)
+        }
+}
+
 var watchServiceTests = []struct {
         test    func(m *state.Service) error
         Exposed bool
         Life    state.Life
 }{
         {
                 test: func(s *state.Service) error {
                         return s.SetExposed()
                 },
                 Exposed: true,
         },
         {
                 test: func(s *state.Service) error {
                         return s.ClearExposed()
                 },
                 Exposed: false,
         },
         {
                 test: func(s *state.Service) error {
-                        return s.Kill()
+                        return s.EnsureDying()
                 },
                 Life: state.Dying,
         },
 }
 
 func (s *ServiceSuite) TestWatchService(c *C) {
         w := s.service.Watch()
         defer func() {
                 c.Assert(w.Stop(), IsNil)
         }()
@@ skipping 24 matching lines @@
                 case <-time.After(500 * time.Millisecond):
                         c.Fatalf("did not get change: %v %v", test.Exposed, test.Life)
                 }
         }
         select {
         case got := <-w.Changes():
                 c.Fatalf("got unexpected change: %#v", got)
         case <-time.After(100 * time.Millisecond):
         }
 }