uniter, state: handle upgrades better

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 46 matching lines @@
 func jujuInfoEp(serviceName string) state.Endpoint {
         return state.Endpoint{
                 ServiceName:   serviceName,
                 Interface:     "juju-info",
                 RelationName:  "juju-info",
                 RelationRole:  state.RoleProvider,
                 RelationScope: charm.ScopeGlobal,
         }
 }
 
+func (s *ServiceSuite) TestEntityName(c *C) {
+        c.Assert(s.mysql.EntityName(), Equals, "service-mysql")
+}
+
 func (s *ServiceSuite) TestMysqlEndpoints(c *C) {
         _, err := s.mysql.Endpoint("mysql")
         c.Assert(err, ErrorMatches, `service "mysql" has no "mysql" relation`)
 
         jiEP, err := s.mysql.Endpoint("juju-info")
         c.Assert(err, IsNil)
         c.Assert(jiEP, DeepEquals, jujuInfoEp("mysql"))
 
         serverEP, err := s.mysql.Endpoint("server")
         c.Assert(err, IsNil)
@@ skipping 317 matching lines @@
                 _, err := s.mysql.Unit("mysql/0")
                 return err
         })
 
         // ...and even, in a very limited way, when the service itself is removed.
         removeAllUnits(c, s.mysql)
         _, err = s.mysql.AllUnits()
         c.Assert(err, IsNil)
 }
 
