github.com/cloudbase/juju-core@v0.0.0-20140504232958-a7271ac7912f/state/apiserver/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  
     9  	envtesting "launchpad.net/juju-core/environs/testing"
    10  	"launchpad.net/juju-core/errors"
    11  	jujutesting "launchpad.net/juju-core/juju/testing"
    12  	"launchpad.net/juju-core/state"
    13  	"launchpad.net/juju-core/state/api/params"
    14  	"launchpad.net/juju-core/state/apiserver/common"
    15  	apiservertesting "launchpad.net/juju-core/state/apiserver/testing"
    16  	"launchpad.net/juju-core/state/apiserver/upgrader"
    17  	statetesting "launchpad.net/juju-core/state/testing"
    18  	jc "launchpad.net/juju-core/testing/checkers"
    19  	"launchpad.net/juju-core/version"
    20  )
    21  
    22  type upgraderSuite struct {
    23  	jujutesting.JujuConnSuite
    24  
    25  	// These are raw State objects. Use them for setup and assertions, but
    26  	// should never be touched by the API calls themselves
    27  	rawMachine *state.Machine
    28  	upgrader   *upgrader.UpgraderAPI
    29  	resources  *common.Resources
    30  	authorizer apiservertesting.FakeAuthorizer
    31  }
    32  
    33  var _ = gc.Suite(&upgraderSuite{})
    34  
    35  func (s *upgraderSuite) SetUpTest(c *gc.C) {
    36  	s.JujuConnSuite.SetUpTest(c)
    37  	s.resources = common.NewResources()
    38  
    39  	// Create a machine to work with
    40  	var err error
    41  	s.rawMachine, err = s.State.AddMachine("quantal", state.JobHostUnits)
    42  	c.Assert(err, gc.IsNil)
    43  
    44  	// The default auth is as the machine agent
    45  	s.authorizer = apiservertesting.FakeAuthorizer{
    46  		Tag:          s.rawMachine.Tag(),
    47  		LoggedIn:     true,
    48  		MachineAgent: true,
    49  	}
    50  	s.upgrader, err = upgrader.NewUpgraderAPI(s.State, s.resources, s.authorizer)
    51  	c.Assert(err, gc.IsNil)
    52  }
    53  
    54  func (s *upgraderSuite) TearDownTest(c *gc.C) {
    55  	if s.resources != nil {
    56  		s.resources.StopAll()
    57  	}
    58  	s.JujuConnSuite.TearDownTest(c)
    59  }
    60  
    61  func (s *upgraderSuite) TestWatchAPIVersionNothing(c *gc.C) {
    62  	// Not an error to watch nothing
    63  	results, err := s.upgrader.WatchAPIVersion(params.Entities{})
    64  	c.Assert(err, gc.IsNil)
    65  	c.Check(results.Results, gc.HasLen, 0)
    66  }
    67  
    68  func (s *upgraderSuite) TestWatchAPIVersion(c *gc.C) {
    69  	args := params.Entities{
    70  		Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
    71  	}
    72  	results, err := s.upgrader.WatchAPIVersion(args)
    73  	c.Assert(err, gc.IsNil)
    74  	c.Check(results.Results, gc.HasLen, 1)
    75  	c.Check(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
    76  	c.Check(results.Results[0].Error, gc.IsNil)
    77  	resource := s.resources.Get(results.Results[0].NotifyWatcherId)
    78  	c.Check(resource, gc.NotNil)
    79  
    80  	w := resource.(state.NotifyWatcher)
    81  	wc := statetesting.NewNotifyWatcherC(c, s.State, w)
    82  	wc.AssertNoChange()
    83  
    84  	err = statetesting.SetAgentVersion(s.State, version.MustParse("3.4.567.8"))
    85  	c.Assert(err, gc.IsNil)
    86  	wc.AssertOneChange()
    87  	statetesting.AssertStop(c, w)
    88  	wc.AssertClosed()
    89  }
    90  
    91  func (s *upgraderSuite) TestUpgraderAPIRefusesNonMachineAgent(c *gc.C) {
    92  	anAuthorizer := s.authorizer
    93  	anAuthorizer.UnitAgent = true
    94  	anAuthorizer.MachineAgent = false
    95  	anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer)
    96  	c.Check(err, gc.NotNil)
    97  	c.Check(anUpgrader, gc.IsNil)
    98  	c.Assert(err, gc.ErrorMatches, "permission denied")
    99  }
   100  
   101  func (s *upgraderSuite) TestWatchAPIVersionRefusesWrongAgent(c *gc.C) {
   102  	// We are a machine agent, but not the one we are trying to track
   103  	anAuthorizer := s.authorizer
   104  	anAuthorizer.Tag = "machine-12354"
   105  	anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer)
   106  	c.Check(err, gc.IsNil)
   107  	args := params.Entities{
   108  		Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
   109  	}
   110  	results, err := anUpgrader.WatchAPIVersion(args)
   111  	// It is not an error to make the request, but the specific item is rejected
   112  	c.Assert(err, gc.IsNil)
   113  	c.Check(results.Results, gc.HasLen, 1)
   114  	c.Check(results.Results[0].NotifyWatcherId, gc.Equals, "")
   115  	c.Assert(results.Results[0].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   116  }
   117  
   118  func (s *upgraderSuite) TestToolsNothing(c *gc.C) {
   119  	// Not an error to watch nothing
   120  	results, err := s.upgrader.Tools(params.Entities{})
   121  	c.Assert(err, gc.IsNil)
   122  	c.Check(results.Results, gc.HasLen, 0)
   123  }
   124  
   125  func (s *upgraderSuite) TestToolsRefusesWrongAgent(c *gc.C) {
   126  	anAuthorizer := s.authorizer
   127  	anAuthorizer.Tag = "machine-12354"
   128  	anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer)
   129  	c.Check(err, gc.IsNil)
   130  	args := params.Entities{
   131  		Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
   132  	}
   133  	results, err := anUpgrader.Tools(args)
   134  	// It is not an error to make the request, but the specific item is rejected
   135  	c.Assert(err, gc.IsNil)
   136  	c.Check(results.Results, gc.HasLen, 1)
   137  	toolResult := results.Results[0]
   138  	c.Assert(toolResult.Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   139  }
   140  
   141  func (s *upgraderSuite) TestToolsForAgent(c *gc.C) {
   142  	cur := version.Current
   143  	agent := params.Entity{Tag: s.rawMachine.Tag()}
   144  
   145  	// The machine must have its existing tools set before we query for the
   146  	// next tools. This is so that we can grab Arch and Series without
   147  	// having to pass it in again
   148  	err := s.rawMachine.SetAgentVersion(version.Current)
   149  	c.Assert(err, gc.IsNil)
   150  
   151  	args := params.Entities{Entities: []params.Entity{agent}}
   152  	results, err := s.upgrader.Tools(args)
   153  	c.Assert(err, gc.IsNil)
   154  	assertTools := func() {
   155  		c.Check(results.Results, gc.HasLen, 1)
   156  		c.Assert(results.Results[0].Error, gc.IsNil)
   157  		agentTools := results.Results[0].Tools
   158  		c.Check(agentTools.URL, gc.Not(gc.Equals), "")
   159  		c.Check(agentTools.Version, gc.DeepEquals, cur)
   160  	}
   161  	assertTools()
   162  	c.Check(results.Results[0].DisableSSLHostnameVerification, jc.IsFalse)
   163  
   164  	envtesting.SetSSLHostnameVerification(c, s.State, false)
   165  
   166  	results, err = s.upgrader.Tools(args)
   167  	c.Assert(err, gc.IsNil)
   168  	assertTools()
   169  	c.Check(results.Results[0].DisableSSLHostnameVerification, jc.IsTrue)
   170  }
   171  
   172  func (s *upgraderSuite) TestSetToolsNothing(c *gc.C) {
   173  	// Not an error to watch nothing
   174  	results, err := s.upgrader.SetTools(params.EntitiesVersion{})
   175  	c.Assert(err, gc.IsNil)
   176  	c.Check(results.Results, gc.HasLen, 0)
   177  }
   178  
   179  func (s *upgraderSuite) TestSetToolsRefusesWrongAgent(c *gc.C) {
   180  	anAuthorizer := s.authorizer
   181  	anAuthorizer.Tag = "machine-12354"
   182  	anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer)
   183  	c.Check(err, gc.IsNil)
   184  	args := params.EntitiesVersion{
   185  		AgentTools: []params.EntityVersion{{
   186  			Tag: s.rawMachine.Tag(),
   187  			Tools: &params.Version{
   188  				Version: version.Current,
   189  			},
   190  		}},
   191  	}
   192  
   193  	results, err := anUpgrader.SetTools(args)
   194  	c.Assert(results.Results, gc.HasLen, 1)
   195  	c.Assert(results.Results[0].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   196  }
   197  
   198  func (s *upgraderSuite) TestSetTools(c *gc.C) {
   199  	cur := version.Current
   200  	_, err := s.rawMachine.AgentTools()
   201  	c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
   202  	args := params.EntitiesVersion{
   203  		AgentTools: []params.EntityVersion{{
   204  			Tag: s.rawMachine.Tag(),
   205  			Tools: &params.Version{
   206  				Version: cur,
   207  			}},
   208  		},
   209  	}
   210  	results, err := s.upgrader.SetTools(args)
   211  	c.Assert(err, gc.IsNil)
   212  	c.Assert(results.Results, gc.HasLen, 1)
   213  	c.Assert(results.Results[0].Error, gc.IsNil)
   214  	// Check that the new value actually got set, we must Refresh because
   215  	// it was set on a different Machine object
   216  	err = s.rawMachine.Refresh()
   217  	c.Assert(err, gc.IsNil)
   218  	realTools, err := s.rawMachine.AgentTools()
   219  	c.Assert(err, gc.IsNil)
   220  	c.Check(realTools.Version.Arch, gc.Equals, cur.Arch)
   221  	c.Check(realTools.Version.Series, gc.Equals, cur.Series)
   222  	c.Check(realTools.Version.Major, gc.Equals, cur.Major)
   223  	c.Check(realTools.Version.Minor, gc.Equals, cur.Minor)
   224  	c.Check(realTools.Version.Patch, gc.Equals, cur.Patch)
   225  	c.Check(realTools.Version.Build, gc.Equals, cur.Build)
   226  	c.Check(realTools.URL, gc.Equals, "")
   227  }
   228  
   229  func (s *upgraderSuite) TestDesiredVersionNothing(c *gc.C) {
   230  	// Not an error to watch nothing
   231  	results, err := s.upgrader.DesiredVersion(params.Entities{})
   232  	c.Assert(err, gc.IsNil)
   233  	c.Check(results.Results, gc.HasLen, 0)
   234  }
   235  
   236  func (s *upgraderSuite) TestDesiredVersionRefusesWrongAgent(c *gc.C) {
   237  	anAuthorizer := s.authorizer
   238  	anAuthorizer.Tag = "machine-12354"
   239  	anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer)
   240  	c.Check(err, gc.IsNil)
   241  	args := params.Entities{
   242  		Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
   243  	}
   244  	results, err := anUpgrader.DesiredVersion(args)
   245  	// It is not an error to make the request, but the specific item is rejected
   246  	c.Assert(err, gc.IsNil)
   247  	c.Check(results.Results, gc.HasLen, 1)
   248  	toolResult := results.Results[0]
   249  	c.Assert(toolResult.Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   250  }
   251  
   252  func (s *upgraderSuite) TestDesiredVersionNoticesMixedAgents(c *gc.C) {
   253  	args := params.Entities{Entities: []params.Entity{
   254  		{Tag: s.rawMachine.Tag()},
   255  		{Tag: "machine-12345"},
   256  	}}
   257  	results, err := s.upgrader.DesiredVersion(args)
   258  	c.Assert(err, gc.IsNil)
   259  	c.Check(results.Results, gc.HasLen, 2)
   260  	c.Assert(results.Results[0].Error, gc.IsNil)
   261  	agentVersion := results.Results[0].Version
   262  	c.Assert(agentVersion, gc.NotNil)
   263  	c.Check(*agentVersion, gc.DeepEquals, version.Current.Number)
   264  
   265  	c.Assert(results.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
   266  	c.Assert(results.Results[1].Version, gc.IsNil)
   267  
   268  }
   269  
   270  func (s *upgraderSuite) TestDesiredVersionForAgent(c *gc.C) {
   271  	args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}}
   272  	results, err := s.upgrader.DesiredVersion(args)
   273  	c.Assert(err, gc.IsNil)
   274  	c.Check(results.Results, gc.HasLen, 1)
   275  	c.Assert(results.Results[0].Error, gc.IsNil)
   276  	agentVersion := results.Results[0].Version
   277  	c.Assert(agentVersion, gc.NotNil)
   278  	c.Check(*agentVersion, gc.DeepEquals, version.Current.Number)
   279  }