← Back to branch summary

~therve/pyjuju/subordinates-relation-check

« back to all changes in this revision

Viewing changes to juju/providers/orchestra/tests/test_getmachines.py

  • Committer: Kapil Thangavelu
  • Author(s): Kapil Thangavelu
  • Date: 2013-02-01 18:24:47 UTC
  • mfrom: (611.2.1 drop-orchestra)
  • Revision ID: kapil.foss@gmail.com-20130201182447-a3qsgpgwqyeudikc
Drop orchestra provider support

The orchestra provider is dead upstream, and represents
a significant support burden on the code base. Given
hardware deployments are directed towards MaaS and no
current users, its better to drop this now.

R=
CC=
https://codereview.appspot.com/7225084

Show diffs side-by-side

added added

removed removed

Lines of Context:
juju/providers/orchestra/tests/test_getmachines.py
1
 
from twisted.internet.defer import fail, succeed
2
 
 
3
 
from juju.errors import MachinesNotFound
4
 
from juju.lib.testing import TestCase
5
 
from juju.providers.orchestra.machine import OrchestraMachine
6
 
 
7
 
from .common import OrchestraTestMixin
8
 
 
9
 
 
10
 
class SomeError(Exception):
11
 
    pass
12
 
 
13
 
 
14
 
class GetMachinesTest(TestCase, OrchestraTestMixin):
15
 
 
16
 
    def assert_not_found(self, d, instance_ids):
17
 
        self.assertFailure(d, MachinesNotFound)
18
 
 
19
 
        def verify(error):
20
 
            self.assertEquals(error.instance_ids, instance_ids)
21
 
        d.addCallback(verify)
22
 
        return d
23
 
 
24
 
    def assert_machine(self, machine, uid, name):
25
 
        self.assertTrue(isinstance(machine, OrchestraMachine))
26
 
        self.assertEquals(machine.instance_id, uid)
27
 
        self.assertEquals(machine.dns_name, name)
28
 
 
29
 
    def _system(self, uid, name, mgmt_classes):
30
 
        return {"uid": uid,
31
 
                "name": name,
32
 
                "mgmt_classes": mgmt_classes,
33
 
                "netboot_enabled": True}
34
 
 
35
 
    def mock_get_systems_success(self):
36
 
        self.proxy_m.callRemote("get_systems")
37
 
        self.mocker.result(succeed([
38
 
            self._system("foo", "irrelevant", ["bad"]),
39
 
            self._system("bar", "barrr", ["acquired"]),
40
 
            self._system("baz", "bazzz", ["acquired"])]))
41
 
 
42
 
    def test_multiple_success(self):
43
 
        self.setup_mocks()
44
 
        self.mock_get_systems_success()
45
 
        self.mocker.replay()
46
 
 
47
 
        provider = self.get_provider()
48
 
        d = provider.get_machines()
49
 
 
50
 
        def verify(result):
51
 
            (bar, baz) = result
52
 
            self.assert_machine(bar, "bar", "barrr")
53
 
            self.assert_machine(baz, "baz", "bazzz")
54
 
        d.addCallback(verify)
55
 
        return d
56
 
 
57
 
    def test_multiple_failure(self):
58
 
        self.setup_mocks()
59
 
        self.mock_get_systems_success()
60
 
        self.mocker.replay()
61
 
 
62
 
        provider = self.get_provider()
63
 
        d = provider.get_machines(["foo", "bar"])
64
 
        return self.assert_not_found(d, ["foo"])
65
 
 
66
 
    def test_multiple_error(self):
67
 
        self.setup_mocks()
68
 
        self.proxy_m.callRemote("get_systems")
69
 
        self.mocker.result(fail(SomeError()))
70
 
        self.mocker.replay()
71
 
 
72
 
        provider = self.get_provider()
73
 
        d = provider.get_machines(["foo", "bar"])
74
 
        self.assertFailure(d, SomeError)
75
 
        return d
76
 
 
77
 
    def test_one_success(self):
78
 
        self.setup_mocks()
79
 
        self.mock_get_systems_success()
80
 
        self.mocker.replay()
81
 
 
82
 
        provider = self.get_provider()
83
 
        d = provider.get_machine("bar")
84
 
        d.addCallback(self.assert_machine, "bar", "barrr")
85
 
        return d
86
 
 
87
 
    def test_one_failure(self):
88
 
        self.setup_mocks()
89
 
        self.mock_get_systems_success()
90
 
        self.mocker.replay()
91
 
 
92
 
        provider = self.get_provider()
93
 
        d = provider.get_machine("foo")
94
 
        return self.assert_not_found(d, ["foo"])
95
 
 
96
 
    def test_one_error(self):
97
 
        self.setup_mocks()
98
 
        self.proxy_m.callRemote("get_systems")
99
 
        self.mocker.result(fail(SomeError()))
100
 
        self.mocker.replay()
101
 
 
102
 
        provider = self.get_provider()
103
 
        d = provider.get_machine("foo")
104
 
        self.assertFailure(d, SomeError)
105
 
        return d