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