state/api/watcher: Refactor API watchers

state/api/upgrader/upgrader_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package upgrader_test
 
 import (
         stdtesting "testing"
 
         . "launchpad.net/gocheck"
 
@@ skipping 84 matching lines @@
         err := s.upgrader.SetTools(params.AgentTools{
                 Tag:    "42",
                 Arch:   cur.Arch,
                 Series: cur.Series,
                 Major:  cur.Major,
                 Minor:  cur.Minor,
                 Patch:  cur.Patch,
                 Build:  cur.Build,
         })
         c.Assert(err, ErrorMatches, "permission denied")
-        c.Assert(api.ErrCode(err), Equals, api.CodeUnauthorized)
+        c.Assert(params.ErrCode(err), Equals, params.CodeUnauthorized)
 }
 
 func (s *upgraderSuite) TestSetTools(c *C) {
         cur := version.Current
         tools, err := s.rawMachine.AgentTools()
         c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
         c.Assert(tools, IsNil)
         err = s.upgrader.SetTools(params.AgentTools{
                 Tag:    s.rawMachine.Tag(),
                 Arch:   cur.Arch,
                 Series: cur.Series,
                 URL:    "",
                 Major:  cur.Major,
                 Minor:  cur.Minor,
                 Patch:  cur.Patch,
                 Build:  cur.Build,
         })
         c.Assert(err, IsNil)
         s.rawMachine.Refresh()
         tools, err = s.rawMachine.AgentTools()
         c.Assert(err, IsNil)
         c.Assert(tools, NotNil)
         c.Check(tools.Binary, Equals, cur)
 }
 
 func (s *upgraderSuite) TestToolsWrongMachine(c *C) {
         tools, err := s.upgrader.Tools("42")
         c.Assert(err, ErrorMatches, "permission denied")
-        c.Assert(api.ErrCode(err), Equals, api.CodeUnauthorized)
+        c.Assert(params.ErrCode(err), Equals, params.CodeUnauthorized)
         c.Assert(tools, IsNil)
 }
 
 func (s *upgraderSuite) TestTools(c *C) {
         cur := version.Current
         curTools := &state.Tools{Binary: cur, URL: ""}
         if curTools.Minor > 0 {
                 curTools.Minor -= 1
         }
         s.rawMachine.SetAgentTools(curTools)
         // Upgrader.Tools returns the *desired* set of tools, not the currently
         // running set. We want to upgraded to cur.Version
         tools, err := s.upgrader.Tools(s.rawMachine.Tag())
         c.Assert(err, IsNil)
         c.Assert(tools, NotNil)
         c.Check(tools.Tag, Equals, s.rawMachine.Tag())
         c.Check(tools.Major, Equals, cur.Major)
         c.Check(tools.Minor, Equals, cur.Minor)
         c.Check(tools.Patch, Equals, cur.Patch)
         c.Check(tools.Build, Equals, cur.Build)
         c.Check(tools.Arch, Equals, cur.Arch)
         c.Check(tools.Series, Equals, cur.Series)
         c.Check(tools.URL, Not(Equals), "")
 }