← Back to branch summary

~fwereade/pyjuju/document-relation-set-empty

« back to all changes in this revision

Viewing changes to ensemble/providers/orchestra/tests/test_cobbler.py

  • Committer: William Reade
  • Date: 2011-08-17 09:17:06 UTC
  • mfrom: (306.1.24 hide-instances)
  • Revision ID: fwereade@gmail.com-20110817091706-2zg0we3co9xqrwfk
simplified instance-getting; ec2 no longer filters 'pending' instances, to better match orchestra behaviour; several error types/messages reworked

Show diffs side-by-side

added added

removed removed

Lines of Context:
ensemble/providers/orchestra/tests/test_cobbler.py
4
4
from twisted.web.xmlrpc import Proxy
5
5
 
6
6
from ensemble.errors import (
7
 
    MachineNotFound, ProviderError, ProviderInteractionError)
 
7
    MachinesNotFound, ProviderError, ProviderInteractionError)
8
8
from ensemble.lib.testing import TestCase
9
9
from ensemble.providers.orchestra.cobbler import CobblerCaller, CobblerClient
10
10
 
226
226
                                {"power": "on", "systems": ["some-name"]}, "")
227
227
        self.mocker.result(result)
228
228
 
 
229
    def mock_get_systems(self, result):
 
230
        self.proxy_m.callRemote("get_systems")
 
231
        self.mocker.result(result)
 
232
 
229
233
    def call_cobbler_method(self, method_name, *args, **kwargs):
230
234
        cobbler = CobblerClient(_CONFIG)
231
235
        method = getattr(cobbler, method_name)
232
236
        return method(*args, **kwargs)
233
237
 
 
238
    def check_not_found(self, d, uids=["some-uid"]):
 
239
        self.assertFailure(d, MachinesNotFound)
 
240
 
 
241
        def verify(error):
 
242
            self.assertEquals(error.instance_ids, uids)
 
243
        d.addCallback(verify)
 
244
        return d
 
245
 
 
246
    def check_bad_call(self, d, method):
 
247
        self.assertFailure(d, ProviderError)
 
248
 
 
249
        def verify(error):
 
250
            self.assertIn("Bad result from call to %s" % method, str(error))
 
251
        d.addCallback(verify)
 
252
        return d
 
253
 
234
254
    def check_get_name_failure(self, method_name, *args, **kwargs):
235
255
        self.setup_mock()
236
256
        self.mock_get_name(succeed([]))
237
257
        self.mocker.replay()
238
258
        d = self.call_cobbler_method(method_name, *args, **kwargs)
239
 
        self.assertFailure(d, MachineNotFound)
240
 
        return d
 
259
        return self.check_not_found(d)
241
260
 
242
261
    def check_get_name_insane(self, method_name, *args, **kwargs):
243
262
        self.setup_mock()
275
294
        self.mock_get_system(succeed("~"))
276
295
        self.mocker.replay()
277
296
        d = self.call_cobbler_method("describe_system", "some-uid")
278
 
        self.assertFailure(d, MachineNotFound)
279
 
        return d
 
297
        return self.check_not_found(d)
280
298
 
281
299
    def test_describe_system_get_system_error(self):
282
300
        self.setup_mock()
319
337
        self.mocker.replay()
320
338
        d = self.call_cobbler_method(
321
339
            "set_on_system", "some-uid", "don't", "care")
322
 
        self.assertFailure(d, MachineNotFound)
323
 
        return d
 
340
        return self.check_not_found(d)
324
341
 
325
342
    def test_set_on_system_get_system_handle_unknown_fault(self):
326
343
        self.setup_mock()
350
367
        self.mocker.replay()
351
368
        d = self.call_cobbler_method(
352
369
            "set_on_system", "some-uid", "some-key", "some-value")
353
 
        self.assertFailure(d, ProviderError)
354
 
        return d
 
370
        return self.check_bad_call(d, "modify_system")
355
371
 
356
372
    def test_set_on_system_modify_system_error(self):
357
373
        self.setup_mock()
373
389
        self.mocker.replay()
374
390
        d = self.call_cobbler_method(
375
391
            "set_on_system", "some-uid", "some-key", "some-value")
376
 
        self.assertFailure(d, ProviderError)
377
 
        return d
 
392
        return self.check_bad_call(d, "save_system")
378
393
 
379
394
    def test_set_on_system_save_system_error(self):
380
395
        self.setup_mock()
458
473
        self.mock_get_name(succeed([]))
459
474
        self.mocker.replay()
460
475
        d = self.call_cobbler_method("acquire_system")
461
 
        self.assertFailure(d, MachineNotFound)
462
 
        return d
 
476
        return self.check_not_found(d)
463
477
 
464
478
    def test_acquire_system_get_name_error(self):
465
479
        self.setup_mock()
480
494
            Fault("blah", "blah unknown system name blah")))
481
495
        self.mocker.replay()
482
496
        d = self.call_cobbler_method("acquire_system")
483
 
        self.assertFailure(d, MachineNotFound)
484
 
        return d
 
497
        return self.check_not_found(d)
485
498
 
486
499
    def test_acquire_system_get_system_handle_unknown_fault(self):
487
500
        self.setup_mock()
515
528
                                "mgmt_classes", ["preserve_me", "acquired"])
516
529
        self.mocker.replay()
517
530
        d = self.call_cobbler_method("acquire_system")
518
 
        self.assertFailure(d, ProviderError)
