← Back to branch summary

~andreserl/maas/lp1665143

« back to all changes in this revision

Viewing changes to src/provisioningserver/rpc/tests/test_pods.py

Merged specify_scripts_commissioning into test_api.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/provisioningserver/rpc/tests/test_pods.py
15
15
    MAASTwistedRunTest,
16
16
)
17
17
from provisioningserver.drivers.pod import (
 
18
    DiscoveredMachine,
18
19
    DiscoveredPod,
19
20
    DiscoveredPodHints,
 
21
    RequestedMachine,
 
22
    RequestedMachineBlockDevice,
 
23
    RequestedMachineInterface,
20
24
)
21
25
from provisioningserver.drivers.pod.registry import PodDriverRegistry
22
26
from provisioningserver.rpc import (
50
54
            PodDriverRegistry, "get_item").return_value = fake_driver
51
55
        with ExpectedException(
52
56
                exceptions.PodActionFail,
53
 
                re.escape("bad pod driver; did not return Deferred.")):
 
57
                re.escape(
 
58
                    "bad pod driver '%s'; 'discover' did not "
 
59
                    "return Deferred." % fake_driver.name)):
54
60
            yield pods.discover_pod(fake_driver.name, {})
55
61
 
56
62
    @inlineCallbacks
74
80
            PodDriverRegistry, "get_item").return_value = fake_driver
75
81
        with ExpectedException(
76
82
                exceptions.PodActionFail,
77
 
                re.escape("bad pod driver; invalid result.")):
 
83
                re.escape(
 
84
                    "bad pod driver '%s'; 'discover' returned "
 
85
                    "invalid result." % fake_driver.name)):
78
86
            yield pods.discover_pod(fake_driver.name, {})
79
87
 
80
88
    @inlineCallbacks
124
132
                exceptions.PodActionFail,
125
133
                re.escape("Failed talking to pod: " + fake_exception_msg)):
126
134
            yield pods.discover_pod(fake_driver.name, {})
 
135
 
 
136
 
 
137
class TestComposeMachine(MAASTestCase):
 
138
 
 
139
    run_tests_with = MAASTwistedRunTest.make_factory(timeout=5)
 
140
 
 
141
    def make_requested_machine(self):
 
142
        return RequestedMachine(
 
143
            architecture='amd64/generic',
 
144
            cores=random.randint(1, 8),
 
145
            cpu_speed=random.randint(1000, 3000),
 
146
            memory=random.randint(1024, 8192),
 
147
            block_devices=[
 
148
                RequestedMachineBlockDevice(size=random.randint(8, 16))],
 
149
            interfaces=[
 
150
                RequestedMachineInterface()])
 
151
 
 
152
    @inlineCallbacks
 
153
    def test_unknown_pod_raises_UnknownPodType(self):
 
154
        unknown_type = factory.make_name("unknown")
 
155
        fake_request = self.make_requested_machine()
 
156
        pod_id = random.randint(1, 10)
 
157
        pod_name = factory.make_name("pod")
 
158
        with ExpectedException(exceptions.UnknownPodType):
 
159
            yield pods.compose_machine(
 
160
                unknown_type, {}, fake_request, pod_id=pod_id, name=pod_name)
 
161
 
 
162
    @inlineCallbacks
 
163
    def test_handles_driver_not_returning_Deferred(self):
 
164
        fake_driver = MagicMock()
 
165
        fake_driver.name = factory.make_name("pod")
 
166
        fake_driver.compose.return_value = None
 
167
        fake_request = self.make_requested_machine()
 
168
        pod_id = random.randint(1, 10)
 
169
        pod_name = factory.make_name("pod")
 
170
        self.patch(
 
171
            PodDriverRegistry, "get_item").return_value = fake_driver
 
172
        with ExpectedException(
 
173
                exceptions.PodActionFail,
 
174
                re.escape(
 
175
                    "bad pod driver '%s'; 'compose' did not "
 
176
                    "return Deferred." % fake_driver.name)):
 
177
            yield pods.compose_machine(
 
178
                fake_driver.name, {}, fake_request,
 
179
                pod_id=pod_id, name=pod_name)
 
180
 
 
181
    @inlineCallbacks
 
182
    def test_handles_driver_resolving_to_None(self):
 
183
        fake_driver = MagicMock()
 
184
        fake_driver.name = factory.make_name("pod")
 
185
        fake_driver.compose.return_value = succeed(None)
 
186
        fake_request = self.make_requested_machine()
 
187
        pod_id = random.randint(1, 10)
 
188
        pod_name = factory.make_name("pod")
 
189
        self.patch(
 
190
            PodDriverRegistry, "get_item").return_value = fake_driver
 
191
        with ExpectedException(exceptions.PodInvalidResources):
 
192
            yield pods.compose_machine(
 
193
                fake_driver.name, {}, fake_request,
 
194
                pod_id=pod_id, name=pod_name)
 
195
 
 
196
    @inlineCallbacks
 
197
    def test_handles_driver_not_resolving_to_tuple(self):
 
