errors: Improve tests, unify interfaces, wrapping

state/unit_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state_test
 
 import (
         "strconv"
 
         jc "github.com/juju/testing/checkers"
         gc "launchpad.net/gocheck"
@@ skipping 23 matching lines @@
         s.service = s.AddTestingService(c, "wordpress", s.charm)
         c.Assert(err, gc.IsNil)
         s.unit, err = s.service.AddUnit()
         c.Assert(err, gc.IsNil)
         c.Assert(s.unit.Series(), gc.Equals, "quantal")
 }
 
 func (s *UnitSuite) TestUnitNotFound(c *gc.C) {
         _, err := s.State.Unit("subway/0")
         c.Assert(err, gc.ErrorMatches, `unit "subway/0" not found`)
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
 }
 
 func (s *UnitSuite) TestService(c *gc.C) {
         svc, err := s.unit.Service()
         c.Assert(err, gc.IsNil)
         c.Assert(svc.Name(), gc.Equals, s.unit.ServiceName())
 }
 
 func (s *UnitSuite) TestConfigSettingsNeedCharmURLSet(c *gc.C) {
         _, err := s.unit.ConfigSettings()
@@ skipping 234 matching lines @@
         err = unit1.Refresh()
         c.Assert(err, gc.IsNil)
         valid = unit1.PasswordValid("arble-farble-dying-yarble")
         c.Assert(valid, jc.IsTrue)
 
         err = unit1.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = unit1.Remove()
         c.Assert(err, gc.IsNil)
         err = unit1.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
 }
 
 func (s *UnitSuite) TestGetSetStatusWhileAlive(c *gc.C) {
         err := s.unit.SetStatus(params.StatusError, "", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status "error" without info`)
         err = s.unit.SetStatus(params.StatusPending, "", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status "pending"`)
         err = s.unit.SetStatus(params.StatusDown, "", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status "down"`)
         err = s.unit.SetStatus(params.Status("vliegkat"), "orville", nil)
@@ skipping 303 matching lines @@
         assertRemoved(c, s.unit)
 }
 
 func assertLife(c *gc.C, entity state.Living, life state.Life) {
         c.Assert(entity.Refresh(), gc.IsNil)
         c.Assert(entity.Life(), gc.Equals, life)
 }
 
 func assertRemoved(c *gc.C, entity state.Living) {
         err := entity.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
         err = entity.Destroy()
         c.Assert(err, gc.IsNil)
         if entity, ok := entity.(state.AgentLiving); ok {
                 err = entity.EnsureDead()
                 c.Assert(err, gc.IsNil)
                 err = entity.Remove()
                 c.Assert(err, gc.IsNil)
         }
 }
 
@@ skipping 44 matching lines @@
         err = unit.AssignToMachine(m)
         c.Assert(err, gc.IsNil)
         err = m.SetMongoPassword("foo")
         c.Assert(err, gc.IsNil)
 
         // Sanity check that we cannot connect with the wrong
         // password
         info.Tag = m.Tag()
         info.Password = "foo1"
         err = tryOpenState(info)
-        c.Assert(err, jc.Satisfies, errors.IsUnauthorizedError)
+        c.Assert(err, jc.Satisfies, errors.IsUnauthorized)
 
         // Connect as the machine entity.
         info.Tag = m.Tag()
         info.Password = "foo"
         st1, err := state.Open(info, state.TestingDialOpts(), state.Policy(nil))
         c.Assert(err, gc.IsNil)
         defer st1.Close()
 
         // Change the password for a unit derived from
         // the machine entity's state.
@@ skipping 361 matching lines @@
 }
 
 func (s *UnitSuite) TestRemove(c *gc.C) {
         err := s.unit.Remove()
         c.Assert(err, gc.ErrorMatches, `cannot remove unit "wordpress/0": unit is not dead`)
         err = s.unit.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = s.unit.Remove()
         c.Assert(err, gc.IsNil)
         err = s.unit.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
         units, err := s.service.AllUnits()
         c.Assert(err, gc.IsNil)
         c.Assert(units, gc.HasLen, 0)
         err = s.unit.Remove()
         c.Assert(err, gc.IsNil)
 }
 
 func (s *UnitSuite) TestRemovePathological(c *gc.C) {
         // Add a relation between wordpress and mysql...
         wordpress := s.service
@@ skipping 29 matching lines @@
         err = wordpress.Refresh()
         c.Assert(err, gc.IsNil)
         err = rel.Refresh()
         c.Assert(err, gc.IsNil)
 
         // ...but when the unit on the other side departs the relation, the
         // relation and the other service are cleaned up.
         err = mysql0ru.LeaveScope()
         c.Assert(err, gc.IsNil)
         err = wordpress.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
         err = rel.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
 }
 
 func (s *UnitSuite) TestRemovePathologicalWithBuggyUniter(c *gc.C) {
         // Add a relation between wordpress and mysql...
         wordpress := s.service
         wordpress0 := s.unit
         mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
         eps, err := s.State.InferEndpoints([]string{"wordpress", "mysql"})
         c.Assert(err, gc.IsNil)
         rel, err := s.State.AddRelation(eps...)
@@ skipping 27 matching lines @@
         c.Assert(err, gc.IsNil)
 
         // ...and that when the malfunctioning unit agent on the other side
         // sets itself to dead *without* departing the relation, the unit's
         // removal causes the relation and the other service to be cleaned up.
         err = mysql0.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = mysql0.Remove()
         c.Assert(err, gc.IsNil)
         err = wordpress.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
         err = rel.Refresh()
-        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFound)
 }
 
 func (s *UnitSuite) TestWatchSubordinates(c *gc.C) {
         w := s.unit.WatchSubordinateUnits()
         defer testing.AssertStop(c, w)
         wc := testing.NewStringsWatcherC(c, s.State, w)
         wc.AssertChange()
         wc.AssertNoChange()
 
         // Add a couple of subordinates, check change.
@@ skipping 101 matching lines @@
         err := s.unit.SetAnnotations(annotations)
         c.Assert(err, gc.IsNil)
         err = s.unit.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = s.unit.Remove()
         c.Assert(err, gc.IsNil)
         ann, err := s.unit.Annotations()
         c.Assert(err, gc.IsNil)
         c.Assert(ann, gc.DeepEquals, make(map[string]string))
 }