← Back to branch summary

~lamont/maas/bug-1614584

« back to all changes in this revision

Viewing changes to src/provisioningserver/power/tests/test_change.py

  • Committer: MAAS Lander
  • Author(s): Blake Rouse
  • Date: 2016-11-30 15:12:47 UTC
  • mfrom: (5570.1.7 reorg-power-drivers)
  • Revision ID: maas_lander-20161130151247-bkx57gqe5auighsd
[r=newell-jensen][bug=][author=blake-rouse] Remove the src/provisioningserver/power/schema.py. Place the schema for each driver in the driver class. This makes it easier to add drivers without requiring code in two places.

Remove all the diskless code, as that used some of the old schema stuff and it was never used.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/provisioningserver/power/tests/test_change.py
25
25
from provisioningserver import power
26
26
from provisioningserver.drivers.power import (
27
27
    get_error_message as get_driver_error_message,
28
 
    power_drivers_by_name,
29
28
    PowerDriverRegistry,
30
29
    PowerError,
31
30
)
177
176
    def test___handles_power_driver_power_types(self):
178
177
        system_id = factory.make_name('system_id')
179
178
        hostname = factory.make_name('hostname')
180
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
179
        power_driver = random.choice([
 
180
            driver
 
181
            for _, driver in PowerDriverRegistry
 
182
            if driver.queryable
 
183
        ])
181
184
        power_change = random.choice(['on', 'off'])
182
185
        context = {
183
186
            factory.make_name('context-key'): factory.make_name('context-val')
193
196
        yield self.patch_rpc_methods()
194
197
 
195
198
        yield power.change.change_power_state(
196
 
            system_id, hostname, power_type, power_change, context)
 
199
            system_id, hostname, power_driver.name, power_change, context)
197
200
 
198
201
        self.expectThat(
199
202
            perform_power_driver_change, MockCalledOnceWith(
200
 
                system_id, hostname, power_type, power_change, context))
 
203
                system_id, hostname, power_driver.name, power_change, context))
201
204
        self.expectThat(
202
205
            perform_power_driver_query, MockCalledOnceWith(
203
 
                system_id, hostname, power_type, context))
 
206
                system_id, hostname, power_driver.name, context))
204
207
        self.expectThat(
205
208
            power_change_success, MockCalledOnceWith(
206
209
                system_id, hostname, power_change))
209
212
    def test__calls_power_driver_on_for_power_driver(self):
210
213
        system_id = factory.make_name('system_id')
211
214
        hostname = factory.make_name('hostname')
212
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
215
        power_driver = random.choice([
 
216
            driver
 
217
            for _, driver in PowerDriverRegistry
 
218
            if driver.queryable
 
219
        ])
213
220
        power_change = 'on'
214
221
        context = {
215
222
            factory.make_name('context-key'): factory.make_name('context-val')
223
230
        yield self.patch_rpc_methods()
224
231
 
225
232
        result = yield power.change.change_power_state(
226
 
            system_id, hostname, power_type, power_change, context)
 
233
            system_id, hostname, power_driver.name, power_change, context)
227
234
 
228
 
        self.expectThat(get_item, MockCalledOnceWith(power_type))
 
235
        self.expectThat(get_item, MockCalledOnceWith(power_driver.name))
229
236
        self.expectThat(
230
237
            perform_power_driver_query, MockCalledOnceWith(
231
 
                system_id, hostname, power_type, context))
 
238
                system_id, hostname, power_driver.name, context))
232
239
        self.expectThat(
233
240
            power.change.power_change_success, MockCalledOnceWith(
234
241
                system_id, hostname, power_change))
238
245
    def test__calls_power_driver_off_for_power_driver(self):
239
246
        system_id = factory.make_name('system_id')
240
247
        hostname = factory.make_name('hostname')
241
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
248
        power_driver = random.choice([
 
249
            driver
 
250
            for _, driver in PowerDriverRegistry
 
251
            if driver.queryable
 
252
        ])
242
253
        power_change = 'off'
243
254
        context = {
244
255
            factory.make_name('context-key'): factory.make_name('context-val')
252
263
        yield self.patch_rpc_methods()
253
264
 
254
265
        result = yield power.change.change_power_state(
255
 
            system_id, hostname, power_type, power_change, context)
 
266
            system_id, hostname, power_driver.name, power_change, context)
256
267
 
