← Back to branch summary

~axwalk/juju-core/api-uniter-machine

« back to all changes in this revision

Viewing changes to state/relationunit_test.go

  • Committer: Tarmac
  • Author(s): William Reade
  • Date: 2014-05-22 11:37:17 UTC
  • mfrom: (1679.1.11 juju-core)
  • Revision ID: tarmac-20140522113717-99dhnikcznpjpwrw
[r=fwereade],[bug=1192433] state: set departed on dying units' relations

This ended up including:

  * stopping using magic strings in cleanup
  * drawing a clear distinction between "joined" and "in scope" (which
    accounts for most of the lines of changes)

...but did *not* include:

  * fixing the name of the Uniter.JoinedRelations API, because I want to
    wait for API versioning

https://codereview.appspot.com/94540043/

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/relationunit_test.go
35
35
}
36
36
 
37
37
func assertNotInScope(c *gc.C, ru *state.RelationUnit) {
 
38
        assertNotJoined(c, ru)
38
39
        ok, err := ru.InScope()
39
40
        c.Assert(err, gc.IsNil)
40
41
        c.Assert(ok, jc.IsFalse)
41
42
}
42
43
 
 
44
func assertJoined(c *gc.C, ru *state.RelationUnit) {
 
45
        assertInScope(c, ru)
 
46
        ok, err := ru.Joined()
 
47
        c.Assert(err, gc.IsNil)
 
48
        c.Assert(ok, jc.IsTrue)
 
49
}
 
50
 
 
51
func assertNotJoined(c *gc.C, ru *state.RelationUnit) {
 
52
        ok, err := ru.Joined()
 
53
        c.Assert(err, gc.IsNil)
 
54
        c.Assert(ok, jc.IsFalse)
 
55
}
 
56
 
43
57
func (s *RelationUnitSuite) TestReadSettingsErrors(c *gc.C) {
44
58
        riak := s.AddTestingService(c, "riak", s.AddTestingCharm(c, "riak"))
45
59
        u0, err := riak.AddUnit()
94
108
                }
95
109
        }
96
110
        assertSettings(pr.u0, normal)
97
 
        assertInScope(c, pr.ru0)
 
111
        assertJoined(c, pr.ru0)
98
112
 
99
113
        // Check that EnterScope when scope already entered does not touch
100
114
        // settings at all.
102
116
        err = pr.ru0.EnterScope(changed)
103
117
        c.Assert(err, gc.IsNil)
104
118
        assertSettings(pr.u0, normal)
105
 
        assertInScope(c, pr.ru0)
 
119
        assertJoined(c, pr.ru0)
106
120
 
107
121
        // Leave scope, check settings are still as accessible as before.
108
122
        err = pr.ru0.LeaveScope()
115
129
        err = pr.ru0.EnterScope(changed)
116
130
        c.Assert(err, gc.IsNil)
117
131
        assertSettings(pr.u0, changed)
118
 
        assertInScope(c, pr.ru0)
 
132
        assertJoined(c, pr.ru0)
119
133
 
120
134
        // Leave and re-enter with nil nettings, and check they overwrite to become
121
135
        // an empty map.
125
139
        err = pr.ru0.EnterScope(nil)
126
140
        c.Assert(err, gc.IsNil)
127
141
        assertSettings(pr.u0, map[string]interface{}{})
128
 
        assertInScope(c, pr.ru0)
 
142
        assertJoined(c, pr.ru0)
129
143
 
130
144
        // Check that entering scope for the first time with nil settings works correctly.
131
145
        assertNotInScope(c, pr.ru1)
132
146
        err = pr.ru1.EnterScope(nil)
133
147
        c.Assert(err, gc.IsNil)
134
148
        assertSettings(pr.u1, map[string]interface{}{})
135
 
        assertInScope(c, pr.ru1)
 
149
        assertJoined(c, pr.ru1)
136
150
}
137
151
 