519
 
        return d
 
531
        return self.check_bad_call(d, "modify_system")
520
532
 
521
533
    def test_acquire_system_modify_system_error(self):
522
534
        self.setup_mock()
542
554
        self.mock_save_system(succeed(False))
543
555
        self.mocker.replay()
544
556
        d = self.call_cobbler_method("acquire_system")
545
 
        self.assertFailure(d, ProviderError)
546
 
        return d
 
557
        return self.check_bad_call(d, "save_system")
547
558
 
548
559
    def test_acquire_system_save_system_error(self):
549
560
        self.setup_mock()
593
604
            Fault("blah", "blah unknown system name blah")))
594
605
        self.mocker.replay()
595
606
        d = self.call_cobbler_method("start_system", "some-uid")
596
 
        self.assertFailure(d, MachineNotFound)
597
 
        return d
 
607
        return self.check_not_found(d)
598
608
 
599
609
    def test_start_system_get_system_handle_unknown_fault(self):
600
610
        self.setup_mock()
621
631
        self.mock_modify_system(succeed(False), "netboot_enabled", True)
622
632
        self.mocker.replay()
623
633
        d = self.call_cobbler_method("start_system", "some-uid")
624
 
        self.assertFailure(d, ProviderError)
625
 
        return d
 
634
        return self.check_bad_call(d, "modify_system")
626
635
 
627
636
    def test_start_system_modify_system_error(self):
628
637
        self.setup_mock()
642
651
        self.mock_save_system(succeed(False))
643
652
        self.mocker.replay()
644
653
        d = self.call_cobbler_method("start_system", "some-uid")
645
 
        self.assertFailure(d, ProviderError)
646
 
        return d
 
654
        return self.check_bad_call(d, "save_system")
647
655
 
648
656
    def test_start_system_save_system_error(self):
649
657
        self.setup_mock()
678
686
        self.mocker.replay()
679
687
        d = self.call_cobbler_method("start_system", "some-uid")
680
688
        return d
 
689
 
 
690
    def test_describe_systems_error(self):
 
691
        self.setup_mock()
 
692
        self.mock_get_systems(fail(SomeError()))
 
693
        self.mocker.replay()
 
694
        d = self.call_cobbler_method("describe_systems")
 
695
        self.assertFailure(d, SomeError)
 
696
        return d
 
697
 
 
698
    def test_describe_systems_failure(self):
 
699
        self.setup_mock()
 
700
        self.mock_get_systems(succeed([
 
701
            {"uid": "something-else", "mgmt_classes": "acquired"}]))
 
702
        self.mocker.replay()
 
703
        d = self.call_cobbler_method("describe_systems", "something")
 
704
        return self.check_not_found(d, ["something"])
 
705
 
 
706
    def test_describe_systems_success_all(self):
 
707
        self.setup_mock()
 
708
        self.mock_get_systems(succeed([
 
709
            {"uid": "bar", "mgmt_classes": ["acquired"]},
 
710
            {"uid": "baz", "mgmt_classes": ["other"]},
 
711
            {"uid": "foo", "mgmt_classes": ["acquired"]}]))
 
712
        self.mocker.replay()
 
713
        d = self.call_cobbler_method("describe_systems")
 
714
 
 
715
        def verify(result):
 
716
            expect = [{"uid": "bar", "mgmt_classes": ["acquired"]},
 
717
                      {"uid": "foo", "mgmt_classes": ["acquired"]}]
 
718
            self.assertEquals(result, expect)
 
719
        d.addCallback(verify)
 
720
        return d
 
721
 
 
722
    def test_describe_systems_not_acquired_some(self):
 
723
        self.setup_mock()
 
724
        self.mock_get_systems(succeed([
 
725
            {"uid": "bar", "mgmt_classes": ["irrelevant"]},
 
726
            {"uid": "baz", "mgmt_classes": ["acquired"]},
 
727
            {"uid": "foo", "mgmt_classes": ["omg-b0rken"]}]))
 
728
        self.mocker.replay()
 
729
        d = self.call_cobbler_method("describe_systems", "foo", "baz")
 
730
        return self.check_not_found(d, ["foo"])
 
731
 
 
732
    def test_describe_systems_success_some(self):
 
733
        self.setup_mock()
 
734
        self.mock_get_systems(succeed([
 
735
            {"uid": "bar", "mgmt_classes": ["ignored"]},
 
736
            {"uid": "baz", "mgmt_classes": ["acquired"]},
 
737
            {"uid": "foo", "mgmt_classes": ["acquired"]}]))
 
738
        self.mocker.replay()
 
739
        d = self.call_cobbler_method("describe_systems", "foo", "baz")
 
740
 
 
741
        def verify(result):
 
742
            expect = [{"uid": "foo", "mgmt_classes": ["acquired"]},
 
743
                      {"uid": "baz", "mgmt_classes": ["acquired"]}]
 
744
            self.assertEquals(result, expect)
 
745
        d.addCallback(verify)
 
746
        return d
 
747
 
 
748
    def test_describe_systems_success_none(self):
 
749
        self.setup_mock()
 
750
        self.mock_get_systems(succeed([]))
 
751
        self.mocker.replay()
 
752
        d = self.call_cobbler_method("describe_systems")
 
753
 
 
754
        def verify(result):
 
755
            self.assertEquals(result, [])
 
756
        d.addCallback(verify)
 
757
        return d