launchpad.net/~rogpeppe/juju-core/500-errgo-fix@v0.0.0-20140213181702-000000002356/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) TestUpgraderAPIRefusesNonAgent(c *gc.C) { 92 // We aren't even a machine agent 93 anAuthorizer := s.authorizer 94 anAuthorizer.UnitAgent = false 95 anAuthorizer.MachineAgent = false 96 anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer) 97 c.Check(err, gc.NotNil) 98 c.Check(anUpgrader, gc.IsNil) 99 c.Assert(err, gc.ErrorMatches, "permission denied") 100 } 101 102 func (s *upgraderSuite) TestWatchAPIVersionRefusesWrongAgent(c *gc.C) { 103 // We are a machine agent, but not the one we are trying to track 104 anAuthorizer := s.authorizer 105 anAuthorizer.Tag = "machine-12354" 106 anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer) 107 c.Check(err, gc.IsNil) 108 args := params.Entities{ 109 Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}, 110 } 111 results, err := anUpgrader.WatchAPIVersion(args) 112 // It is not an error to make the request, but the specific item is rejected 113 c.Assert(err, gc.IsNil) 114 c.Check(results.Results, gc.HasLen, 1) 115 c.Check(results.Results[0].NotifyWatcherId, gc.Equals, "") 116 c.Assert(results.Results[0].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized) 117 } 118 119 func (s *upgraderSuite) TestToolsNothing(c *gc.C) { 120 // Not an error to watch nothing 121 results, err := s.upgrader.Tools(params.Entities{}) 122 c.Assert(err, gc.IsNil) 123 c.Check(results.Results, gc.HasLen, 0) 124 } 125 126 func (s *upgraderSuite) TestToolsRefusesWrongAgent(c *gc.C) { 127 anAuthorizer := s.authorizer 128 anAuthorizer.Tag = "machine-12354" 129 anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer) 130 c.Check(err, gc.IsNil) 131 args := params.Entities{ 132 Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}, 133 } 134 results, err := anUpgrader.Tools(args) 135 // It is not an error to make the request, but the specific item is rejected 136 c.Assert(err, gc.IsNil) 137 c.Check(results.Results, gc.HasLen, 1) 138 toolResult := results.Results[0] 139 c.Assert(toolResult.Error, gc.DeepEquals, apiservertesting.ErrUnauthorized) 140 } 141 142 func (s *upgraderSuite) TestToolsForAgent(c *gc.C) { 143 cur := version.Current 144 agent := params.Entity{Tag: s.rawMachine.Tag()} 145 146 // The machine must have its existing tools set before we query for the 147 // next tools. This is so that we can grab Arch and Series without 148 // having to pass it in again 149 err := s.rawMachine.SetAgentVersion(version.Current) 150 c.Assert(err, gc.IsNil) 151 152 args := params.Entities{Entities: []params.Entity{agent}} 153 results, err := s.upgrader.Tools(args) 154 c.Assert(err, gc.IsNil) 155 assertTools := func() { 156 c.Check(results.Results, gc.HasLen, 1) 157 c.Assert(results.Results[0].Error, gc.IsNil) 158 agentTools := results.Results[0].Tools 159 c.Check(agentTools.URL, gc.Not(gc.Equals), "") 160 c.Check(agentTools.Version, gc.DeepEquals, cur) 161 } 162 assertTools() 163 c.Check(results.Results[0].DisableSSLHostnameVerification, jc.IsFalse) 164 165 envtesting.SetSSLHostnameVerification(c, s.State, false) 166 167 results, err = s.upgrader.Tools(args) 168 c.Assert(err, gc.IsNil) 169 assertTools() 170 c.Check(results.Results[0].DisableSSLHostnameVerification, jc.IsTrue) 171 } 172 173 func (s *upgraderSuite) TestSetToolsNothing(c *gc.C) { 174 // Not an error to watch nothing 175 results, err := s.upgrader.SetTools(params.EntitiesVersion{}) 176 c.Assert(err, gc.IsNil) 177 c.Check(results.Results, gc.HasLen, 0) 178 } 179 180 func (s *upgraderSuite) TestSetToolsRefusesWrongAgent(c *gc.C) { 181 anAuthorizer := s.authorizer 182 anAuthorizer.Tag = "machine-12354" 183 anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer) 184 c.Check(err, gc.IsNil) 185 args := params.EntitiesVersion{ 186 AgentTools: []params.EntityVersion{{ 187 Tag: s.rawMachine.Tag(), 188 Tools: ¶ms.Version{ 189 Version: version.Current, 190 }, 191 }}, 192 } 193 194 results, err := anUpgrader.SetTools(args) 195 c.Assert(results.Results, gc.HasLen, 1) 196 c.Assert(results.Results[0].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized) 197 } 198 199 func (s *upgraderSuite) TestSetTools(c *gc.C) { 200 cur := version.Current 201 _, err := s.rawMachine.AgentTools() 202 c.Assert(err, jc.Satisfies, errors.IsNotFoundError) 203 args := params.EntitiesVersion{ 204 AgentTools: []params.EntityVersion{{ 205 Tag: s.rawMachine.Tag(), 206 Tools: ¶ms.Version{ 207 Version: cur, 208 }}, 209 }, 210 } 211 results, err := s.upgrader.SetTools(args) 212 c.Assert(err, gc.IsNil) 213 c.Assert(results.Results, gc.HasLen, 1) 214 c.Assert(results.Results[0].Error, gc.IsNil) 215 // Check that the new value actually got set, we must Refresh because 216 // it was set on a different Machine object 217 err = s.rawMachine.Refresh() 218 c.Assert(err, gc.IsNil) 219 realTools, err := s.rawMachine.AgentTools() 220 c.Assert(err, gc.IsNil) 221 c.Check(realTools.Version.Arch, gc.Equals, cur.Arch) 222 c.Check(realTools.Version.Series, gc.Equals, cur.Series) 223 c.Check(realTools.Version.Major, gc.Equals, cur.Major) 224 c.Check(realTools.Version.Minor, gc.Equals, cur.Minor) 225 c.Check(realTools.Version.Patch, gc.Equals, cur.Patch) 226 c.Check(realTools.Version.Build, gc.Equals, cur.Build) 227 c.Check(realTools.URL, gc.Equals, "") 228 } 229 230 func (s *upgraderSuite) TestDesiredVersionNothing(c *gc.C) { 231 // Not an error to watch nothing 232 results, err := s.upgrader.DesiredVersion(params.Entities{}) 233 c.Assert(err, gc.IsNil) 234 c.Check(results.Results, gc.HasLen, 0) 235 } 236 237 func (s *upgraderSuite) TestDesiredVersionRefusesWrongAgent(c *gc.C) { 238 anAuthorizer := s.authorizer 239 anAuthorizer.Tag = "machine-12354" 240 anUpgrader, err := upgrader.NewUpgraderAPI(s.State, s.resources, anAuthorizer) 241 c.Check(err, gc.IsNil) 242 args := params.Entities{ 243 Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}, 244 } 245 results, err := anUpgrader.DesiredVersion(args) 246 // It is not an error to make the request, but the specific item is rejected 247 c.Assert(err, gc.IsNil) 248 c.Check(results.Results, gc.HasLen, 1) 249 toolResult := results.Results[0] 250 c.Assert(toolResult.Error, gc.DeepEquals, apiservertesting.ErrUnauthorized) 251 } 252 253 func (s *upgraderSuite) TestDesiredVersionNoticesMixedAgents(c *gc.C) { 254 args := params.Entities{Entities: []params.Entity{ 255 {Tag: s.rawMachine.Tag()}, 256 {Tag: "machine-12345"}, 257 }} 258 results, err := s.upgrader.DesiredVersion(args) 259 c.Assert(err, gc.IsNil) 260 c.Check(results.Results, gc.HasLen, 2) 261 c.Assert(results.Results[0].Error, gc.IsNil) 262 agentVersion := results.Results[0].Version 263 c.Assert(agentVersion, gc.NotNil) 264 c.Check(*agentVersion, gc.DeepEquals, version.Current.Number) 265 266 c.Assert(results.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized) 267 c.Assert(results.Results[1].Version, gc.IsNil) 268 269 } 270 271 func (s *upgraderSuite) TestDesiredVersionForAgent(c *gc.C) { 272 args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}} 273 results, err := s.upgrader.DesiredVersion(args) 274 c.Assert(err, gc.IsNil) 275 c.Check(results.Results, gc.HasLen, 1) 276 c.Assert(results.Results[0].Error, gc.IsNil) 277 agentVersion := results.Results[0].Version 278 c.Assert(agentVersion, gc.NotNil) 279 c.Check(*agentVersion, gc.DeepEquals, version.Current.Number) 280 }