138
152
func (s *RelationUnitSuite) TestProReqSettings(c *gc.C) {
154
168
        node.Set("meme", "foul-bachelor-frog")
155
169
        _, err = node.Write()
156
170
        c.Assert(err, gc.IsNil)
157
 
        assertInScope(c, prr.pru0)
 
171
        assertJoined(c, prr.pru0)
158
172
 
159
173
        // Check settings can be read by every RU.
160
174
        for _, ru := range rus {
184
198
        node.Set("meme", "foul-bachelor-frog")
185
199
        _, err = node.Write()
186
200
        c.Assert(err, gc.IsNil)
187
 
        assertInScope(c, prr.pru0)
 
201
        assertJoined(c, prr.pru0)
188
202
 
189
203
        // Check settings can be read by RUs in the same container.
190
204
        rus0 := RUs{prr.pru0, prr.rru0}
229
243
        err = pru.EnterScope(nil)
230
244
        c.Assert(err, gc.IsNil)
231
245
        assertSubCount(1)
232
 
        assertInScope(c, pru)
 
246
        assertJoined(c, pru)
233
247
 
234
248
        // Enter principal scope again and check no more subordinates created.
235
249
        err = pru.EnterScope(nil)
236
250
        c.Assert(err, gc.IsNil)
237
251
        assertSubCount(1)
238
 
        assertInScope(c, pru)
 
252
        assertJoined(c, pru)
239
253
 
240
254
        // Leave principal scope, then re-enter, and check that still no further
241
255
        // subordinates are created.
245
259
        err = pru.EnterScope(nil)
246
260
        c.Assert(err, gc.IsNil)
247
261
        runits := assertSubCount(1)
248
 
        assertInScope(c, pru)
 
262
        assertJoined(c, pru)
249
263
 
250
264
        // Set the subordinate to Dying, and enter scope again; because the scope
251
265
        // is already entered, no error is returned.
254
268
        c.Assert(err, gc.IsNil)
255
269
        err = pru.EnterScope(nil)
256
270
        c.Assert(err, gc.IsNil)
257
 
        assertInScope(c, pru)
 
271
        assertJoined(c, pru)
258
272
 
259
273
        // Leave scope, then try to enter again with the Dying subordinate.
260
274
        err = pru.LeaveScope()
275
289
        err = pru.EnterScope(nil)
276
290
        c.Assert(err, gc.IsNil)
277
291
        assertSubCount(1)
278
 
        assertInScope(c, pru)
 
292
        assertJoined(c, pru)
279
293
}
280
294
 
281
295
func (s *RelationUnitSuite) TestDestroyRelationWithUnitsInScope(c *gc.C) {
287
301
        assertNotInScope(c, pr.ru0)
288
302
        err := pr.ru0.EnterScope(map[string]interface{}{"some": "settings"})
289
303
        c.Assert(err, gc.IsNil)
290
 
        assertInScope(c, pr.ru0)
 
304
        assertJoined(c, pr.ru0)
291
305
        assertNotInScope(c, pr.ru1)
292
306
        err = pr.ru1.EnterScope(nil)
293
307
        c.Assert(err, gc.IsNil)
294
 
        assertInScope(c, pr.ru1)
 
308
        assertJoined(c, pr.ru1)
295
309
        err = pr.svc.Destroy()
296
310
        c.Assert(err, gc.IsNil)
297
311
        err = rel.Refresh()
309
323
        c.Assert(err, gc.ErrorMatches, `cannot read settings for unit "riak/2" in relation "riak:ring": settings not found`)
310
324
 
311
325
        // ru0 leaves the scope; check that service Destroy is still a no-op.
312
 
        assertInScope(c, pr.ru0)
 
326
        assertJoined(c, pr.ru0)
313
327
        err = pr.ru0.LeaveScope()
314
328
        c.Assert(err, gc.IsNil)
315
329
        assertNotInScope(c, pr.ru0)
328
342
        assertSettings()
329
343
 
330
344
        // The final unit leaves the scope, and cleans up after itself.
331
 
        assertInScope(c, pr.ru1)
 
345
        assertJoined(c, pr.ru1)
332
346
        err = pr.ru1.LeaveScope()
333
347
        c.Assert(err, gc.IsNil)
334
348
        assertNotInScope(c, pr.ru1)
353
367
        assertNotInScope(c, pr.ru0)
354
368
        err := pr.ru0.EnterScope(nil)
355
369
        c.Assert(err, gc.IsNil)
356
 
        assertInScope(c, pr.ru0)
 
370
        assertJoined(c, pr.ru0)
357
371
        assertNotInScope(c, pr.ru1)
358
372
        err = pr.ru1.EnterScope(nil)
359
373
        c.Assert(err, gc.IsNil)
360
 
        assertInScope(c, pr.ru1)
 
374
        assertJoined(c, pr.ru1)
361
375
 
362
376
        // One unit becomes Dying, then re-enters the scope; this is not an error,
363
377
        // because the state is already as requested.
365
379
        c.Assert(err, gc.IsNil)
366
380
        err = pr.ru0.EnterScope(nil)
367
381
        c.Assert(err, gc.IsNil)
368
 
        assertInScope(c, pr.ru0)
 
382
        assertJoined(c, pr.ru0)
369
383
 
370
384
        // Two units leave...
371
385
        err = pr.ru0.LeaveScope()
384
398
        assertNotInScope(c, pr.ru2)
385
399
        err = pr.ru2.EnterScope(nil)
386
400
        c.Assert(err, gc.IsNil)
387
 
        assertInScope(c, pr.ru2)
 
401
        assertJoined(c, pr.ru2)
388
402
 
389
403
        // ...but Dying units cannot.
390
404
        err = pr.u3.Destroy()
421
435
        node, err := pr.ru0.Settings()
422
436
        c.Assert(err, gc.IsNil)
423
437
        c.Assert(node.Map(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
424
 
        assertInScope(c, pr.ru0)
 
438
        assertJoined(c, pr.ru0)
425
439
 
426
440
        // ru1 enters; check change is observed.
427
441
        assertNotInScope(c, pr.ru1)
429
443
        c.Assert(err, gc.IsNil)
430
444
        s.assertScopeChange(c, w0, []string{"riak/1"}, nil)
431
445
        s.assertNoScopeChange(c, w0)
432
 
        assertInScope(c, pr.ru1)
 
446
        assertJoined(c, pr.ru1)
433
447
 
434
448
        // ru1 enters again, check no problems and no changes.
435
449
        err = pr.ru1.EnterScope(nil)
436
450
        c.Assert(err, gc.IsNil)
437
451
        s.assertNoScopeChange(c, w0)
438
 
        assertInScope(c, pr.ru1)
 
452
        assertJoined(c, pr.ru1)
439
453
 
440
454
        // Stop watching; ru2 enters.
441
455
        testing.AssertStop(c, w0)
442
456
        assertNotInScope(c, pr.ru2)
443
457
        err = pr.ru2.EnterScope(nil)
444
458
        c.Assert(err, gc.IsNil)
445
 
        assertInScope(c, pr.ru2)
 
459
        assertJoined(c, pr.ru2)
446
460
 
447
461
        // Start watch again, check initial event.
448
462
        w0 = pr.ru0.WatchScope()
451
465
        s.assertNoScopeChange(c, w0)
452
466
 
453
467
        // ru1 leaves; check event.
454
 
        assertInScope(c, pr.ru1)
 
468
        assertJoined(c, pr.ru1)
455
469
        err = pr.ru1.LeaveScope()
456
470
        c.Assert(err, gc.IsNil)
457
471
        s.assertScopeChange(c, w0, nil, []string{"riak/1"})
489
503
                s.assertScopeChange(c, w, []string{"mysql/0"}, nil)
490
504
        }
491
505
        s.assertNoScopeChange(c, ws...)
492
 
        assertInScope(c, prr.pru0)
 
506
        assertJoined(c, prr.pru0)
493
507
 
494
508
        // req0 enters; check detected only by pro RUs.
495
509
        assertNotInScope(c, prr.rru0)
502
516
                s.assertScopeChange(c, w, []string{"wordpress/0"}, nil)
503
517
        }
504
518
        s.assertNoScopeChange(c, ws...)
505
 
        assertInScope(c, prr.rru0)
 
519
        assertJoined(c, prr.rru0)
506
520
 
507
521
        // Stop watches; remaining RUs enter.
508
522
        for _, w := range ws {
511
525
        assertNotInScope(c, prr.pru1)
512
526
        err = prr.pru1.EnterScope(nil)
513
527
        c.Assert(err, gc.IsNil)
514
 
        assertInScope(c, prr.pru1)
 
528
        assertJoined(c, prr.pru1)
515
529
        assertNotInScope(c, prr.rru1)
516
530
        err = prr.rru1.EnterScope(nil)
517
531
        c.Assert(err, gc.IsNil)
518
 
        assertInScope(c, prr.rru0)
 
532
        assertJoined(c, prr.rru0)
519
533
 
520
534
        // Start new watches, check initial events.
521
535
        ws = prr.watches()
531
545
        s.assertNoScopeChange(c, ws...)
532
546
 
533
547
        // pru0 leaves; check detected only by req RUs.
534
 
        assertInScope(c, prr.pru0)
 
548
        assertJoined(c, prr.pru0)
535
549
        err = prr.pru0.LeaveScope()
536
550
        c.Assert(err, gc.IsNil)
537
551
        for _, w := range rws() {
541
555
        assertNotInScope(c, prr.pru0)
542
556
 
543
557
        // rru0 leaves; check detected only by pro RUs.
544
 
        assertInScope(c, prr.rru0)
 
558
        assertJoined(c, prr.rru0)
545
559
        err = prr.rru0.LeaveScope()
546
560
        c.Assert(err, gc.IsNil)
547
561
        for _, w := range pws() {
570
584
        c.Assert(err, gc.IsNil)
571
585
        s.assertScopeChange(c, ws[2], []string{"mysql/0"}, nil)
572
586
        s.assertNoScopeChange(c, ws...)
573
 
        assertInScope(c, prr.pru0)
 
587
        assertJoined(c, prr.pru0)
574
588
 
575
589
        // req1 enters; check detected only by same-container pro.
576
590
        assertNotInScope(c, prr.rru1)
578
592
        c.Assert(err, gc.IsNil)
579
593
        s.assertScopeChange(c, ws[1], []string{"logging/1"}, nil)
580
594
        s.assertNoScopeChange(c, ws...)
581
 
        assertInScope(c, prr.rru1)
 
595
        assertJoined(c, prr.rru1)
582
596
 
583
597
        // Stop watches; remaining RUs enter scope.
584
598
        for _, w := range ws {
601
615
        s.assertScopeChange(c, ws[2], []string{"mysql/0"}, nil)
602
616
        s.assertScopeChange(c, ws[3], []string{"mysql/1"}, nil)
603
617
        s.assertNoScopeChange(c, ws...)
604
 
        assertInScope(c, prr.pru1)
605
 
        assertInScope(c, prr.rru0)
 
618
        assertJoined(c, prr.pru1)
 
619
        assertJoined(c, prr.rru0)
606
620
 
607
621
        // pru0 leaves; check detected only by same-container req.
608
 
        assertInScope(c, prr.pru0)
 
622
        assertJoined(c, prr.pru0)
609
623
        err = prr.pru0.LeaveScope()
610
624
        c.Assert(err, gc.IsNil)
611
625
        s.assertScopeChange(c, ws[2], nil, []string{"mysql/0"})
613
627
        assertNotInScope(c, prr.pru0)
614
628
 
615
629
        // rru0 leaves; check detected only by same-container pro.
616
 
        assertInScope(c, prr.rru0)
 
630
        assertJoined(c, prr.rru0)
617
631
        err = prr.rru0.LeaveScope()
618
632
        c.Assert(err, gc.IsNil)
619
633
        s.assertScopeChange(c, ws[0], nil, []string{"logging/0"})
678
692
        s.assertScopeChange(c, w0, nil, []string{"wordpress/0"})
679
693
        s.assertNoScopeChange(c, w0)
680
694
        assertInScope(c, prr.rru0)
 
695
        assertNotJoined(c, prr.rru0)
681
696
 
682
697
        // rru1 leaves, and the relation is destroyed; it's not removed, because
683
698
        // rru0 keeps it alive until it really leaves scope.