launchpad.net/~rogpeppe/juju-core/500-errgo-fix@v0.0.0-20140213181702-000000002356/state/api/upgrader/upgrader_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package upgrader_test
     5  
     6  import (
     7  	gc "launchpad.net/gocheck"
     8  	stdtesting "testing"
     9  
    10  	envtesting "launchpad.net/juju-core/environs/testing"
    11  	"launchpad.net/juju-core/errors"
    12  	"launchpad.net/juju-core/juju/testing"
    13  	"launchpad.net/juju-core/state"
    14  	"launchpad.net/juju-core/state/api"
    15  	"launchpad.net/juju-core/state/api/params"
    16  	"launchpad.net/juju-core/state/api/upgrader"
    17  	statetesting "launchpad.net/juju-core/state/testing"
    18  	coretesting "launchpad.net/juju-core/testing"
    19  	jc "launchpad.net/juju-core/testing/checkers"
    20  	"launchpad.net/juju-core/tools"
    21  	"launchpad.net/juju-core/version"
    22  )
    23  
    24  func TestAll(t *stdtesting.T) {
    25  	coretesting.MgoTestPackage(t)
    26  }
    27  
    28  type upgraderSuite struct {
    29  	testing.JujuConnSuite
    30  
    31  	stateAPI *api.State
    32  
    33  	// These are raw State objects. Use them for setup and assertions, but
    34  	// should never be touched by the API calls themselves
    35  	rawMachine *state.Machine
    36  	rawCharm   *state.Charm
    37  	rawService *state.Service
    38  	rawUnit    *state.Unit
    39  
    40  	st *upgrader.State
    41  }
    42  
    43  var _ = gc.Suite(&upgraderSuite{})
    44  
    45  func (s *upgraderSuite) SetUpTest(c *gc.C) {
    46  	s.JujuConnSuite.SetUpTest(c)
    47  	s.stateAPI, s.rawMachine = s.OpenAPIAsNewMachine(c)
    48  	// Create the upgrader facade.
    49  	s.st = s.stateAPI.Upgrader()
    50  	c.Assert(s.st, gc.NotNil)
    51  }
    52  
    53  // Note: This is really meant as a unit-test, this isn't a test that should
    54  //       need all of the setup we have for this test suite
    55  func (s *upgraderSuite) TestNew(c *gc.C) {
    56  	upgrader := upgrader.NewState(s.stateAPI)
    57  	c.Assert(upgrader, gc.NotNil)
    58  }
    59  
    60  func (s *upgraderSuite) TestSetVersionWrongMachine(c *gc.C) {
    61  	err := s.st.SetVersion("42", version.Current)
    62  	c.Assert(err, gc.ErrorMatches, "permission denied")
    63  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    64  }
    65  
    66  func (s *upgraderSuite) TestSetVersion(c *gc.C) {
    67  	cur := version.Current
    68  	agentTools, err := s.rawMachine.AgentTools()
    69  	c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
    70  	c.Assert(agentTools, gc.IsNil)
    71  	err = s.st.SetVersion(s.rawMachine.Tag(), cur)
    72  	c.Assert(err, gc.IsNil)
    73  	s.rawMachine.Refresh()
    74  	agentTools, err = s.rawMachine.AgentTools()
    75  	c.Assert(err, gc.IsNil)
    76  	c.Check(agentTools.Version, gc.Equals, cur)
    77  }
    78  
    79  func (s *upgraderSuite) TestToolsWrongMachine(c *gc.C) {
    80  	tools, _, err := s.st.Tools("42")
    81  	c.Assert(err, gc.ErrorMatches, "permission denied")
    82  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    83  	c.Assert(tools, gc.IsNil)
    84  }
    85  
    86  func (s *upgraderSuite) TestTools(c *gc.C) {
    87  	cur := version.Current
    88  	curTools := &tools.Tools{Version: cur, URL: ""}
    89  	curTools.Version.Minor++
    90  	s.rawMachine.SetAgentVersion(cur)
    91  	// Upgrader.Tools returns the *desired* set of tools, not the currently
    92  	// running set. We want to be upgraded to cur.Version
    93  	stateTools, disableSSLHostnameVerification, err := s.st.Tools(s.rawMachine.Tag())
    94  	c.Assert(err, gc.IsNil)
    95  	c.Assert(stateTools.Version, gc.Equals, cur)
    96  	c.Assert(stateTools.URL, gc.Not(gc.Equals), "")
    97  	c.Assert(disableSSLHostnameVerification, jc.IsFalse)
    98  
    99  	envtesting.SetSSLHostnameVerification(c, s.State, false)
   100  
   101  	stateTools, disableSSLHostnameVerification, err = s.st.Tools(s.rawMachine.Tag())
   102  	c.Assert(err, gc.IsNil)
   103  	c.Assert(stateTools.Version, gc.Equals, cur)
   104  	c.Assert(stateTools.URL, gc.Not(gc.Equals), "")
   105  	c.Assert(disableSSLHostnameVerification, jc.IsTrue)
   106  }
   107  
   108  func (s *upgraderSuite) TestWatchAPIVersion(c *gc.C) {
   109  	w, err := s.st.WatchAPIVersion(s.rawMachine.Tag())
   110  	c.Assert(err, gc.IsNil)
   111  	defer statetesting.AssertStop(c, w)
   112  	wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
   113  	// Initial event
   114  	wc.AssertOneChange()
   115  	vers := version.MustParse("10.20.34")
   116  	err = statetesting.SetAgentVersion(s.BackingState, vers)
   117  	c.Assert(err, gc.IsNil)
   118  	// One change noticing the new version
   119  	wc.AssertOneChange()
   120  	// Setting the version to the same value doesn't trigger a change
   121  	err = statetesting.SetAgentVersion(s.BackingState, vers)
   122  	c.Assert(err, gc.IsNil)
   123  	wc.AssertNoChange()
   124  	vers = version.MustParse("10.20.35")
   125  	err = statetesting.SetAgentVersion(s.BackingState, vers)
   126  	c.Assert(err, gc.IsNil)
   127  	wc.AssertOneChange()
   128  	statetesting.AssertStop(c, w)
   129  	wc.AssertClosed()
   130  }
   131  
   132  func (s *upgraderSuite) TestDesiredVersion(c *gc.C) {
   133  	cur := version.Current
   134  	curTools := &tools.Tools{Version: cur, URL: ""}
   135  	curTools.Version.Minor++
   136  	s.rawMachine.SetAgentVersion(cur)
   137  	// Upgrader.DesiredVersion returns the *desired* set of tools, not the
   138  	// currently running set. We want to be upgraded to cur.Version
   139  	stateVersion, err := s.st.DesiredVersion(s.rawMachine.Tag())
   140  	c.Assert(err, gc.IsNil)
   141  	c.Assert(stateVersion, gc.Equals, cur.Number)
   142  }