-func (s *ServiceSuite) TestLifeWithUnits(c *C) {
+func (s *ServiceSuite) TestDestroySimple(c *C) {
+        err := s.mysql.Destroy()
+        c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+        err = s.mysql.Refresh()
+        c.Assert(state.IsNotFound(err), Equals, true)
+}
+
+func (s *ServiceSuite) TestDestroyStillHasUnits(c *C) {
         unit, err := s.mysql.AddUnit()
         c.Assert(err, IsNil)
         err = s.mysql.Destroy()
         c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+
         err = unit.EnsureDead()
         c.Assert(err, IsNil)
         err = s.mysql.Refresh()
         c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+
         err = unit.Remove()
         c.Assert(err, IsNil)
         err = s.mysql.Refresh()
         c.Assert(state.IsNotFound(err), Equals, true)
 }
 
-func (s *ServiceSuite) TestLifeWithRemovableRelations(c *C) {
+func (s *ServiceSuite) TestDestroyOnceHadUnits(c *C) {
+        unit, err := s.mysql.AddUnit()
+        c.Assert(err, IsNil)
+        err = unit.EnsureDead()
+        c.Assert(err, IsNil)
+        err = unit.Remove()
+        c.Assert(err, IsNil)
+
+        err = s.mysql.Destroy()
+        c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+        err = s.mysql.Refresh()
+        c.Assert(state.IsNotFound(err), Equals, true)
+}
+
+func (s *ServiceSuite) TestDestroyStaleNonZeroUnitCount(c *C) {
+        unit, err := s.mysql.AddUnit()
+        c.Assert(err, IsNil)
+        err = s.mysql.Refresh()
+        c.Assert(err, IsNil)
+        err = unit.EnsureDead()
+        c.Assert(err, IsNil)
+        err = unit.Remove()
+        c.Assert(err, IsNil)
+
+        err = s.mysql.Destroy()
+        c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+        err = s.mysql.Refresh()
+        c.Assert(state.IsNotFound(err), Equals, true)
+}
+
+func (s *ServiceSuite) TestDestroyStaleZeroUnitCount(c *C) {
+        unit, err := s.mysql.AddUnit()
+        c.Assert(err, IsNil)
+
+        err = s.mysql.Destroy()
+        c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+
+        err = s.mysql.Refresh()
+        c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+
+        err = unit.EnsureDead()
+        c.Assert(err, IsNil)
+        err = s.mysql.Refresh()
+        c.Assert(err, IsNil)
+        c.Assert(s.mysql.Life(), Equals, state.Dying)
+
+        err = unit.Remove()
+        c.Assert(err, IsNil)
+        err = s.mysql.Refresh()
+        c.Assert(state.IsNotFound(err), Equals, true)
+}
+
+func (s *ServiceSuite) TestDestroyWithRemovableRelation(c *C) {
         wordpress, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
         c.Assert(err, IsNil)
         eps, err := s.State.InferEndpoints([]string{"wordpress", "mysql"})
         c.Assert(err, IsNil)
         rel, err := s.State.AddRelation(eps...)
         c.Assert(err, IsNil)
 
         // Destroy a service with no units in relation scope; check service and
         // unit removed.
         err = wordpress.Destroy()
         c.Assert(err, IsNil)
         err = wordpress.Refresh()
         c.Assert(state.IsNotFound(err), Equals, true)
         err = rel.Refresh()
         c.Assert(state.IsNotFound(err), Equals, true)
 }
 
-func (s *ServiceSuite) TestLifeWithReferencedRelations(c *C) {
+func (s *ServiceSuite) TestDestroyWithReferencedRelation(c *C) {
+        s.assertDestroyWithReferencedRelation(c, true)
+}
+
+func (s *ServiceSuite) TestDestroyWithreferencedRelationStaleCount(c *C) {
+        s.assertDestroyWithReferencedRelation(c, false)
+}
+
+func (s *ServiceSuite) assertDestroyWithReferencedRelation(c *C, refresh bool) {
         wordpress, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
         c.Assert(err, IsNil)
         eps, err := s.State.InferEndpoints([]string{"wordpress", "mysql"})
         c.Assert(err, IsNil)
-        rel, err := s.State.AddRelation(eps...)
-        c.Assert(err, IsNil)
-
-        // Join a unit to the wordpress side to keep the relation alive.
+        rel0, err := s.State.AddRelation(eps...)
+        c.Assert(err, IsNil)
+
+        _, err = s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
+        c.Assert(err, IsNil)
+        eps, err = s.State.InferEndpoints([]string{"logging", "mysql"})
+        c.Assert(err, IsNil)
+        rel1, err := s.State.AddRelation(eps...)
+        c.Assert(err, IsNil)
+
+        // Add a separate reference to the first relation.
         unit, err := wordpress.AddUnit()
         c.Assert(err, IsNil)
-        ru, err := rel.Unit(unit)
+        ru, err := rel0.Unit(unit)
         c.Assert(err, IsNil)
         err = ru.EnterScope(nil)
         c.Assert(err, IsNil)
 
-        // Set Dying, and check that the relation also becomes Dying.
+        // Optionally update the service document to get correct relation counts.
+        if refresh {
+                err = s.mysql.Destroy()
+                c.Assert(err, IsNil)
+        }
+
+        // Destroy, and check that the first relation becomes Dying...
         err = s.mysql.Destroy()
         c.Assert(err, IsNil)
-        err = rel.Refresh()
-        c.Assert(err, IsNil)
-        c.Assert(rel.Life(), Equals, state.Dying)
-
-        // Check that no new relations can be added.
-        _, err = s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
-        c.Assert(err, IsNil)
-        eps, err = s.State.InferEndpoints([]string{"logging", "mysql"})
-        c.Assert(err, IsNil)
-        _, err = s.State.AddRelation(eps...)
-        c.Assert(err, ErrorMatches, `cannot add relation "logging:info mysql:juju-info": service "mysql" is not alive`)
-
-        // Leave scope on the counterpart side; check the service and relation
-        // are both removed.
+        err = rel0.Refresh()
+        c.Assert(err, IsNil)
+        c.Assert(rel0.Life(), Equals, state.Dying)
+
+        // ...while the second is removed directly.
+        err = rel1.Refresh()
+        c.Assert(state.IsNotFound(err), Equals, true)
+
+        // Drop the last reference to the first relation; check the relation and
+        // the service are are both removed.
         err = ru.LeaveScope()
         c.Assert(err, IsNil)
         err = s.mysql.Refresh()
         c.Assert(state.IsNotFound(err), Equals, true)
-        err = rel.Refresh()
+        err = rel0.Refresh()
         c.Assert(state.IsNotFound(err), Equals, true)
 }
 
 func (s *ServiceSuite) TestReadUnitWithChangingState(c *C) {
         // Check that reading a unit after removing the service
         // fails nicely.
         err := s.mysql.Destroy()
         c.Assert(err, IsNil)
         err = s.mysql.Refresh()
         c.Assert(state.IsNotFound(err), Equals, true)
@@ skipping 573 matching lines @@
         case <-time.After(500 * time.Millisecond):
                 c.Fatalf("did not get change")
         }
 
         select {
         case got := <-configWatcher.Changes():
                 c.Fatalf("got unexpected change: %#v", got)
         case <-time.After(100 * time.Millisecond):
         }
 }
+
+func (s *ServiceSuite) TestAnnotatorForService(c *C) {
+        testAnnotator(c, func() (annotator, error) {
+                return s.State.Service("mysql")
+        })
+}