« back to all changes in this revision
Viewing changes to tests/syncdaemon/test_states.py
- browse files at revision 1.1.43
- compare with another revision
- download diff
- download tarball
- view history from revision 1.1.43
- Committer: Bazaar Package Importer
- Author(s): Rodney Dawes
- Date: 2011-01-25 16:42:52 UTC
- mto: This revision was merged to the branch mainline in revision 64.
- Revision ID: james.westby@ubuntu.com-20110125164252-rl1pybasx1nsqgoy
Tags: upstream-1.5.3
Import upstream version 1.5.3
- files added:
- tests/platform/linux/test_notification.py
- tests/status
- ubuntuone/status
- files removed:
- contrib/pylint-wrapper
- contrib/testing/dbus-session
- files modified:
- Makefile.am
added
removed
tests/syncdaemon/test_states.py
46
46
It has the behaviour of the real queues regarding waiting, done,
47
47
and counter.
48
48
49
- WAITING when command is queued and the queue was empty.
50
- WAITING when command is done and queue still has stuff
49
- WAITING when command is queued and the queue was empty (first cmd, bah).
51
50
- DONE when command is done and queue is empty
52
51
53
52
It does NOT send a WAITING everytime something is queued, and it does
54
53
NOT send a DONE everytime a command finishes.
55
54
"""
56
def __init__(self, name, execs):
57
self.name = name
58
if name == 'MQ':
59
self.event_preffix = 'SYS_META_QUEUE_'
60
else:
61
self.event_preffix = 'SYS_CONTENT_QUEUE_'
62
self.execs = execs
55
def __init__(self):
56
self.active = False
63
57
self.jobs = []
64
58
65
59
def __len__(self):
69
63
"""Inserts a job."""
70
64
self.jobs.append(job)
71
65
if len(self) == 1:
72
self.qm.on_event(self.event_preffix + 'WAITING')
66
self.qm.on_event('SYS_QUEUE_WAITING')
73
67
74
68
def run(self):
75
"""Executes one job."""
76
if not len(self):
77
raise ValueError("Run without jobs! (%s)" % self.jobs)
78
79
def executed(_):
80
if self.jobs:
81
self.qm.on_event(self.event_preffix + 'WAITING')
82
else:
83
self.qm.on_event(self.event_preffix + 'DONE')
84
85
self.execs.append(self.name)
86
job = self.jobs.pop(0)
87
job.addCallback(executed)
69
"""Run."""
70
self.active = True
71
72
def stop(self):
73
"""Stop."""
74
self.active = False
88
75
89
76
90
77
class FakeActionQueue(object):
91
78
"""Fake class to log actions on AQ."""
92
79
def __init__(self):
93
# this '.execs' is not in the real AQ, it's used in both queues to
94
# record themselves in the same list; this way we can assert over
95
# the order and amount of queue executions
96
self.execs = []
97
self.meta_queue = FakeRequestQueue('MQ', self.execs)
98
self.content_queue = FakeRequestQueue('CQ', self.execs)
80
self.queue = FakeRequestQueue()
99
81
self.actions = []
100
82
101
83
def __getattribute__(self, name):
124
106
125
107
class Base(TwistedTestCase):
126
108
"""Base class for state tests."""
109
127
110
def setUp(self):
128
111
# create fake classes
129
112
self.eq = FakeEventQueue()
134
117
self.cm = self.sm.connection
135
118
136
119
# add QM to queues, to push events for testing
137
self.aq.content_queue.qm = self.qm
138
self.aq.meta_queue.qm = self.qm
120
self.aq.queue.qm = self.qm
139
121
140
122
# add logger
141
123
self.fake_logger = FakeLogger()
178
160
def tearDown(self):
179
161
self.sm.connection.shutdown()
180
162
163
181
164
class QueueBase(Base):
182
165
"""Basic setup for QueueManager."""
183
166
184
167
def setUp(self):
185
168
Base.setUp(self)
186
187
# set up everything so run() will actually run the queues
188
self.qm.cq.queue(defer.Deferred())
189
self.qm.mq.queue(defer.Deferred())
190
169
self.sm.state = StateManager.QUEUE_MANAGER
191
170
192
171
202
181
m = "Bad Event received: Got %r while in %s" % (event, n_from)
203
182
self.assertEqual(in_log, self.check_log('warning', m))
204
183
205
def test_idle_mq_waiting(self):
206
"""MQ Waiting when in IDLE."""
207
self.check('IDLE', 'SYS_META_QUEUE_WAITING', 'WORKING_ON_METADATA')
208
self.assertEqual(self.aq.execs, ['MQ'])
209
210
def test_idle_mq_done(self):
211
"""MQ Done when in IDLE."""
212
self.check('IDLE', 'SYS_META_QUEUE_DONE', 'IDLE', in_log=True)
213
214
def test_idle_cq_waiting(self):
215
"""CQ Waiting when in IDLE."""
216
self.check('IDLE', 'SYS_CONTENT_QUEUE_WAITING', 'WORKING_ON_CONTENT')
217
self.assertEqual(self.aq.execs, ['CQ'])
218
219
def test_idle_cq_done(self):
220
"""CQ Done when in IDLE."""
221
self.check('IDLE', 'SYS_CONTENT_QUEUE_DONE', 'IDLE', in_log=True)
222
223
def test_workingmetadata_mq_waiting(self):
224
"""MQ Waiting when in WORKING_ON_METADATA."""
225
self.check('WORKING_ON_METADATA', 'SYS_META_QUEUE_WAITING',
226
'WORKING_ON_METADATA')
227
self.assertEqual(self.aq.execs, ['MQ'])
228
229
def test_workingmetadata_mq_done(self):
230
"""MQ Done when in WORKING_ON_METADATA."""
231
self.check('WORKING_ON_METADATA', 'SYS_META_QUEUE_DONE', 'IDLE')
232
233
def test_workingmetadata_cq_waiting(self):
234
"""CQ Waiting when in WORKING_ON_METADATA."""
235
self.check('WORKING_ON_METADATA', 'SYS_CONTENT_QUEUE_WAITING',
236
'WORKING_ON_BOTH')
237
238
def test_workingmetadata_cq_done(self):
239
"""CQ Done when in WORKING_ON_METADATA."""
240
self.check('WORKING_ON_METADATA', 'SYS_CONTENT_QUEUE_DONE',
241
'WORKING_ON_METADATA', in_log=True)
242
243
def test_workingcontent_mq_waiting(self):
244
"""MQ Waiting when in WORKING_ON_CONTENT."""
245
self.check('WORKING_ON_CONTENT', 'SYS_META_QUEUE_WAITING',
246
'WORKING_ON_BOTH')
247
self.assertEqual(self.aq.execs, ['MQ'])
248
249
def test_workingcontent_mq_done(self):
250
"""MQ Done when in WORKING_ON_CONTENT."""
251
self.check('WORKING_ON_CONTENT', 'SYS_META_QUEUE_DONE',
252
'WORKING_ON_CONTENT', in_log=True)
253
254
def test_workingcontent_cq_waiting(self):
255
"""CQ Waiting when in WORKING_ON_CONTENT."""
256
self.check('WORKING_ON_CONTENT', 'SYS_CONTENT_QUEUE_WAITING',
257
'WORKING_ON_CONTENT')
258
self.assertEqual(self.aq.execs, ['CQ'])
259
260
def test_workingcontent_cq_done(self):
261
"""CQ Done when in WORKING_ON_CONTENT."""
262
self.check('WORKING_ON_CONTENT', 'SYS_CONTENT_QUEUE_DONE', 'IDLE')
263
264
def test_workingboth_mq_waiting(self):
265
"""MQ Waiting when in WORKING_ON_BOTH."""
266
self.check('WORKING_ON_BOTH', 'SYS_META_QUEUE_WAITING',
267
'WORKING_ON_BOTH')
268
self.assertEqual(self.aq.execs, ['MQ'])
269
270
def test_workingboth_mq_done(self):
271
"""MQ Done when in WORKING_ON_BOTH."""
272
self.check('WORKING_ON_BOTH', 'SYS_META_QUEUE_DONE',
273
'WORKING_ON_CONTENT')
274
self.assertEqual(self.aq.execs, ['CQ'])
275
276
def test_workingboth_cq_waiting(self):
277
"""CQ Waiting when in WORKING_ON_BOTH."""
278
self.check('WORKING_ON_BOTH', 'SYS_CONTENT_QUEUE_WAITING',
279
'WORKING_ON_BOTH')
280
281
def test_workingboth_cq_done(self):
282
"""CQ Done when in WORKING_ON_BOTH."""
283
self.check('WORKING_ON_BOTH', 'SYS_CONTENT_QUEUE_DONE',
284
'WORKING_ON_METADATA')
184
def test_idle_waiting(self):
185
"""Waiting when in IDLE."""
186
self.check('IDLE', 'SYS_QUEUE_WAITING', 'WORKING')
187
188
def test_idle_done(self):
189
"""Done when in IDLE."""
190
self.check('IDLE', 'SYS_QUEUE_DONE', 'IDLE', in_log=True)
191
192
def test_working_waiting(self):
193
"""Waiting when in WORKING."""
194
self.check('WORKING', 'SYS_QUEUE_WAITING', 'WORKING', in_log=True)
195
196
def test_working_done(self):
197
"""Done when in WORKING."""
198
self.check('WORKING', 'SYS_QUEUE_DONE', 'IDLE')
285
199
286
200
287
201
class TestQueueManagerFromOutside(QueueBase):
288
"""Getting into QueueManager."""
202
"""Getting in/out QueueManager."""
289
203
290
def test_idle(self):
204
def test_into_idle(self):
291
205
"""Entering when IDLE."""
206
assert not self.aq.queue.active
292
207
self.qm.state = QueueManager.IDLE
293
208
self.sm.state = StateManager.SERVER_RESCAN
294
209
self.sm.handle_default('SYS_SERVER_RESCAN_DONE')
295
210
self.assertEqual(self.qm.state, QueueManager.IDLE)
296
self.assertEqual(self.aq.execs, [])
297
298
def test_workingmeta(self):
299
"""Entering when WORKING_ON_METADATA."""
300
self.qm.state = QueueManager.WORKING_ON_METADATA
301
self.sm.state = StateManager.SERVER_RESCAN
302
self.sm.handle_default('SYS_SERVER_RESCAN_DONE')
303
self.assertEqual(self.qm.state, QueueManager.WORKING_ON_METADATA)
304
self.assertEqual(self.aq.execs, ['MQ'])
305
306
def test_workingcontent(self):
307
"""Entering when WORKING_ON_CONTENT."""
308
self.qm.state = QueueManager.WORKING_ON_CONTENT
309
self.sm.state = StateManager.SERVER_RESCAN
310
self.sm.handle_default('SYS_SERVER_RESCAN_DONE')
311
self.assertEqual(self.qm.state, QueueManager.WORKING_ON_CONTENT)
312
self.assertEqual(self.aq.execs, ['CQ'])
313
314
def test_workingboth(self):
315
"""Entering when WORKING_ON_BOTH."""
316
self.qm.state = QueueManager.WORKING_ON_BOTH
317
self.sm.state = StateManager.SERVER_RESCAN
318
self.sm.handle_default('SYS_SERVER_RESCAN_DONE')
319
self.assertEqual(self.qm.state, QueueManager.WORKING_ON_BOTH)
320
self.assertEqual(self.aq.execs, ['MQ'])
321
322
323
class TestQueueManagerRunQueues(QueueBase):
324
"""QueueManager run the queues when it should."""
325
326
def test_mq_run_something_yes(self):
327
"""MQ.run() is executed when something in the queue and working."""
328
self.sm.state = StateManager.QUEUE_MANAGER
329
self.qm._run(self.qm.mq)
330
self.assertEqual(self.aq.execs, ['MQ'])
331
332
def test_cq_run_something_yes(self):
333
"""CQ.run() is executed when something in the queue and working."""
334
self.sm.state = StateManager.QUEUE_MANAGER
335
self.qm._run(self.qm.cq)
336
self.assertEqual(self.aq.execs, ['CQ'])
337
338
def test_mq_run_something_noqueue(self):
339
"""MQ.run() is not executed if nothing in the queue."""
340
self.qm.mq.jobs[:] = []
341
self.sm.state = StateManager.QUEUE_MANAGER
342
self.qm._run(self.qm.mq)
343
self.assertEqual(self.aq.execs, [])
344
345
def test_cq_run_something_noqueue(self):
346
"""CQ.run() is not executed if nothing in the queue."""
347
self.qm.cq.jobs[:] = []
348
self.sm.state = StateManager.QUEUE_MANAGER
349
self.qm._run(self.qm.cq)
350
self.assertEqual(self.aq.execs, [])
351
352
def test_mq_run_something_noworking(self):
353
"""MQ.run() is not executed if not working."""
354
self.sm.state = StateManager.INIT # just not QM
355
self.qm._run(self.qm.mq)
356
self.assertEqual(self.aq.execs, [])
357
358
def test_cq_run_something_noworking(self):
359
"""CQ.run() is not executed if not working."""
360
self.sm.state = StateManager.INIT # just not QM
361
self.qm._run(self.qm.cq)
362
self.assertEqual(self.aq.execs, [])
363
364
365
class TestQueueManagerBehaviour(Base):
366
"""Behaviour of QueueManager when managing queues.
367
368
The rules of who is sending us events are defined in the FakeQueues above.
369
"""
370
371
def setUp(self):
372
Base.setUp(self)
373
self.sm.state = StateManager.QUEUE_MANAGER
374
375
def execute_test(self, events, should_happen):
376
"""Execute the test."""
377
for evt in events:
378
self.qm.on_event(evt)
379
self.assertEqual(self.aq.execs, should_happen)
380
self.assertEqual(self.qm.state, QueueManager.IDLE)
381
382
def test_onlyMQ(self):
383
"""Only MQ."""
384
self.qm.mq.queue(defer.succeed(True))
385
self.assertEqual(self.aq.execs, ['MQ'])
386
self.assertEqual(self.qm.state, QueueManager.IDLE)
387
388
def test_onlyCQ(self):
389
"""Only CQ."""
390
self.qm.cq.queue(defer.succeed(True))
391
self.assertEqual(self.aq.execs, ['CQ'])
392
self.assertEqual(self.qm.state, QueueManager.IDLE)
393
394
def test_mixed_simple(self):
395
"""A couple of both, sequential."""
396
self.qm.mq.queue(defer.succeed(True))
397
self.qm.cq.queue(defer.succeed(True))
398
self.qm.mq.queue(defer.succeed(True))
399
self.qm.cq.queue(defer.succeed(True))
400
self.assertEqual(self.aq.execs, ['MQ', 'CQ', 'MQ', 'CQ'])
401
self.assertEqual(self.qm.state, QueueManager.IDLE)
402
403
def test_workingCQ_stillCQ(self):
404
"""Has CQ pending when finishing CQ."""
405
d = defer.Deferred()
406
self.qm.cq.queue(d)
407
self.qm.cq.queue(defer.succeed(True))
408
d.callback(True)
409
410
self.assertEqual(self.aq.execs, ['CQ', 'CQ'])
411
self.assertEqual(self.qm.state, QueueManager.IDLE)
412
413
def test_workingCQ_stillMQ_first_ends_CQ(self):
414
"""Has MQ pending when finishing CQ, then CQ finishes first."""
415
dc = defer.Deferred()
416
dm = defer.Deferred()
417
self.qm.cq.queue(dc)
418
self.qm.mq.queue(dm)
419
dc.callback(True)
420
dm.callback(True)
421
422
self.assertEqual(self.aq.execs, ['CQ', 'MQ'])
423
self.assertEqual(self.qm.state, QueueManager.IDLE)
424
425
def test_workingCQ_stillMQ_first_ends_MQ(self):
426
"""Has MQ pending when finishing CQ, then MQ finishes first."""
427
dc = defer.Deferred()
428
dm = defer.Deferred()
429
self.qm.cq.queue(dc)
430
self.qm.mq.queue(dm)
431
dm.callback(True)
432
dc.callback(True)
433
434
self.assertEqual(self.aq.execs, ['CQ', 'MQ'])
435
self.assertEqual(self.qm.state, QueueManager.IDLE)
436
437
def test_workingMQ_stillCQ(self):
438
"""Has CQ pending when finishing MQ."""
439
d = defer.Deferred()
440
self.qm.mq.queue(d)
441
self.qm.cq.queue(defer.succeed(True))
442
d.callback(True)
443
444
self.assertEqual(self.aq.execs, ['MQ', 'CQ'])
445
self.assertEqual(self.qm.state, QueueManager.IDLE)
446
447
def test_workingMQ_stillMQ(self):
448
"""Has MQ pending when finishing MQ."""
449
d = defer.Deferred()
450
self.qm.mq.queue(d)
451
self.qm.mq.queue(defer.succeed(True))
452
d.callback(True)
453
454
self.assertEqual(self.aq.execs, ['MQ', 'MQ'])
455
self.assertEqual(self.qm.state, QueueManager.IDLE)
456
457
def test_workingCQ_still_both_cm(self):
458
"""Has both pending (C-M) when finishing CQ."""
459
dc = defer.Deferred()
460
dm = defer.Deferred()
461
self.qm.cq.queue(dc)
462
self.qm.cq.queue(defer.succeed(True))
463
self.qm.mq.queue(dm)
464
dc.callback(True)
465
dm.callback(True)
466
467
self.assertEqual(self.aq.execs, ['CQ', 'CQ', 'MQ'])
468
self.assertEqual(self.qm.state, QueueManager.IDLE)
469
470
def test_workingCQ_still_both_mc(self):
471
"""Has both pending (M-C) when finishing CQ."""
472
dc = defer.Deferred()
473
dm = defer.Deferred()
474
self.qm.cq.queue(dc)
475
self.qm.mq.queue(dm)
476
self.qm.cq.queue(defer.succeed(True))
477
dm.callback(True)
478
dc.callback(True)
479
480
self.assertEqual(self.aq.execs, ['CQ', 'MQ', 'CQ'])
481
self.assertEqual(self.qm.state, QueueManager.IDLE)
482
483
def test_workingMQ_still_both_mc(self):
484
"""Has both pending (M-C) when finishing MQ."""
485
dc = defer.Deferred()
486
dm = defer.Deferred()
487
self.qm.mq.queue(dm)
488
self.qm.mq.queue(defer.succeed(True))
489
self.qm.cq.queue(dc)
490
dm.callback(True)
491
dc.callback(True)
492
493
self.assertEqual(self.aq.execs, ['MQ', 'MQ', 'CQ'])
494
self.assertEqual(self.qm.state, QueueManager.IDLE)
495
496
def test_workingMQ_still_both_cm(self):
497
"""Has both pending (C-M) when finishing MQ."""
498
# this is the assymetric one that gives MQ higher priority!
499
dc = defer.Deferred()
500
dm = defer.Deferred()
501
self.qm.mq.queue(dm)
502
self.qm.cq.queue(defer.succeed(True))
503
self.qm.mq.queue(dc)
504
dm.callback(True)
505
dc.callback(True)
506
507
self.assertEqual(self.aq.execs, ['MQ', 'MQ', 'CQ'])
508
self.assertEqual(self.qm.state, QueueManager.IDLE)
509
211
self.assertTrue(self.aq.queue.active)
212
213
def test_into_working(self):
214
"""Entering when WORKING."""
215
assert not self.aq.queue.active
216
self.qm.state = QueueManager.WORKING
217
self.sm.state = StateManager.SERVER_RESCAN
218
self.sm.handle_default('SYS_SERVER_RESCAN_DONE')
219
self.assertEqual(self.qm.state, QueueManager.WORKING)
220
self.assertTrue(self.aq.queue.active)
510
221
511
222
512
223
class TestConnectionManager(Base):
627
338
self.assertTrue(new_node is None) # if working, it should return a node
628
339
629
340
630
631
341
class TestConnectionManagerTimings(Base):
632
342
"""Times handled by ConnectionManager."""
633
343
675
385
self.assertEqual(self.sm.connection.waiting_timeout, t)
676
386
677
387
678
679
388
class StateManagerTransitions(Base):
680
389
"""Base class for all transition tests."""
681
390
702
411
return self.wait_event('SYS_STATE_CHANGED')
703
412
704
413
705
706
414
class TestStateManagerHighLevelTransitions(StateManagerTransitions):
707
415
"""Test StateManager high level transitions."""
708
416
799
507
"""Don't make transition, and don't log warning."""
800
508
nodes = ['INIT', 'READY', 'STANDOFF', 'QUEUE_MANAGER'] # examples
801
509
d = []
802
for event in ('SYS_META_QUEUE_WAITING', 'SYS_META_QUEUE_DONE',
803
'SYS_CONTENT_QUEUE_WAITING', 'SYS_CONTENT_QUEUE_DONE'):
510
for event in ('SYS_QUEUE_WAITING', 'SYS_QUEUE_DONE'):
804
511
node = nodes.pop()
805
512
d.append(self.check(node, event, node))
806
513
return defer.DeferredList(d)
815
522
self.sm.handle_default(event)
816
523
return self.wait_event('SYS_STATE_CHANGED')
817
524
818
def test_IDLE_SYS_META_QUEUE_WAITING(self):
819
"""Transition from IDLE when SYS_META_QUEUE_WAITING."""
820
return self.check('IDLE', 'SYS_META_QUEUE_WAITING')
821
822
def test_IDLE_SYS_CONTENT_QUEUE_WAITING(self):
823
"""Transition from IDLE when SYS_CONTENT_QUEUE_WAITING."""
824
return self.check('IDLE', 'SYS_CONTENT_QUEUE_WAITING')
825
826
def test_WORKING_ON_METADATA_SYS_META_QUEUE_DONE(self):
827
"""Transition from WORKING_ON_METADATA when SYS_META_QUEUE_DONE."""
828
return self.check('WORKING_ON_METADATA', 'SYS_META_QUEUE_DONE')
829
830
def test_WORKING_ON_METADATA_SYS_CONTENT_QUEUE_WAITING(self):
831
"""Transition from WORKING_ON_METADATA when CONTENT_QUEUE_WAITING."""
832
return self.check('WORKING_ON_METADATA', 'SYS_CONTENT_QUEUE_WAITING')
833
834
def test_WORKING_ON_CONTENT_SYS_META_QUEUE_WAITING(self):
835
"""Transition from WORKING_ON_CONTENT when SYS_META_QUEUE_WAITING."""
836
return self.check('WORKING_ON_CONTENT', 'SYS_META_QUEUE_WAITING')
837
838
def test_WORKING_ON_CONTENT_SYS_CONTENT_QUEUE_DONE(self):
839
"""Transition from WORKING_ON_CONTENT when SYS_CONTENT_QUEUE_DONE."""
840
return self.check('WORKING_ON_CONTENT', 'SYS_CONTENT_QUEUE_DONE')
841
842
def test_WORKING_ON_BOTH_SYS_META_QUEUE_DONE(self):
843
"""Transition from WORKING_ON_BOTH when SYS_META_QUEUE_DONE."""
844
return self.check('WORKING_ON_BOTH', 'SYS_META_QUEUE_DONE')
845
846
def test_WORKING_ON_BOTH_SYS_CONTENT_QUEUE_DONE(self):
847
"""Transition from WORKING_ON_BOTH when SYS_CONTENT_QUEUE_DONE."""
848
return self.check('WORKING_ON_BOTH', 'SYS_CONTENT_QUEUE_DONE')
849
525
def test_IDLE_SYS_QUEUE_WAITING(self):
526
"""Transition from IDLE when SYS_QUEUE_WAITING."""
527
return self.check('IDLE', 'SYS_QUEUE_WAITING')
528
529
def test_WORKING_SYS_QUEUE_DONE(self):
530
"""Transition from WORKING when SYS_QUEUE_DONE."""
531
return self.check('WORKING', 'SYS_QUEUE_DONE')
850
532
851
533
852
534
class TestStateManagerNetworkTransitions(StateManagerTransitions):
911
593
return defer.DeferredList(d)
912
594
913
595
914
915
596
class TestStateManagerTimeoutTransitions(StateManagerTransitions):
916
597
"""Test StateManager when HandshakeTimeouts."""
917
598
945
626
'STANDOFF', True)
946
627
947
628
629
class TestStateManagerShutdown(StateManagerTransitions):
630
"""Test StateManager when shutting down."""
631
632
def test_shutdown(self):
633
"""All nodes go to SHUTDOWN."""
634
d = []
635
for node in self.sm_allnodes:
636
d.append(self.check(node, 'SYS_QUIT', 'SHUTDOWN'))
637
return defer.DeferredList(d)
638
948
639
949
640
class TestStateManagerErrors(StateManagerTransitions):
950
641
"""Test StateManager on error conditions."""
974
665
return defer.DeferredList(d)
975
666
976
667
977
978
668
class TestStateManagerEnterExit(Base):
979
669
"""Test StateManager on enter and exit transitions."""
980
670
1144
834
events = ('SYS_NET_DISCONNECTED', 'SYS_USER_DISCONNECT',
1145
835
'SYS_CONNECTION_LOST')
1146
836
for event in events:
837
self.aq.queue.active = True
1147
838
self.sm.state = StateManager.QUEUE_MANAGER
1148
839
self.sm.handle_default(event)
1149
# we just count the cleanups because there're some on_enter mixed
1150
# from STANDOFF
1151
self.assertEqual(self.aq.actions.count('cleanup'), 3)
1152
840
self.assertFalse(self.aq.queue.active)
1153
841
1154
842
1155
843
class TestStateManagerPassToNetworkManager(Base):
1227
915
self.assertEqual(self.called_events, [event]*cnt)
1228
916
1229
917
def test_meta_waiting(self):
1230
"""SYS_META_QUEUE_WAITING should go to QueueMgr no matter where."""
1231
self._test('SYS_META_QUEUE_WAITING')
918
"""SYS_QUEUE_WAITING should go to QueueMgr no matter where."""
919
self._test('SYS_QUEUE_WAITING')
1232
920
1233
921
def test_meta_done(self):
1234
"""SYS_META_QUEUE_DONE should go to QueueMgr no matter where."""
1235
self._test('SYS_META_QUEUE_DONE')
1236
1237
def test_content_waiting(self):
1238
"""SYS_CONTENT_QUEUE_WAITING should go to QueueMgr no matter where."""
1239
self._test('SYS_CONTENT_QUEUE_WAITING')
1240
1241
def test_content_done(self):
1242
"""SYS_CONTENT_QUEUE_DONE should go to QueueMgr no matter where."""
1243
self._test('SYS_CONTENT_QUEUE_DONE')
1244
922
"""SYS_QUEUE_DONE should go to QueueMgr no matter where."""
923
self._test('SYS_QUEUE_DONE')
1245
924
1246
925
1247
926
class TestStateManagerAPI(Base):
1331
1010
self.sm.state = StateManager.STANDOFF
1332
1011
self.check_node("STANDOFF", error=False, conn=True, online=False)
1333
1012
1013
def test_SHUTDOWN(self):
1014
"""SHUTDOWN internals."""
1015
self.sm.state = StateManager.SHUTDOWN
1016
self.check_node("SHUTDOWN", error=False, conn=False, online=False)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1