198
        fake_driver = MagicMock()
 
199
        fake_driver.name = factory.make_name("pod")
 
200
        fake_driver.compose.return_value = succeed({})
 
201
        fake_request = self.make_requested_machine()
 
202
        pod_id = random.randint(1, 10)
 
203
        pod_name = factory.make_name("pod")
 
204
        self.patch(
 
205
            PodDriverRegistry, "get_item").return_value = fake_driver
 
206
        with ExpectedException(
 
207
                exceptions.PodActionFail,
 
208
                re.escape(
 
209
                    "bad pod driver '%s'; 'compose' returned "
 
210
                    "invalid result." % fake_driver.name)):
 
211
            yield pods.compose_machine(
 
212
                fake_driver.name, {}, fake_request,
 
213
                pod_id=pod_id, name=pod_name)
 
214
 
 
215
    @inlineCallbacks
 
216
    def test_handles_driver_not_resolving_to_tuple_of_discovered(self):
 
217
        fake_driver = MagicMock()
 
218
        fake_driver.name = factory.make_name("pod")
 
219
        fake_driver.compose.return_value = succeed((object(), object()))
 
220
        fake_request = self.make_requested_machine()
 
221
        pod_id = random.randint(1, 10)
 
222
        pod_name = factory.make_name("pod")
 
223
        self.patch(
 
224
            PodDriverRegistry, "get_item").return_value = fake_driver
 
225
        with ExpectedException(
 
226
                exceptions.PodActionFail,
 
227
                re.escape(
 
228
                    "bad pod driver '%s'; 'compose' returned "
 
229
                    "invalid result." % fake_driver.name)):
 
230
            yield pods.compose_machine(
 
231
                fake_driver.name, {}, fake_request,
 
232
                pod_id=pod_id, name=pod_name)
 
233
 
 
234
    @inlineCallbacks
 
235
    def test_handles_driver_resolving_to_tuple_of_discovered(self):
 
236
        fake_driver = MagicMock()
 
237
        fake_driver.name = factory.make_name("pod")
 
238
        fake_request = self.make_requested_machine()
 
239
        pod_id = random.randint(1, 10)
 
240
        pod_name = factory.make_name("pod")
 
241
        machine = DiscoveredMachine(
 
242
            architecture='amd64/generic',
 
243
            cores=random.randint(1, 8),
 
244
            cpu_speed=random.randint(1000, 3000),
 
245
            memory=random.randint(1024, 8192),
 
246
            block_devices=[], interfaces=[])
 
247
        hints = DiscoveredPodHints(
 
248
            cores=random.randint(1, 8),
 
249
            cpu_speed=random.randint(1000, 2000),
 
250
            memory=random.randint(1024, 8192), local_storage=0)
 
251
        fake_driver.compose.return_value = succeed((machine, hints))
 
252
        self.patch(
 
253
            PodDriverRegistry, "get_item").return_value = fake_driver
 
254
        result = yield pods.compose_machine(
 
255
            fake_driver.name, {}, fake_request, pod_id=pod_id, name=pod_name)
 
256
        self.assertEquals({
 
257
            "machine": machine,
 
258
            "hints": hints,
 
259
        }, result)
 
260
 
 
261
    @inlineCallbacks
 
262
    def test_handles_driver_raising_NotImplementedError(self):
 
263
        fake_driver = MagicMock()
 
264
        fake_driver.name = factory.make_name("pod")
 
265
        fake_driver.compose.return_value = fail(NotImplementedError())
 
266
        fake_request = self.make_requested_machine()
 
267
        pod_id = random.randint(1, 10)
 
268
        pod_name = factory.make_name("pod")
 
269
        self.patch(
 
270
            PodDriverRegistry, "get_item").return_value = fake_driver
 
271
        with ExpectedException(NotImplementedError):
 
272
            yield pods.compose_machine(
 
273
                fake_driver.name, {}, fake_request,
 
274
                pod_id=pod_id, name=pod_name)
 
275
 
 
276
    @inlineCallbacks
 
277
    def test_handles_driver_raising_any_Exception(self):
 
278
        fake_driver = MagicMock()
 
279
        fake_driver.name = factory.make_name("pod")
 
280
        fake_exception_type = factory.make_exception_type()
 
281
        fake_exception_msg = factory.make_name("error")
 
282
        fake_exception = fake_exception_type(fake_exception_msg)
 
283
        fake_driver.compose.return_value = fail(fake_exception)
 
284
        fake_request = self.make_requested_machine()
 
285
        pod_id = random.randint(1, 10)
 
286
        pod_name = factory.make_name("pod")
 
287
        self.patch(
 
288
            PodDriverRegistry, "get_item").return_value = fake_driver
 
289
        with ExpectedException(
 
290
                exceptions.PodActionFail,
 
291
                re.escape("Failed talking to pod: " + fake_exception_msg)):
 
292
            yield pods.compose_machine(
 
293
                fake_driver.name, {}, fake_request,
 
294
                pod_id=pod_id, name=pod_name)