github.com/cloud-green/juju@v0.0.0-20151002100041-a00291338d3d/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  	"fmt"
     8  	stdtesting "testing"
     9  
    10  	"github.com/juju/errors"
    11  	jc "github.com/juju/testing/checkers"
    12  	gc "gopkg.in/check.v1"
    13  
    14  	"github.com/juju/juju/api"
    15  	"github.com/juju/juju/api/upgrader"
    16  	"github.com/juju/juju/apiserver/params"
    17  	"github.com/juju/juju/juju/testing"
    18  	"github.com/juju/juju/state"
    19  	statetesting "github.com/juju/juju/state/testing"
    20  	coretesting "github.com/juju/juju/testing"
    21  	"github.com/juju/juju/tools"
    22  	"github.com/juju/juju/version"
    23  )
    24  
    25  func TestAll(t *stdtesting.T) {
    26  	coretesting.MgoTestPackage(t)
    27  }
    28  
    29  type machineUpgraderSuite struct {
    30  	testing.JujuConnSuite
    31  
    32  	stateAPI api.Connection
    33  
    34  	// These are raw State objects. Use them for setup and assertions, but
    35  	// should never be touched by the API calls themselves
    36  	rawMachine *state.Machine
    37  
    38  	st *upgrader.State
    39  }
    40  
    41  var _ = gc.Suite(&machineUpgraderSuite{})
    42  
    43  func (s *machineUpgraderSuite) SetUpTest(c *gc.C) {
    44  	s.JujuConnSuite.SetUpTest(c)
    45  	s.stateAPI, s.rawMachine = s.OpenAPIAsNewMachine(c)
    46  	// Create the upgrader facade.
    47  	s.st = s.stateAPI.Upgrader()
    48  	c.Assert(s.st, gc.NotNil)
    49  }
    50  
    51  // Note: This is really meant as a unit-test, this isn't a test that should
    52  //       need all of the setup we have for this test suite
    53  func (s *machineUpgraderSuite) TestNew(c *gc.C) {
    54  	upgrader := upgrader.NewState(s.stateAPI)
    55  	c.Assert(upgrader, gc.NotNil)
    56  }
    57  
    58  func (s *machineUpgraderSuite) TestSetVersionWrongMachine(c *gc.C) {
    59  	err := s.st.SetVersion("machine-42", version.Current)
    60  	c.Assert(err, gc.ErrorMatches, "permission denied")
    61  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    62  }
    63  
    64  func (s *machineUpgraderSuite) TestSetVersionNotMachine(c *gc.C) {
    65  	err := s.st.SetVersion("foo-42", version.Current)
    66  	c.Assert(err, gc.ErrorMatches, "permission denied")
    67  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    68  }
    69  
    70  func (s *machineUpgraderSuite) TestSetVersion(c *gc.C) {
    71  	cur := version.Current
    72  	agentTools, err := s.rawMachine.AgentTools()
    73  	c.Assert(err, jc.Satisfies, errors.IsNotFound)
    74  	c.Assert(agentTools, gc.IsNil)
    75  	err = s.st.SetVersion(s.rawMachine.Tag().String(), cur)
    76  	c.Assert(err, jc.ErrorIsNil)
    77  	s.rawMachine.Refresh()
    78  	agentTools, err = s.rawMachine.AgentTools()
    79  	c.Assert(err, jc.ErrorIsNil)
    80  	c.Check(agentTools.Version, gc.Equals, cur)
    81  }
    82  
    83  func (s *machineUpgraderSuite) TestToolsWrongMachine(c *gc.C) {
    84  	tools, err := s.st.Tools("machine-42")
    85  	c.Assert(err, gc.ErrorMatches, "permission denied")
    86  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    87  	c.Assert(tools, gc.IsNil)
    88  }
    89  
    90  func (s *machineUpgraderSuite) TestToolsNotMachine(c *gc.C) {
    91  	tools, err := s.st.Tools("foo-42")
    92  	c.Assert(err, gc.ErrorMatches, "permission denied")
    93  	c.Assert(err, jc.Satisfies, params.IsCodeUnauthorized)
    94  	c.Assert(tools, gc.IsNil)
    95  }
    96  
    97  func (s *machineUpgraderSuite) TestTools(c *gc.C) {
    98  	cur := version.Current
    99  	curTools := &tools.Tools{Version: cur, URL: ""}
   100  	curTools.Version.Minor++
   101  	s.rawMachine.SetAgentVersion(cur)
   102  	// Upgrader.Tools returns the *desired* set of tools, not the currently
   103  	// running set. We want to be upgraded to cur.Version
   104  	stateTools, err := s.st.Tools(s.rawMachine.Tag().String())
   105  	c.Assert(err, jc.ErrorIsNil)
   106  	c.Assert(stateTools.Version, gc.Equals, cur)
   107  	url := fmt.Sprintf("https://%s/environment/%s/tools/%s",
   108  		s.stateAPI.Addr(), coretesting.EnvironmentTag.Id(), cur)
   109  	c.Assert(stateTools.URL, gc.Equals, url)
   110  }
   111  
   112  func (s *machineUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
   113  	w, err := s.st.WatchAPIVersion(s.rawMachine.Tag().String())
   114  	c.Assert(err, jc.ErrorIsNil)
   115  	defer statetesting.AssertStop(c, w)
   116  	wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
   117  	// Initial event
   118  	wc.AssertOneChange()
   119  	vers := version.MustParse("10.20.34")
   120  	err = statetesting.SetAgentVersion(s.BackingState, vers)
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	// One change noticing the new version
   123  	wc.AssertOneChange()
   124  	// Setting the version to the same value doesn't trigger a change
   125  	err = statetesting.SetAgentVersion(s.BackingState, vers)
   126  	c.Assert(err, jc.ErrorIsNil)
   127  	wc.AssertNoChange()
   128  	vers = version.MustParse("10.20.35")
   129  	err = statetesting.SetAgentVersion(s.BackingState, vers)
   130  	c.Assert(err, jc.ErrorIsNil)
   131  	wc.AssertOneChange()
   132  	statetesting.AssertStop(c, w)
   133  	wc.AssertClosed()
   134  }
   135  
   136  func (s *machineUpgraderSuite) TestDesiredVersion(c *gc.C) {
   137  	cur := version.Current
   138  	curTools := &tools.Tools{Version: cur, URL: ""}
   139  	curTools.Version.Minor++
   140  	s.rawMachine.SetAgentVersion(cur)
   141  	// Upgrader.DesiredVersion returns the *desired* set of tools, not the
   142  	// currently running set. We want to be upgraded to cur.Version
   143  	stateVersion, err := s.st.DesiredVersion(s.rawMachine.Tag().String())
   144  	c.Assert(err, jc.ErrorIsNil)
   145  	c.Assert(stateVersion, gc.Equals, cur.Number)
   146  }