257
 
        self.expectThat(get_item, MockCalledOnceWith(power_type))
 
268
        self.expectThat(get_item, MockCalledOnceWith(power_driver.name))
258
269
        self.expectThat(
259
270
            perform_power_driver_query, MockCalledOnceWith(
260
 
                system_id, hostname, power_type, context))
 
271
                system_id, hostname, power_driver.name, context))
261
272
        self.expectThat(
262
273
            power.change.power_change_success, MockCalledOnceWith(
263
274
                system_id, hostname, power_change))
267
278
    def test__calls_power_driver_cycle_for_power_driver(self):
268
279
        system_id = factory.make_name('system_id')
269
280
        hostname = factory.make_name('hostname')
270
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
281
        power_driver = random.choice([
 
282
            driver
 
283
            for _, driver in PowerDriverRegistry
 
284
            if driver.queryable
 
285
        ])
271
286
        power_change = 'cycle'
272
287
        context = {
273
288
            factory.make_name('context-key'): factory.make_name('context-val')
281
296
        yield self.patch_rpc_methods()
282
297
 
283
298
        result = yield power.change.change_power_state(
284
 
            system_id, hostname, power_type, power_change, context)
 
299
            system_id, hostname, power_driver.name, power_change, context)
285
300
 
286
 
        self.expectThat(get_item, MockCalledOnceWith(power_type))
 
301
        self.expectThat(get_item, MockCalledOnceWith(power_driver.name))
287
302
        self.expectThat(
288
303
            perform_power_driver_query, MockCalledOnceWith(
289
 
                system_id, hostname, power_type, context))
 
304
                system_id, hostname, power_driver.name, context))
290
305
        self.expectThat(
291
306
            power.change.power_change_success, MockCalledOnceWith(
292
307
                system_id, hostname, 'on'))
296
311
    def test__marks_the_node_broken_if_exception_for_power_driver(self):
297
312
        system_id = factory.make_name('system_id')
298
313
        hostname = factory.make_name('hostname')
299
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
314
        power_driver = random.choice([
 
315
            driver
 
316
            for _, driver in PowerDriverRegistry
 
317
            if driver.queryable
 
318
        ])
300
319
        power_change = 'on'
301
320
        context = {
302
321
            factory.make_name('context-key'): factory.make_name('context-val'),
312
331
 
313
332
        with ExpectedException(PowerError):
314
333
            yield power.change.change_power_state(
315
 
                system_id, hostname, power_type, power_change, context)
 
334
                system_id, hostname, power_driver.name, power_change, context)
316
335
 
317
336
        error_message = "Power on for the node failed: %s" % (
318
337
            get_driver_error_message(exception))
328
347
    def setUp(self):
329
348
        super(TestMaybeChangePowerState, self).setUp()
330
349
        self.patch(power, 'power_action_registry', {})
331
 
        for power_driver in power_drivers_by_name.values():
 
350
        for _, power_driver in PowerDriverRegistry:
332
351
            self.patch(
333
352
                power_driver, "detect_missing_packages").return_value = []
334
353
        self.useFixture(EventTypesAllRegistered())
341
360
 
342
361
    def test_always_returns_deferred(self):
343
362
        clock = Clock()
344
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
363
        power_driver = random.choice([
 
364
            driver
 
365
            for _, driver in PowerDriverRegistry
 
366
            if driver.queryable
 
367
        ])
345
368
        d = power.change.maybe_change_power_state(
346
 
            sentinel.system_id, sentinel.hostname, power_type,
 
369
            sentinel.system_id, sentinel.hostname, power_driver.name,
347
370
            random.choice(("on", "off")), sentinel.context, clock=clock)
348
371
        self.assertThat(d, IsInstance(Deferred))
349
372
 
353
376
 
354
377
        system_id = factory.make_name('system_id')
355
378
        hostname = factory.make_name('hostname')
356
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
379
        power_driver = random.choice([
 
380
            driver
 
381
            for _, driver in PowerDriverRegistry
 
382
            if driver.queryable
 
383
        ])
357
384
        power_change = random.choice(['on', 'off', 'cycle'])
358
385
        context = {
359
386
            factory.make_name('context-key'): factory.make_name('context-val')
360
387
        }
361
388
 
362
389
        yield power.change.maybe_change_power_state(
363
 
            system_id, hostname, power_type, power_change, context)
 
