github.com/mhilton/juju-juju@v0.0.0-20150901100907-a94dd2c73455/apiserver/machine/machiner_test.go (about) 1 // Copyright 2013 Canonical Ltd. 2 // Licensed under the AGPLv3, see LICENCE file for details. 3 4 package machine_test 5 6 import ( 7 "github.com/juju/names" 8 jc "github.com/juju/testing/checkers" 9 gc "gopkg.in/check.v1" 10 11 "github.com/juju/juju/apiserver/common" 12 "github.com/juju/juju/apiserver/machine" 13 "github.com/juju/juju/apiserver/params" 14 apiservertesting "github.com/juju/juju/apiserver/testing" 15 "github.com/juju/juju/network" 16 "github.com/juju/juju/state" 17 "github.com/juju/juju/state/multiwatcher" 18 statetesting "github.com/juju/juju/state/testing" 19 ) 20 21 type machinerSuite struct { 22 commonSuite 23 24 resources *common.Resources 25 machiner *machine.MachinerAPI 26 } 27 28 var _ = gc.Suite(&machinerSuite{}) 29 30 func (s *machinerSuite) SetUpTest(c *gc.C) { 31 s.commonSuite.SetUpTest(c) 32 33 // Create the resource registry separately to track invocations to 34 // Register. 35 s.resources = common.NewResources() 36 37 // Create a machiner API for machine 1. 38 machiner, err := machine.NewMachinerAPI( 39 s.State, 40 s.resources, 41 s.authorizer, 42 ) 43 c.Assert(err, jc.ErrorIsNil) 44 s.machiner = machiner 45 } 46 47 func (s *machinerSuite) TestMachinerFailsWithNonMachineAgentUser(c *gc.C) { 48 anAuthorizer := s.authorizer 49 anAuthorizer.Tag = names.NewUnitTag("ubuntu/1") 50 aMachiner, err := machine.NewMachinerAPI(s.State, s.resources, anAuthorizer) 51 c.Assert(err, gc.NotNil) 52 c.Assert(aMachiner, gc.IsNil) 53 c.Assert(err, gc.ErrorMatches, "permission denied") 54 } 55 56 func (s *machinerSuite) TestSetStatus(c *gc.C) { 57 err := s.machine0.SetStatus(state.StatusStarted, "blah", nil) 58 c.Assert(err, jc.ErrorIsNil) 59 err = s.machine1.SetStatus(state.StatusStopped, "foo", nil) 60 c.Assert(err, jc.ErrorIsNil) 61 62 args := params.SetStatus{ 63 Entities: []params.EntityStatusArgs{ 64 {Tag: "machine-1", Status: params.StatusError, Info: "not really"}, 65 {Tag: "machine-0", Status: params.StatusStopped, Info: "foobar"}, 66 {Tag: "machine-42", Status: params.StatusStarted, Info: "blah"}, 67 }} 68 result, err := s.machiner.SetStatus(args) 69 c.Assert(err, jc.ErrorIsNil) 70 c.Assert(result, gc.DeepEquals, params.ErrorResults{ 71 Results: []params.ErrorResult{ 72 {nil}, 73 {apiservertesting.ErrUnauthorized}, 74 {apiservertesting.ErrUnauthorized}, 75 }, 76 }) 77 78 // Verify machine 0 - no change. 79 statusInfo, err := s.machine0.Status() 80 c.Assert(err, jc.ErrorIsNil) 81 c.Assert(statusInfo.Status, gc.Equals, state.StatusStarted) 82 c.Assert(statusInfo.Message, gc.Equals, "blah") 83 // ...machine 1 is fine though. 84 statusInfo, err = s.machine1.Status() 85 c.Assert(err, jc.ErrorIsNil) 86 c.Assert(statusInfo.Status, gc.Equals, state.StatusError) 87 c.Assert(statusInfo.Message, gc.Equals, "not really") 88 } 89 90 func (s *machinerSuite) TestLife(c *gc.C) { 91 err := s.machine1.EnsureDead() 92 c.Assert(err, jc.ErrorIsNil) 93 err = s.machine1.Refresh() 94 c.Assert(err, jc.ErrorIsNil) 95 c.Assert(s.machine1.Life(), gc.Equals, state.Dead) 96 97 args := params.Entities{Entities: []params.Entity{ 98 {Tag: "machine-1"}, 99 {Tag: "machine-0"}, 100 {Tag: "machine-42"}, 101 }} 102 result, err := s.machiner.Life(args) 103 c.Assert(err, jc.ErrorIsNil) 104 c.Assert(result, gc.DeepEquals, params.LifeResults{ 105 Results: []params.LifeResult{ 106 {Life: "dead"}, 107 {Error: apiservertesting.ErrUnauthorized}, 108 {Error: apiservertesting.ErrUnauthorized}, 109 }, 110 }) 111 } 112 113 func (s *machinerSuite) TestEnsureDead(c *gc.C) { 114 c.Assert(s.machine0.Life(), gc.Equals, state.Alive) 115 c.Assert(s.machine1.Life(), gc.Equals, state.Alive) 116 117 args := params.Entities{Entities: []params.Entity{ 118 {Tag: "machine-1"}, 119 {Tag: "machine-0"}, 120 {Tag: "machine-42"}, 121 }} 122 result, err := s.machiner.EnsureDead(args) 123 c.Assert(err, jc.ErrorIsNil) 124 c.Assert(result, gc.DeepEquals, params.ErrorResults{ 125 Results: []params.ErrorResult{ 126 {nil}, 127 {apiservertesting.ErrUnauthorized}, 128 {apiservertesting.ErrUnauthorized}, 129 }, 130 }) 131 132 err = s.machine0.Refresh() 133 c.Assert(err, jc.ErrorIsNil) 134 c.Assert(s.machine0.Life(), gc.Equals, state.Alive) 135 err = s.machine1.Refresh() 136 c.Assert(err, jc.ErrorIsNil) 137 c.Assert(s.machine1.Life(), gc.Equals, state.Dead) 138 139 // Try it again on a Dead machine; should work. 140 args = params.Entities{ 141 Entities: []params.Entity{{Tag: "machine-1"}}, 142 } 143 result, err = s.machiner.EnsureDead(args) 144 c.Assert(err, jc.ErrorIsNil) 145 c.Assert(result, gc.DeepEquals, params.ErrorResults{ 146 Results: []params.ErrorResult{{nil}}, 147 }) 148 149 // Verify Life is unchanged. 150 err = s.machine1.Refresh() 151 c.Assert(err, jc.ErrorIsNil) 152 c.Assert(s.machine1.Life(), gc.Equals, state.Dead) 153 } 154 155 func (s *machinerSuite) TestSetMachineAddresses(c *gc.C) { 156 c.Assert(s.machine0.Addresses(), gc.HasLen, 0) 157 c.Assert(s.machine1.Addresses(), gc.HasLen, 0) 158 159 addresses := network.NewAddresses("127.0.0.1", "8.8.8.8") 160 161 args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{ 162 {Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)}, 163 {Tag: "machine-0", Addresses: params.FromNetworkAddresses(addresses)}, 164 {Tag: "machine-42", Addresses: params.FromNetworkAddresses(addresses)}, 165 }} 166 167 result, err := s.machiner.SetMachineAddresses(args) 168 c.Assert(err, jc.ErrorIsNil) 169 c.Assert(result, gc.DeepEquals, params.ErrorResults{ 170 Results: []params.ErrorResult{ 171 {nil}, 172 {apiservertesting.ErrUnauthorized}, 173 {apiservertesting.ErrUnauthorized}, 174 }, 175 }) 176 177 err = s.machine1.Refresh() 178 c.Assert(err, jc.ErrorIsNil) 179 180 expectedAddresses := network.NewAddresses("8.8.8.8", "127.0.0.1") 181 c.Assert(s.machine1.MachineAddresses(), gc.DeepEquals, expectedAddresses) 182 err = s.machine0.Refresh() 183 c.Assert(err, jc.ErrorIsNil) 184 c.Assert(s.machine0.MachineAddresses(), gc.HasLen, 0) 185 } 186 187 func (s *machinerSuite) TestSetEmptyMachineAddresses(c *gc.C) { 188 // Set some addresses so we can ensure they are removed. 189 addresses := network.NewAddresses("127.0.0.1", "8.8.8.8") 190 args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{ 191 {Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)}, 192 }} 193 result, err := s.machiner.SetMachineAddresses(args) 194 c.Assert(err, jc.ErrorIsNil) 195 c.Assert(result, gc.DeepEquals, params.ErrorResults{ 196 Results: []params.ErrorResult{ 197 {nil}, 198 }, 199 }) 200 err = s.machine1.Refresh() 201 c.Assert(err, jc.ErrorIsNil) 202 c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 2) 203 204 args.MachineAddresses[0].Addresses = nil 205 result, err = s.machiner.SetMachineAddresses(args) 206 c.Assert(err, jc.ErrorIsNil) 207 c.Assert(result, gc.DeepEquals, params.ErrorResults{ 208 Results: []params.ErrorResult{ 209 {nil}, 210 }, 211 }) 212 213 err = s.machine1.Refresh() 214 c.Assert(err, jc.ErrorIsNil) 215 c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 0) 216 } 217 218 func (s *machinerSuite) TestJobs(c *gc.C) { 219 args := params.Entities{Entities: []params.Entity{ 220 {Tag: "machine-1"}, 221 {Tag: "machine-0"}, 222 {Tag: "machine-42"}, 223 }} 224 225 result, err := s.machiner.Jobs(args) 226 c.Assert(err, jc.ErrorIsNil) 227 c.Assert(result, gc.DeepEquals, params.JobsResults{ 228 Results: []params.JobsResult{ 229 {Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}}, 230 {Error: apiservertesting.ErrUnauthorized}, 231 {Error: apiservertesting.ErrUnauthorized}, 232 }, 233 }) 234 } 235 236 func (s *machinerSuite) TestWatch(c *gc.C) { 237 c.Assert(s.resources.Count(), gc.Equals, 0) 238 239 args := params.Entities{Entities: []params.Entity{ 240 {Tag: "machine-1"}, 241 {Tag: "machine-0"}, 242 {Tag: "machine-42"}, 243 }} 244 result, err := s.machiner.Watch(args) 245 c.Assert(err, jc.ErrorIsNil) 246 c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{ 247 Results: []params.NotifyWatchResult{ 248 {NotifyWatcherId: "1"}, 249 {Error: apiservertesting.ErrUnauthorized}, 250 {Error: apiservertesting.ErrUnauthorized}, 251 }, 252 }) 253 254 // Verify the resource was registered and stop when done 255 c.Assert(s.resources.Count(), gc.Equals, 1) 256 c.Assert(result.Results[0].NotifyWatcherId, gc.Equals, "1") 257 resource := s.resources.Get("1") 258 defer statetesting.AssertStop(c, resource) 259 260 // Check that the Watch has consumed the initial event ("returned" in 261 // the Watch call) 262 wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher)) 263 wc.AssertNoChange() 264 }