← Back to branch summary

~fwereade/juju-core/environs-unscrew-startinstance

« back to all changes in this revision

Viewing changes to state/assign_test.go

  • Committer: William Reade
  • Author(s): William Reade
  • Date: 2013-02-22 10:46:28 UTC
  • mfrom: (916.2.3 juju-core)
  • Revision ID: fwereade@gmail.com-20130222104628-0wjbo6vu2hi15oxw
state: add Machine.Series

as a very first step towards resolving lp:1131608

R=TheMue, dimitern
CC=
https://codereview.appspot.com/7399049

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/assign_test.go
62
62
        // Check that assigning an already assigned unit to
63
63
        // a machine fails if it isn't precisely the same
64
64
        // machine.
65
 
        machineOne, err := s.State.AddMachine(state.JobHostUnits)
 
65
        machineOne, err := s.State.AddMachine("series", state.JobHostUnits)
66
66
        c.Assert(err, IsNil)
67
 
        machineTwo, err := s.State.AddMachine(state.JobHostUnits)
 
67
        machineTwo, err := s.State.AddMachine("series", state.JobHostUnits)
68
68
        c.Assert(err, IsNil)
69
69
 
70
70
        err = unit.AssignToMachine(machineOne)
87
87
func (s *AssignSuite) TestAssignedMachineIdWhenNotAlive(c *C) {
88
88
        unit, err := s.wordpress.AddUnit()
89
89
        c.Assert(err, IsNil)
90
 
        machine, err := s.State.AddMachine(state.JobHostUnits)
 
90
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
91
91
        c.Assert(err, IsNil)
92
92
 
93
93
        err = unit.AssignToMachine(machine)
103
103
func (s *AssignSuite) TestAssignedMachineIdWhenPrincipalNotAlive(c *C) {
104
104
        unit, err := s.wordpress.AddUnit()
105
105
        c.Assert(err, IsNil)
106
 
        machine, err := s.State.AddMachine(state.JobHostUnits)
 
106
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
107
107
        c.Assert(err, IsNil)
108
108
        err = unit.AssignToMachine(machine)
109
109
        c.Assert(err, IsNil)
145
145
        c.Assert(err, IsNil)
146
146
        subUnit := s.addSubordinate(c, unit)
147
147
 
148
 
        machine, err := s.State.AddMachine(state.JobHostUnits)
 
148
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
149
149
        c.Assert(err, IsNil)
150
150
        err = subUnit.AssignToMachine(machine)
151
151
        c.Assert(err, ErrorMatches, ".*: unit is a subordinate")
165
165
}
166
166
 
167
167
func (s *AssignSuite) TestDeployerName(c *C) {
168
 
        machine, err := s.State.AddMachine(state.JobHostUnits)
 
168
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
169
169
        c.Assert(err, IsNil)
170
170
        principal, err := s.wordpress.AddUnit()
171
171
        c.Assert(err, IsNil)
201
201
}
202
202
 
203
203
func (s *AssignSuite) TestAssignMachineWhenDying(c *C) {
204
 
        machine, err := s.State.AddMachine(state.JobHostUnits)
 
204
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
205
205
        c.Assert(err, IsNil)
206
206
 
207
207
        const unitDeadErr = ".*: unit is dead"
223
223
}
224
224
 
225
225
func (s *AssignSuite) TestAssignMachinePrincipalsChange(c *C) {
226
 
        machine, err := s.State.AddMachine(state.JobHostUnits)
 
226
        machine, err := s.State.AddMachine("series", state.JobHostUnits)
227
227
        c.Assert(err, IsNil)
228
228
        unit, err := s.wordpress.AddUnit()
229
229
        c.Assert(err, IsNil)
261
261
}
262
262
 
263
263
func (s *AssignSuite) TestAssignUnitToUnusedMachine(c *C) {
264
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
264
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
265
265
        c.Assert(err, IsNil)
266
266
        unit, err := s.wordpress.AddUnit()
267
267
        c.Assert(err, IsNil)
273
273
        for i := range units {
274
274
                u, err := service1.AddUnit()
275
275
                c.Assert(err, IsNil)
276
 
                m, err := s.State.AddMachine(state.JobHostUnits)
 
276
                m, err := s.State.AddMachine("series", state.JobHostUnits)
277
277
                c.Assert(err, IsNil)
278
278
                err = u.AssignToMachine(m)
279
279
                c.Assert(err, IsNil)
282
282
 
283
283
        // Assign the suite's unit to a machine, then remove the unit
284
284
        // so the machine becomes available again.
285
 
        origMachine, err := s.State.AddMachine(state.JobHostUnits)
 
285
        origMachine, err := s.State.AddMachine("series", state.JobHostUnits)
286
286
        c.Assert(err, IsNil)
287
287
        err = unit.AssignToMachine(origMachine)
288
288
        c.Assert(err, IsNil)
303
303
        c.Assert(reusedMachine.Id(), Equals, origMachine.Id())
304
304
 
305
305
        // Check that it fails when called again, even when there's an available machine
306
 
        m, err := s.State.AddMachine(state.JobHostUnits)
 
306
        m, err := s.State.AddMachine("series", state.JobHostUnits)
307
307
        c.Assert(err, IsNil)
308
308
        _, err = newUnit.AssignToUnusedMachine()
309
309
        c.Assert(err, ErrorMatches, `cannot assign unit "riak/0" to unused machine: unit is already assigned to a machine`)
321
321
        c.Assert(err, ErrorMatches, `all machines in use`)
322
322
 
323
323
        // Add a dying machine and check that it is not chosen.
324
 
        m, err = s.State.AddMachine(state.JobHostUnits)
 
324
        m, err = s.State.AddMachine("series", state.JobHostUnits)
325
325
        c.Assert(err, IsNil)
326
326
        err = m.Destroy()
327
327
        c.Assert(err, IsNil)
330
330
        c.Assert(err, ErrorMatches, `all machines in use`)
331
331
 
332
332
        // Add another non-unit-hosting machine and check it is not chosen.
333
 
        m, err = s.State.AddMachine(state.JobManageEnviron)
 
333
        m, err = s.State.AddMachine("series", state.JobManageEnviron)
334
334
        c.Assert(err, IsNil)
335
335
        m, err = newUnit.AssignToUnusedMachine()
336
336
        c.Assert(m, IsNil)
338
338
}
339
339
 
340
340
func (s *AssignSuite) TestAssignUnitToUnusedMachineWithRemovedService(c *C) {
341
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
341
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
342
342
        c.Assert(err, IsNil)
343
343
        unit, err := s.wordpress.AddUnit()
344
344
        c.Assert(err, IsNil)
347
347
        removeAllUnits(c, s.wordpress)
348
348
        err = s.wordpress.Destroy()
349
349
        c.Assert(err, IsNil)
350
 
        _, err = s.State.AddMachine(state.JobHostUnits)
 
350
        _, err = s.State.AddMachine("series", state.JobHostUnits)
351
351
        c.Assert(err, IsNil)
352
352
        _, err = unit.AssignToUnusedMachine()
353
353
        c.Assert(err, ErrorMatches, `cannot assign unit "wordpress/0" to unused machine.*: unit "wordpress/0" not found`)
354
354
}
355
355
 
356
356
func (s *AssignSuite) TestAssignUnitToUnusedMachineWithRemovedUnit(c *C) {
357
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
357
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
358
358
        c.Assert(err, IsNil)
359
359
        unit, err := s.wordpress.AddUnit()
360
360
        c.Assert(err, IsNil)
363
363
        c.Assert(err, IsNil)
364
364
        err = unit.Remove()
365
365
        c.Assert(err, IsNil)
366
 
        _, err = s.State.AddMachine(state.JobHostUnits)
 
366
        _, err = s.State.AddMachine("series", state.JobHostUnits)
367
367
        c.Assert(err, IsNil)
368
368
 
369
369
        _, err = unit.AssignToUnusedMachine()
371
371
}
372
372
 
373
373
func (s *AssignSuite) TestAssignUnitToUnusedMachineWorksWithMachine0(c *C) {
374
 
        m, err := s.State.AddMachine(state.JobHostUnits)
 
374
        m, err := s.State.AddMachine("series", state.JobHostUnits)
375
375
        c.Assert(err, IsNil)
376
376
        c.Assert(m.Id(), Equals, "0")
377
377
        unit, err := s.wordpress.AddUnit()
382
382
}
383
383
 
384
384
func (s *AssignSuite) TestAssignUnitToUnusedMachineNoneAvailable(c *C) {
385
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
385
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
386
386
        c.Assert(err, IsNil)
387
387
        unit, err := s.wordpress.AddUnit()
388
388
        c.Assert(err, IsNil)
389
389
        // Check that assigning without unused machine fails.
390
 
        m1, err := s.State.AddMachine(state.JobHostUnits)
 
390
        m1, err := s.State.AddMachine("series", state.JobHostUnits)
391
391
        c.Assert(err, IsNil)
392
392
        err = unit.AssignToMachine(m1)
393
393
        c.Assert(err, IsNil)
411
411
}
412
412
 
413
413
func (s *AssignSuite) TestAssignUnitLocalPolicy(c *C) {
414
 
        m, err := s.State.AddMachine(state.JobManageEnviron, state.JobHostUnits) // bootstrap machine
 
414
        m, err := s.State.AddMachine("series", state.JobManageEnviron, state.JobHostUnits) // bootstrap machine
415
415
        c.Assert(err, IsNil)
416
416
        unit, err := s.wordpress.AddUnit()
417
417
        c.Assert(err, IsNil)
427
427
}
428
428
 
429
429
func (s *AssignSuite) TestAssignUnitUnusedPolicy(c *C) {
430
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
430
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
431
431
        c.Assert(err, IsNil)
432
432
 
433
433
        // Check unassigned placements with no unused machines.
468
468
        }
469
469
        // Add some more unused machines
470
470
        for i := 0; i < 4; i++ {
471
 
                m, err := s.State.AddMachine(state.JobHostUnits)
 
471
                m, err := s.State.AddMachine("series", state.JobHostUnits)
472
472
                c.Assert(err, IsNil)
473
473
                unused = append(unused, m.Id())
474
474
        }
490
490
}
491
491
 
492
492
func (s *AssignSuite) TestAssignUnitUnusedPolicyConcurrently(c *C) {
493
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
493
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
494
494
        c.Assert(err, IsNil)
495
495
        us := make([]*state.Unit, 50)
496
496
        for i := range us {
531
531
}
532
532
 
533
533
func (s *AssignSuite) TestAssignSubordinate(c *C) {
534
 
        _, err := s.State.AddMachine(state.JobManageEnviron) // bootstrap machine
 
534
        _, err := s.State.AddMachine("series", state.JobManageEnviron) // bootstrap machine
535
535
        c.Assert(err, IsNil)
536
536
        unit, err := s.wordpress.AddUnit()
537
537
        c.Assert(err, IsNil)