← Back to branch summary

~andreserl/+junk/ensemble

« back to all changes in this revision

Viewing changes to ensemble/providers/common/tests/test_findzookeepers.py

merge from lp:~fwereade/ensemble/cobbler-launch-macine

Show diffs side-by-side

added added

removed removed

Lines of Context:
ensemble/providers/common/tests/test_findzookeepers.py
 
1
from twisted.internet.defer import fail, succeed
 
2
 
 
3
from ensemble.errors import (
 
4
    EnvironmentNotFound, EnvironmentPending, MachineNotFound, MachineNotReady)
 
5
from ensemble.lib.testing import TestCase
 
6
from ensemble.providers.common.findzookeepers import find_zookeepers
 
7
 
 
8
 
 
9
class DummyProvider(object):
 
10
 
 
11
    def __init__(self, state):
 
12
        self.state = state
 
13
 
 
14
    def load_state(self):
 
15
        return succeed(self.state)
 
16
 
 
17
 
 
18
class FindZookeepersTest(TestCase):
 
19
 
 
20
    def test_no_state(self):
 
21
        provider = DummyProvider(False)
 
22
        d = find_zookeepers(provider, self.mocker.mock())
 
23
        self.assertFailure(d, EnvironmentNotFound)
 
24
        return d
 
25
 
 
26
    def test_empty_state(self):
 
27
        provider = DummyProvider({})
 
28
        d = find_zookeepers(provider, self.mocker.mock())
 
29
        self.assertFailure(d, EnvironmentNotFound)
 
30
        return d
 
31
 
 
32
    def test_get_machine_error_aborts(self):
 
33
        provider = DummyProvider({"zookeeper-instances": ["porter", "carter"]})
 
34
        get_machine = self.mocker.mock()
 
35
        get_machine(provider, "porter")
 
36
 
 
37
        class SomeError(Exception):
 
38
            pass
 
39
        self.mocker.result(fail(SomeError()))
 
40
        self.mocker.replay()
 
41
 
 
42
        d = find_zookeepers(provider, get_machine)
 
43
        self.assertFailure(d, SomeError)
 
44
        return d
 
45
 
 
46
    def test_bad_machine(self):
 
47
        provider = DummyProvider({"zookeeper-instances": ["porter"]})
 
48
        get_machine = self.mocker.mock()
 
49
        get_machine(provider, "porter")
 
50
        self.mocker.result(fail(MachineNotFound("porter")))
 
51
        self.mocker.replay()
 
52
 
 
53
        d = find_zookeepers(provider, get_machine)
 
54
        self.assertFailure(d, EnvironmentNotFound)
 
55
        return d
 
56
 
 
57
    def test_pending_machine(self):
 
58
        provider = DummyProvider({"zookeeper-instances": ["porter"]})
 
59
        get_machine = self.mocker.mock()
 
60
        get_machine(provider, "porter")
 
61
        self.mocker.result(fail(MachineNotReady("porter")))
 
62
        self.mocker.replay()
 
63
 
 
64
        d = find_zookeepers(provider, get_machine)
 
65
        self.assertFailure(d, EnvironmentPending)
 
66
        return d
 
67
 
 
68
    def test_pending_overrides_bad(self):
 
69
        provider = DummyProvider({"zookeeper-instances": ["porter", "carter"]})
 
70
        get_machine = self.mocker.mock()
 
71
        get_machine(provider, "porter")
 
72
        self.mocker.result(fail(MachineNotReady("porter")))
 
73
        get_machine(provider, "carter")
 
74
        self.mocker.result(fail(MachineNotFound("carter")))
 
75
        self.mocker.replay()
 
76
 
 
77
        d = find_zookeepers(provider, get_machine)
 
78
        self.assertFailure(d, EnvironmentPending)
 
79
        return d
 
80
 
 
81
    def test_good_machine(self):
 
82
        provider = DummyProvider({"zookeeper-instances": ["porter"]})
 
83
        get_machine = self.mocker.mock()
 
84
        get_machine(provider, "porter")
 
85
        machine = object()
 
86
        self.mocker.result(succeed(machine))
 
87
        self.mocker.replay()
 
88
 
 
89
        d = find_zookeepers(provider, get_machine)
 
90
 
 
91
        def verify_machine(result):
 
92
            self.assertEquals(result, [machine])
 
93
        d.addCallback(verify_machine)
 
94
        return d
 
95
 
 
96
    def test_first_good_always_wins(self):
 
97
        provider = DummyProvider(
 
98
            {"zookeeper-instances": ["porter", "carter", "miller", "baker"]})
 
99
        get_machine = self.mocker.mock()
 
100
        get_machine(provider, "porter")
 
101
        self.mocker.result(fail(MachineNotFound("porter")))
 
102
        get_machine(provider, "carter")
 
103
        self.mocker.result(fail(MachineNotReady("carter")))
 
104
        get_machine(provider, "miller")
 
105
        machine = object()
 
106
        self.mocker.result(succeed(machine))
 
107
        self.mocker.replay()
 
108
 
 
109
        d = find_zookeepers(provider, get_machine)
 
110
 
 
111
        def verify_machine(result):
 
112
            self.assertEquals(result, [machine])
 
113
        d.addCallback(verify_machine)
 
114
        return d