390
            system_id, hostname, power_driver.name, power_change, context)
364
391
        self.assertEqual(
365
392
            {system_id: (power_change, ANY)},
366
393
            power.power_action_registry)
373
400
 
374
401
        system_id = factory.make_name('system_id')
375
402
        hostname = factory.make_name('hostname')
376
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
403
        power_driver = random.choice([
 
404
            driver
 
405
            for _, driver in PowerDriverRegistry
 
406
            if driver.queryable
 
407
        ])
377
408
        power_change = random.choice(['on', 'off', 'cycle'])
378
409
        context = {
379
410
            factory.make_name('context-key'): factory.make_name('context-val')
380
411
        }
381
 
        power_driver = power_drivers_by_name.get(power_type)
382
412
        yield power.change.maybe_change_power_state(
383
 
            system_id, hostname, power_type, power_change, context)
 
413
            system_id, hostname, power_driver.name, power_change, context)
384
414
        reactor.runUntilCurrent()  # Run all delayed calls.
385
415
        self.assertThat(
386
416
            power_driver.detect_missing_packages, MockCalledOnceWith())
391
421
 
392
422
        system_id = factory.make_name('system_id')
393
423
        hostname = factory.make_name('hostname')
394
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
424
        power_driver = random.choice([
 
425
            driver
 
426
            for _, driver in PowerDriverRegistry
 
427
            if driver.queryable
 
428
        ])
395
429
        power_change = random.choice(['on', 'off', 'cycle'])
396
430
        context = {
397
431
            factory.make_name('context-key'): factory.make_name('context-val')
398
432
        }
399
 
        power_driver = power_drivers_by_name.get(power_type)
400
433
        power_driver.detect_missing_packages.return_value = ['gone']
401
434
        with ExpectedException(exceptions.PowerActionFail):
402
435
            yield power.change.maybe_change_power_state(
403
 
                system_id, hostname, power_type, power_change, context)
 
436
                system_id, hostname, power_driver.name, power_change, context)
404
437
        self.assertThat(
405
438
            power_driver.detect_missing_packages, MockCalledOnceWith())
406
439
 
408
441
    def test_errors_when_change_conflicts_with_in_progress_change(self):
409
442
        system_id = factory.make_name('system_id')
410
443
        hostname = factory.make_name('hostname')
411
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
444
        power_driver = random.choice([
 
445
            driver
 
446
            for _, driver in PowerDriverRegistry
 
447
            if driver.queryable
 
448
        ])
412
449
        power_changes = ['on', 'off']
413
450
        random.shuffle(power_changes)
414
451
        current_power_change, power_change = power_changes
419
456
            current_power_change, sentinel.d)
420
457
        with ExpectedException(exceptions.PowerActionAlreadyInProgress):
421
458
            yield power.change.maybe_change_power_state(
422
 
                system_id, hostname, power_type, power_change, context)
 
459
                system_id, hostname, power_driver.name, power_change, context)
423
460
 
424
461
    @inlineCallbacks
425
462
    def test_does_nothing_when_change_matches_in_progress_change(self):
426
463
        system_id = factory.make_name('system_id')
427
464
        hostname = factory.make_name('hostname')
428
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
465
        power_driver = random.choice([
 
466
            driver
 
467
            for _, driver in PowerDriverRegistry
 
468
            if driver.queryable
 
469
        ])
429
470
        current_power_change = power_change = (
430
471
            random.choice(['on', 'off', 'cycle']))
431
472
        context = {
434
475
        power.power_action_registry[system_id] = (
435
476
            current_power_change, sentinel.d)
436
477
        yield power.change.maybe_change_power_state(
437
 
            system_id, hostname, power_type, power_change, context)
 
478
            system_id, hostname, power_driver.name, power_change, context)
438
479
        self.assertThat(power.power_action_registry, Equals(
439
480
            {system_id: (power_change, sentinel.d)}))
440
481
 
444
485
 
445
486
        system_id = factory.make_name('system_id')
446
487
        hostname = factory.make_name('hostname')
447
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
488
        power_driver = random.choice([
 
489
            driver
 
490
            for _, driver in PowerDriverRegistry
 
491
            if driver.queryable
 
492
        ])
448
493
        power_change = random.choice(['on', 'off', 'cycle'])
449
494
        context = {
450
495
            factory.make_name('context-key'): factory.make_name('context-val')
451
496
        }
