various: gocheck, checkers, imports fixes

state/service_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state_test
 
 import (
         "fmt"
         "sort"
 
         "labix.org/v2/mgo"
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/errors"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/testing"
-        "launchpad.net/juju-core/testing/checkers"
+        jc "launchpad.net/juju-core/testing/checkers"
 )
 
 type ServiceSuite struct {
         ConnSuite
         charm *state.Charm
         mysql *state.Service
 }
 
 var _ = gc.Suite(&ServiceSuite{})
 
@@ skipping 484 matching lines @@
         c.Assert(err, gc.IsNil)
         rels := s.assertServiceRelations(c, s.mysql, "mysql:cluster", "mysql:loadbalancer")
 
         // Check state consistency by attempting to destroy the service.
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
 
         // Check the peer relations got destroyed as well.
         for _, rel := range rels {
                 err = rel.Refresh()
-                c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+                c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
         }
 }
 
 func jujuInfoEp(serviceName string) state.Endpoint {
         return state.Endpoint{
                 ServiceName: serviceName,
                 Relation: charm.Relation{
                         Interface: "juju-info",
                         Name:      "juju-info",
                         Role:      charm.RoleProvider,
@@ skipping 178 matching lines @@
         err = s1.Refresh()
         c.Assert(err, gc.IsNil)
         testch, force, err = s1.Charm()
         c.Assert(err, gc.IsNil)
         c.Assert(force, gc.Equals, true)
         c.Assert(testch.URL(), gc.DeepEquals, s.charm.URL())
 
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestServiceExposed(c *gc.C) {
         // Check that querying for the exposed flag works correctly.
         c.Assert(s.mysql.IsExposed(), gc.Equals, false)
 
         // Check that setting and clearing the exposed flag works correctly.
         err := s.mysql.SetExposed()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.IsExposed(), gc.Equals, true)
@@ skipping 175 matching lines @@
         removeAllUnits(c, s.mysql)
         _, err = s.mysql.AllUnits()
         c.Assert(err, gc.IsNil)
 }
 
 func (s *ServiceSuite) TestDestroySimple(c *gc.C) {
         err := s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyStillHasUnits(c *gc.C) {
         unit, err := s.mysql.AddUnit()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
 
         err = unit.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
 
         err = unit.Remove()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyOnceHadUnits(c *gc.C) {
         unit, err := s.mysql.AddUnit()
         c.Assert(err, gc.IsNil)
         err = unit.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = unit.Remove()
         c.Assert(err, gc.IsNil)
 
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyStaleNonZeroUnitCount(c *gc.C) {
         unit, err := s.mysql.AddUnit()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
         c.Assert(err, gc.IsNil)
         err = unit.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = unit.Remove()
         c.Assert(err, gc.IsNil)
 
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyStaleZeroUnitCount(c *gc.C) {
         unit, err := s.mysql.AddUnit()
         c.Assert(err, gc.IsNil)
 
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
 
         err = s.mysql.Refresh()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
 
         err = unit.EnsureDead()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
         c.Assert(err, gc.IsNil)
         c.Assert(s.mysql.Life(), gc.Equals, state.Dying)
 
         err = unit.Remove()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyWithRemovableRelation(c *gc.C) {
         wordpress, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
         c.Assert(err, gc.IsNil)
         eps, err := s.State.InferEndpoints([]string{"wordpress", "mysql"})
         c.Assert(err, gc.IsNil)
         rel, err := s.State.AddRelation(eps...)
         c.Assert(err, gc.IsNil)
 
         // Destroy a service with no units in relation scope; check service and
         // unit removed.
         err = wordpress.Destroy()
         c.Assert(err, gc.IsNil)
         err = wordpress.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
         err = rel.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyWithReferencedRelation(c *gc.C) {
         s.assertDestroyWithReferencedRelation(c, true)
 }
 
 func (s *ServiceSuite) TestDestroyWithreferencedRelationStaleCount(c *gc.C) {
         s.assertDestroyWithReferencedRelation(c, false)
 }
 
@@ skipping 28 matching lines @@
 
         // Destroy, and check that the first relation becomes Dying...
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         err = rel0.Refresh()
         c.Assert(err, gc.IsNil)
         c.Assert(rel0.Life(), gc.Equals, state.Dying)
 
         // ...while the second is removed directly.
         err = rel1.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 
         // Drop the last reference to the first relation; check the relation and
         // the service are are both removed.
         err = ru.LeaveScope()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
         err = rel0.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 }
 
 func (s *ServiceSuite) TestDestroyQueuesUnitCleanup(c *gc.C) {
         // Add 5 units; block quick-remove of mysql/1 and mysql/3
         units := make([]*state.Unit, 5)
         for i := range units {
                 unit, err := s.mysql.AddUnit()
                 c.Assert(err, gc.IsNil)
                 units[i] = unit
                 if i%2 != 0 {
@@ skipping 34 matching lines @@
         c.Assert(err, gc.IsNil)
         c.Assert(dirty, gc.Equals, false)
 }
 
 func (s *ServiceSuite) TestReadUnitWithChangingState(c *gc.C) {
         // Check that reading a unit after removing the service
         // fails nicely.
         err := s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
         _, err = s.State.Unit("mysql/0")
         c.Assert(err, gc.ErrorMatches, `unit "mysql/0" not found`)
 }
 
 func uint64p(val uint64) *uint64 {
         return &val
 }
 
 func (s *ServiceSuite) TestConstraints(c *gc.C) {
         // Constraints are initially empty (for now).
@@ skipping 15 matching lines @@
         c.Assert(err, gc.IsNil)
         cons5, err := s.mysql.Constraints()
         c.Assert(err, gc.IsNil)
         c.Assert(cons5, gc.DeepEquals, cons4)
 
         // Destroy the existing service; there's no way to directly assert
         // that the constraints are deleted...
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         err = s.mysql.Refresh()
-        c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
+        c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
 
         // ...but we can check that old constraints do not affect new services
         // with matching names.
         ch, _, err := s.mysql.Charm()
         c.Assert(err, gc.IsNil)
         mysql, err := s.State.AddService(s.mysql.Name(), ch)
         c.Assert(err, gc.IsNil)
         cons6, err := mysql.Constraints()
         c.Assert(err, gc.IsNil)
         c.Assert(cons6, gc.DeepEquals, cons0)
@@ skipping 259 matching lines @@
 func (s *ServiceSuite) TestAnnotationRemovalForService(c *gc.C) {
         annotations := map[string]string{"mykey": "myvalue"}
         err := s.mysql.SetAnnotations(annotations)
         c.Assert(err, gc.IsNil)
         err = s.mysql.Destroy()
         c.Assert(err, gc.IsNil)
         ann, err := s.mysql.Annotations()
         c.Assert(err, gc.IsNil)
         c.Assert(ann, gc.DeepEquals, make(map[string]string))
 }