452
497
 
453
498
        yield power.change.maybe_change_power_state(
454
 
            system_id, hostname, power_type, power_change, context)
 
499
            system_id, hostname, power_driver.name, power_change, context)
455
500
        reactor.runUntilCurrent()  # Run all delayed calls.
456
501
        self.assertThat(
457
502
            power.change.change_power_state,
458
503
            MockCalledOnceWith(
459
 
                system_id, hostname, power_type, power_change, context,
 
504
                system_id, hostname, power_driver.name, power_change, context,
460
505
                power.change.reactor))
461
506
 
462
507
    @inlineCallbacks
465
510
 
466
511
        system_id = factory.make_name('system_id')
467
512
        hostname = factory.make_name('hostname')
468
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
513
        power_driver = random.choice([
 
514
            driver
 
515
            for _, driver in PowerDriverRegistry
 
516
            if driver.queryable
 
517
        ])
469
518
        power_change = random.choice(['on', 'off', 'cycle'])
470
519
        context = {
471
520
            factory.make_name('context-key'): factory.make_name('context-val')
472
521
        }
473
522
 
474
523
        yield power.change.maybe_change_power_state(
475
 
            system_id, hostname, power_type, power_change, context)
 
524
            system_id, hostname, power_driver.name, power_change, context)
476
525
        reactor.runUntilCurrent()  # Run all delayed calls.
477
526
        self.assertNotIn(system_id, power.power_action_registry)
478
527
 
487
536
 
488
537
        system_id = factory.make_name('system_id')
489
538
        hostname = factory.make_hostname()
490
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
539
        power_driver = random.choice([
 
540
            driver
 
541
            for _, driver in PowerDriverRegistry
 
542
            if driver.queryable
 
543
        ])
491
544
        power_change = random.choice(['on', 'off', 'cycle'])
492
545
        context = sentinel.context
493
546
 
494
547
        logger = self.useFixture(TwistedLoggerFixture())
495
548
 
496
549
        yield power.change.maybe_change_power_state(
497
 
            system_id, hostname, power_type, power_change, context)
 
550
            system_id, hostname, power_driver.name, power_change, context)
498
551
        reactor.runUntilCurrent()  # Run all delayed calls.
499
552
        self.assertNotIn(system_id, power.power_action_registry)
500
553
        self.assertDocTestMatches(
516
569
 
517
570
        system_id = factory.make_name('system_id')
518
571
        hostname = factory.make_hostname()
519
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
572
        power_driver = random.choice([
 
573
            driver
 
574
            for _, driver in PowerDriverRegistry
 
575
            if driver.queryable
 
576
        ])
520
577
        power_change = random.choice(['on', 'off', 'cycle'])
521
578
        context = sentinel.context
522
579
 
523
580
        logger = self.useFixture(TwistedLoggerFixture())
524
581
 
525
582
        yield power.change.maybe_change_power_state(
526
 
            system_id, hostname, power_type, power_change, context)
 
583
            system_id, hostname, power_driver.name, power_change, context)
527
584
 
528
585
        # Get the Deferred from the registry and cancel it.
529
586
        _, d = power.power_action_registry[system_id]
547
604
 
548
605
        system_id = factory.make_name('system_id')
549
606
        hostname = factory.make_name('hostname')
550
 
        power_type = random.choice(power.QUERY_POWER_TYPES)
 
607
        power_driver = random.choice([
 
608
            driver
 
609
            for _, driver in PowerDriverRegistry
 
610
            if driver.queryable
 
611
        ])
551
612
        power_change = random.choice(['on', 'off', 'cycle'])
552
613
        context = {
553
614
            factory.make_name('context-key'): factory.make_name('context-val')
554
615
        }
555
616
 
556
617
        yield power.change.maybe_change_power_state(
557
 
            system_id, hostname, power_type, power_change, context)
 
618
            system_id, hostname, power_driver.name, power_change, context)
558
619
        reactor.runUntilCurrent()  # Run all delayed calls.
559
620
        self.assertThat(
560
621
            defer_with_timeout, MockCalledOnceWith(
561
622
                power.change.CHANGE_POWER_STATE_TIMEOUT,
562
623
                power.change.change_power_state, system_id, hostname,
563
 
                power_type, power_change, context, power.change.reactor))
 
624
                power_driver.name, power_change,
 
625
                context, power.change.reactor))