Debian Codegraph @

ironic_tempest_plugin/tests/api/admin/test_microversion_enforcement.py

raw
1 # Licensed under the Apache License, Version 2.0 (the "License"); you may
2 # not use this file except in compliance with the License. You may obtain
3 # a copy of the License at
4 #
5 # http://www.apache.org/licenses/LICENSE-2.0
6 #
7 # Unless required by applicable law or agreed to in writing, software
8 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
9 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
10 # License for the specific language governing permissions and limitations
11 # under the License.
12
13 import random
14
15 from oslo_utils import timeutils
16 from oslo_utils import uuidutils
17 from tempest import config
18 from tempest.lib.common.utils import data_utils
19 from tempest.lib import decorators
20 from tempest.lib import exceptions as lib_exc
21
22 from ironic_tempest_plugin.services.baremetal.v1.json.baremetal_client import \
23 BaremetalClient
24 from ironic_tempest_plugin.tests.api.admin import api_microversion_fixture
25 from ironic_tempest_plugin.tests.api import base
26
27 CONF = config.CONF
28
29
30 class MicroversionTestMixin:
31 """Mixin class containing shared microversion test functionality."""
32
33 def _microversion_test(
34 self,
35 method_name,
36 min_version,
37 expected_error,
38 required_args,
39 ignore_positive=False,
40 ):
41 """Test methods with invalid API versions"""
42
43 major, minor = map(int, min_version.split("."))
44 invalid_versions = []
45 if minor >= 11:
46 invalid_versions.append(f"{major}.{minor - 10}")
47 if minor >= 2:
48 invalid_versions.append(f"{major}.{minor - 1}")
49 elif minor == 0 and major > 1:
50 invalid_versions.append(f"{major - 1}.99")
51 elif minor == 1:
52 invalid_versions.append(f"{major}.0")
53 else:
54 # We expect fails for v1.0 and below
55 raise ValueError(f"Invalid microversion {min_version}")
56
57 # Get method name from method object
58 method_name = method_name.__name__
59
60 # Test with invalid versions (should fail)
61 for microversion in invalid_versions:
62 msg = (
63 f"Testing {method_name} with version {microversion} "
64 f"and arguments {required_args} - should fail"
65 )
66 with self.subTest(
67 msg=msg, method=method_name, version=microversion
68 ):
69 self.useFixture(
70 api_microversion_fixture.APIMicroversionFixture(
71 microversion
72 )
73 )
74 method = getattr(self.client, method_name)
75
76 try:
77 method(**required_args)
78 self.fail(
79 f"Request for microversion {microversion} for "
80 f"{method_name} unexpectedly succeeded. We expected "
81 f"{expected_error.__name__}."
82 )
83 except expected_error:
84 pass # Expected error, test passes
85 except Exception as e:
86 self.fail(
87 f"Request for microversion {microversion} for "
88 f"{method_name} raised unexpected exception: {e}"
89 )
90
91 if ignore_positive:
92 return True
93
94 # Test with valid version (should succeed)
95 # Use the minimum required version
96 msg = (
97 f"Testing {method_name} with version {min_version} "
98 f"and arguments {required_args} - should succeed"
99 )
100 with self.subTest(
101 msg=msg, method=method_name, version=min_version
102 ):
103 self.useFixture(
104 api_microversion_fixture.APIMicroversionFixture(
105 min_version
106 )
107 )
108 method = getattr(self.client, method_name)
109
110 try:
111 # We don't check the actual response, just
112 # that it doesn't raise
113 # the expected error from the negative test
114 method(**required_args)
115 return True
116
117 except expected_error as e:
118 self.fail(
119 f"Method {method_name} failed with valid "
120 f"microversion {min_version}: {e}"
121 )
122 except Exception as e:
123 # Other exceptions might be expected due to invalid test data
124 # For example, a 404 might be expected if we're using fake IDs
125 self.assertNotIsInstance(
126 e,
127 expected_error,
128 (
129 f"Got unexpected {expected_error.__name__} with valid "
130 f"microversion {min_version}: {e}"
131 ),
132 )
133
134
135 class BaseTestMicroversionEnforcement(base.BaseBaremetalTest):
136 """Base class for microversion enforcement tests."""
137
138 def setUp(self):
139 super().setUp()
140 self.resource_class = uuidutils.generate_uuid()
141
142
143 class TestNodesMicroversions(
144 BaseTestMicroversionEnforcement, MicroversionTestMixin
145 ):
146 """Tests for nodes-related API microversion enforcement."""
147
148 min_microversion = "1.1"
149
150 def setUp(self):
151 super(TestNodesMicroversions, self).setUp()
152 _, self.chassis = self.create_chassis()
153
154 # NOTE(adamcarthur) - We test the positive case in the other
155 # tests. Doing it here would require changing the test function
156 # to allow returns.
157 @decorators.idempotent_id("be29d566-43d5-41ce-8c8a-ce360af9995b")
158 def test_create_node(self):
159 self._microversion_test(
160 BaremetalClient.create_node,
161 "1.1",
162 lib_exc.NotAcceptable,
163 {"chassis_id": self.chassis["uuid"]},
164 ignore_positive=True
165 )
166
167 @decorators.idempotent_id("3ddd0ae9-979b-44ac-9cdc-2cabd2f61118")
168 def test_list_nodes(self):
169 self._microversion_test(
170 BaremetalClient.list_nodes, "1.1", lib_exc.NotAcceptable, {}
171 )
172
173 @decorators.idempotent_id("d47160dd-654e-427b-91b0-9a4298a7ff54")
174 def test_list_nodes_detail(self):
175 self._microversion_test(
176 BaremetalClient.list_nodes_detail, "1.1", lib_exc.NotAcceptable, {}
177 )
178
179 @decorators.idempotent_id("a612b489-d4c6-4f29-9dcd-ca7a71d93f77")
180 def test_show_node(self):
181 _, node = self.create_node(self.chassis["uuid"])
182 self._microversion_test(
183 BaremetalClient.show_node,
184 "1.1",
185 lib_exc.NotAcceptable,
186 {"uuid": node["uuid"]},
187 )
188 # delete the node
189 self.client.delete_node(node["uuid"])
190
191 @decorators.idempotent_id("02623737-84f5-42f1-a8f3-0f3a8c1319da")
192 def test_update_node(self):
193 _, node = self.create_node(self.chassis["uuid"])
194 instance_uuid = data_utils.rand_uuid()
195 self._microversion_test(
196 BaremetalClient.update_node,
197 "1.1",
198 lib_exc.NotAcceptable,
199 {"uuid": node["uuid"], "patch": instance_uuid},
200 )
201 # delete the node
202 self.client.delete_node(node["uuid"])
203
204 @decorators.idempotent_id("59f433f1-05b8-47a9-b14a-f4aba337698d")
205 def test_delete_node(self):
206 _, node = self.create_node(self.chassis["uuid"])
207 self._microversion_test(
208 BaremetalClient.delete_node,
209 "1.1",
210 lib_exc.NotAcceptable,
211 {"uuid": node["uuid"]},
212 )
213
214
215 class TestNodeManagementMicroversions(
216 BaseTestMicroversionEnforcement, MicroversionTestMixin
217 ):
218 """Tests for node management-related API microversion enforcement."""
219
220 min_microversion = "1.1"
221
222 def setUp(self):
223 super(TestNodeManagementMicroversions, self).setUp()
224 _, self.chassis = self.create_chassis()
225 _, self.node = self.create_node(self.chassis["uuid"])
226
227 def _validate_provision_state(self, node_uuid, target_state):
228 # Validate that provision state is set within timeout
229 start = timeutils.utcnow()
230 while timeutils.delta_seconds(
231 start, timeutils.utcnow()) < self.unprovision_timeout:
232 _, node = self.client.show_node(node_uuid)
233 if node['provision_state'] == target_state:
234 return
235 message = ('Failed to set provision state %(state)s within '
236 'the required time: %(timeout)s sec.',
237 {'state': target_state,
238 'timeout': self.unprovision_timeout})
239 raise lib_exc.TimeoutException(message)
240
241 @decorators.idempotent_id("54a58e1e-8334-4152-84b4-2974cabb74e8")
242 def test_validate_driver_interface(self):
243 self._microversion_test(
244 BaremetalClient.validate_driver_interface,
245 "1.1",
246 lib_exc.NotAcceptable,
247 {"node_uuid": self.node["uuid"]},
248 )
249
250 @decorators.idempotent_id("9adfa595-8937-4a99-83e5-6012ddcbddc0")
251 def test_set_node_power_state(self):
252 self._microversion_test(
253 BaremetalClient.set_node_power_state,
254 "1.1",
255 lib_exc.NotAcceptable,
256 {"node_uuid": self.node["uuid"], "state": "power off"},
257 )
258
259 @decorators.idempotent_id("efd978ce-2ce5-4dc3-8f69-ff063644a550")
260 def test_set_node_provision_state(self):
261 contd = self._microversion_test(
262 BaremetalClient.set_node_provision_state,
263 "1.1",
264 lib_exc.NotAcceptable,
265 {"node_uuid": self.node["uuid"], "state": "manageable"},
266 )
267
268 if contd:
269 self._validate_provision_state(self.node["uuid"], "manageable")
270
271 @decorators.idempotent_id("893e4815-2c55-40f6-84e3-1816e28f6803")
272 def test_set_node_raid_config(self):
273 self._microversion_test(
274 BaremetalClient.set_node_raid_config,
275 "1.12",
276 lib_exc.NotAcceptable,
277 {"node_uuid": self.node["uuid"], "target_raid_config": {}},
278 )
279
280 @decorators.idempotent_id("f6b835da-dea3-46b2-8e16-6f910ad7cc86")
281 def test_get_console(self):
282 self._microversion_test(
283 BaremetalClient.get_console,
284 "1.1",
285 lib_exc.NotAcceptable,
286 {"node_uuid": self.node["uuid"]},
287 )
288
289 @decorators.idempotent_id("2dc96b6b-5713-467d-9707-389292ae5460")
290 def test_set_console_mode(self):
291 self._microversion_test(
292 BaremetalClient.set_console_mode,
293 "1.1",
294 lib_exc.NotAcceptable,
295 {"node_uuid": self.node["uuid"], "enabled": True},
296 )
297
298 @decorators.idempotent_id("4b4e23ae-3d18-4f35-a140-d10abcf22110")
299 def test_set_node_boot_device(self):
300 self._microversion_test(
301 BaremetalClient.set_node_boot_device,
302 "1.1",
303 lib_exc.NotAcceptable,
304 {"node_uuid": self.node["uuid"], "boot_device": "pxe"},
305 )
306
307 @decorators.idempotent_id("f13b398e-cde1-4862-a183-f20eb56d3234")
308 def test_get_node_boot_device(self):
309 self._microversion_test(
310 BaremetalClient.get_node_boot_device,
311 "1.1",
312 lib_exc.NotAcceptable,
313 {"node_uuid": self.node["uuid"]},
314 )
315
316 @decorators.idempotent_id("88985d9e-ccd1-4894-bc5d-e712ce29b892")
317 def test_get_node_supported_boot_devices(self):
318 self._microversion_test(
319 BaremetalClient.get_node_supported_boot_devices,
320 "1.1",
321 lib_exc.NotAcceptable,
322 {"node_uuid": self.node["uuid"]},
323 )
324
325
326 class TestNodeVMediaMicroversions(
327 BaseTestMicroversionEnforcement, MicroversionTestMixin
328 ):
329 """Tests for node vmedia-related API microversion enforcement."""
330
331 min_microversion = "1.89"
332
333 def setUp(self):
334 super(TestNodeVMediaMicroversions, self).setUp()
335 _, self.chassis = self.create_chassis()
336 _, self.node = self.create_node(self.chassis["uuid"])
337
338 @decorators.idempotent_id("305c0689-c43b-407c-8b78-932ff86e4b3d")
339 def test_attach_node_vmedia(self):
340 self._microversion_test(
341 BaremetalClient._put_request,
342 "1.89",
343 lib_exc.NotFound,
344 {
345 "resource": f"nodes/{self.node['uuid']}/vmedia",
346 "put_object": {
347 "device_type": "CDROM", "image_url": "http://image"
348 },
349 },
350 )
351
352 @decorators.idempotent_id("1d4d15bb-a66c-47f9-bf41-cc5e09854bcc")
353 def test_detach_node_vmedia(self):
354 self._microversion_test(
355 BaremetalClient._delete_request,
356 "1.89",
357 lib_exc.NotFound,
358 {"resource": f"nodes/{self.node['uuid']}/vmedia", "uuid": ""},
359 )
360
361
362 class TestNodeVendorPassthruMethodsMicroversions(
363 BaseTestMicroversionEnforcement, MicroversionTestMixin
364 ):
365 """Tests for node vendor passthru methods API microversion enforcement."""
366
367 min_microversion = "1.1"
368
369 def setUp(self):
370 super(TestNodeVendorPassthruMethodsMicroversions, self).setUp()
371 _, self.chassis = self.create_chassis()
372 _, self.node = self.create_node(self.chassis["uuid"])
373
374 @decorators.idempotent_id("8599e266-debc-4548-af5a-cd2223a5e051")
375 def test_list_vendor_passthru_methods(self):
376 self._microversion_test(
377 BaremetalClient.list_vendor_passthru_methods,
378 "1.1",
379 lib_exc.NotAcceptable,
380 {"node_uuid": self.node["uuid"]},
381 )
382
383
384 class TestNodeVendorPassthruCallMethodMicroversions(
385 BaseTestMicroversionEnforcement, MicroversionTestMixin
386 ):
387 """Tests for vendor passthru call method API microversion"""
388
389 min_microversion = "1.1"
390
391 def setUp(self):
392 super(TestNodeVendorPassthruCallMethodMicroversions, self).setUp()
393 _, self.chassis = self.create_chassis()
394 _, self.node = self.create_node(self.chassis["uuid"])
395
396 @decorators.idempotent_id("35b34e5d-78d4-49e6-81b3-48b536f9fb60")
397 def test_call_vendor_passthru_method(self):
398 self._microversion_test(
399 BaremetalClient._put_request,
400 "1.1",
401 lib_exc.NotAcceptable,
402 {
403 "resource": f"nodes/{self.node['uuid']}/vendor_passthru",
404 "put_object": {"method": "fakemethod"},
405 },
406 )
407
408
409 class TestNodeTraitsMicroversions(
410 BaseTestMicroversionEnforcement, MicroversionTestMixin
411 ):
412 """Tests for node traits-related API microversion enforcement."""
413
414 min_microversion = "1.37"
415
416 def setUp(self):
417 super(TestNodeTraitsMicroversions, self).setUp()
418 _, self.chassis = self.create_chassis()
419 _, self.node = self.create_node(self.chassis["uuid"])
420 self.traits = ["CUSTOM_TRAIT1", "HW_CPU_X86_VMX"]
421
422 @decorators.idempotent_id("3f4ba6c1-5b39-4cb1-a823-21dcea802d61")
423 def test_list_node_traits(self):
424 self._microversion_test(
425 BaremetalClient.list_node_traits,
426 "1.37",
427 lib_exc.NotAcceptable,
428 {"node_uuid": self.node["uuid"]},
429 )
430
431 @decorators.idempotent_id("10d77871-cd8a-4ecb-b6a4-f38d6ad719fe")
432 def test_set_node_traits(self):
433 self._microversion_test(
434 BaremetalClient.set_node_traits,
435 "1.37",
436 lib_exc.UnexpectedResponseCode,
437 {"node_uuid": self.node["uuid"], "traits": self.traits},
438 )
439
440 @decorators.idempotent_id("12ca1f62-9d4a-490c-8f8a-a10fc742630a")
441 def test_add_node_trait(self):
442 self._microversion_test(
443 BaremetalClient.add_node_trait,
444 "1.37",
445 lib_exc.UnexpectedResponseCode,
446 {"node_uuid": self.node["uuid"], "trait": "CUSTOM_TRAIT1"},
447 )
448
449 @decorators.idempotent_id("dd2f3b89-3fe3-4861-ba11-608b365ff484")
450 def test_remove_node_traits(self):
451 # add a trait to remove it
452 self.client.add_node_trait(self.node["uuid"], "CUSTOM_TRAIT1")
453 self._microversion_test(
454 BaremetalClient.remove_node_traits,
455 "1.37",
456 lib_exc.NotFound,
457 {"node_uuid": self.node["uuid"]},
458 )
459
460 @decorators.idempotent_id("be438903-26d0-4ee6-970e-2d6d66058842")
461 def test_remove_node_trait(self):
462 self.client.add_node_trait(self.node["uuid"], "CUSTOM_TRAIT1")
463 self._microversion_test(
464 BaremetalClient.remove_node_trait,
465 "1.37",
466 lib_exc.NotFound,
467 {"node_uuid": self.node["uuid"], "trait": "CUSTOM_TRAIT1"},
468 )
469
470
471 class TestNodeVIFsMicroversions(
472 BaseTestMicroversionEnforcement, MicroversionTestMixin
473 ):
474 """Tests for node VIFs-related API microversion enforcement."""
475
476 min_microversion = "1.28"
477
478 def setUp(self):
479 super(TestNodeVIFsMicroversions, self).setUp()
480 _, self.chassis = self.create_chassis()
481 _, self.node = self.create_node(self.chassis["uuid"])
482 self.vif_id = uuidutils.generate_uuid()
483
484 @decorators.idempotent_id("9b26c364-0623-4bd4-ac53-a3eca8d58fea")
485 def test_list_node_vifs(self):
486 self._microversion_test(
487 BaremetalClient.vif_list,
488 "1.28",
489 lib_exc.NotFound,
490 {"node_uuid": self.node["uuid"]},
491 )
492
493 @decorators.idempotent_id("4e91a305-145d-408d-9aea-08d73ef8d082")
494 def test_attach_node_vif(self):
495 self._microversion_test(
496 BaremetalClient.vif_attach,
497 "1.28",
498 lib_exc.NotFound,
499 {"node_uuid": self.node["uuid"], "vif_id": self.vif_id},
500 )
501
502 @decorators.idempotent_id("ce93713b-5df8-44ce-815c-c18ae0203c63")
503 def test_detach_node_vif(self):
504 self._microversion_test(
505 BaremetalClient.vif_detach,
506 "1.28",
507 lib_exc.NotFound,
508 {"node_uuid": self.node["uuid"], "vif_id": self.vif_id},
509 )
510
511
512 class TestNodeIndicatorsMicroversions(
513 BaseTestMicroversionEnforcement, MicroversionTestMixin
514 ):
515 """Tests for node indicators-related API microversion enforcement."""
516
517 min_microversion = "1.1"
518
519 def setUp(self):
520 super(TestNodeIndicatorsMicroversions, self).setUp()
521 _, self.chassis = self.create_chassis()
522 _, self.node = self.create_node(self.chassis["uuid"])
523 self.component = "system"
524 self.ind_ident = "led"
525 self.state = "ON"
526
527 @decorators.idempotent_id("79194e54-c98d-4e55-a368-2a2ba2199844")
528 def test_get_node_indicator_state(self):
529 self._microversion_test(
530 BaremetalClient.get_node_indicator_state,
531 "1.1",
532 lib_exc.NotAcceptable,
533 {
534 "node_uuid": self.node["uuid"],
535 "component": self.component,
536 "ind_ident": self.ind_ident,
537 },
538 )
539
540
541 class TestPortgroupMicroversions(BaseTestMicroversionEnforcement,
542 MicroversionTestMixin):
543 """Tests for Portgroup-related API microversion enforcement.
544
545 Portgroup APIs (e.g. listing, creating, showing, updating and deleting)
546 were introduced in microversion 1.23.
547 """
548
549 min_microversion = "1.23"
550
551 def setUp(self):
552 super(TestPortgroupMicroversions, self).setUp()
553 _, self.chassis = self.create_chassis()
554 _, self.node = self.create_node(self.chassis['uuid'])
555
556 @decorators.idempotent_id("a8b52cdf-8471-40d7-9bc0-6ecfefa33adf")
557 def test_list_portgroups(self):
558 self._microversion_test(
559 BaremetalClient.list_portgroups,
560 "1.23",
561 lib_exc.NotFound,
562 {} # Empty dict for no required args
563 )
564
565 @decorators.idempotent_id("cb5b92f0-fdb6-4789-b9b5-ae147cbe288b")
566 def test_list_portgroups_detail(self):
567 self._microversion_test(
568 BaremetalClient.list_portgroups_detail,
569 "1.23",
570 lib_exc.NotFound,
571 {} # Empty dict for no required args
572 )
573
574 @decorators.idempotent_id("aafb5f2d-22e4-4b07-98c6-7f8f5f4a6699")
575 def test_create_portgroup(self):
576 self._microversion_test(
577 BaremetalClient.create_portgroup,
578 "1.23",
579 lib_exc.NotFound,
580 {
581 "node_uuid": self.node['uuid'],
582 "address": "11:11:11:11:11:11",
583 "name": "test_portgroup"
584 }
585 )
586
587 @decorators.idempotent_id("ea27635c-132f-4cff-9f93-b11bd4baa5a2")
588 def test_show_portgroup(self):
589 _, portgroup = self.client.create_portgroup(self.node['uuid'])
590 self._microversion_test(
591 BaremetalClient.show_portgroup,
592 "1.23",
593 lib_exc.NotFound,
594 {"portgroup_ident": portgroup['uuid']}
595 )
596
597 @decorators.idempotent_id("48dfef1f-b95f-4767-86ee-d6257c52cefd")
598 def test_update_portgroup(self):
599 patch_doc = [
600 {"op": "replace", "path": "/address", "value": "22:22:22:22:22:22"}
601 ]
602 # Need to create a portgroup to delete it
603 _, portgroup = self.create_portgroup(self.node['uuid'])
604 self._microversion_test(
605 BaremetalClient.update_portgroup,
606 "1.23",
607 lib_exc.NotFound,
608 {
609 "uuid": portgroup['uuid'],
610 "patch": patch_doc
611 }
612 )
613
614 @decorators.idempotent_id("e0884cbe-bacc-4347-be14-72e475855eff")
615 def test_delete_portgroup(self):
616 # Need to create a portgroup to delete it
617 _, portgroup = self.create_portgroup(self.node['uuid'])
618
619 self._microversion_test(
620 BaremetalClient.delete_portgroup,
621 "1.23",
622 lib_exc.NotFound,
623 {"portgroup_ident": portgroup['uuid']}
624 )
625
626
627 class TestPortgroupByNodeMicroversions(BaseTestMicroversionEnforcement,
628 MicroversionTestMixin):
629 """Tests for listing Portgroups by Node.
630
631 These endpoints (e.g. /v1/nodes/{node_ident}/portgroups and
632 /v1/nodes/{node_ident}/portgroups/detail) were introduced
633 in microversion 1.24.
634 """
635
636 min_microversion = "1.24"
637
638 def setUp(self):
639 super(TestPortgroupByNodeMicroversions, self).setUp()
640 _, self.chassis = self.create_chassis()
641 _, self.node = self.create_node(self.chassis['uuid'])
642
643 @decorators.idempotent_id("c967b02f-1acc-4714-98b0-07e49e9b3482")
644 def test_list_portgroups_by_node(self):
645 self._microversion_test(
646 BaremetalClient.list_portgroups_by_node,
647 "1.24",
648 lib_exc.NotFound,
649 {"node_ident": self.node['uuid']}
650 )
651
652 @decorators.idempotent_id("8c38415b-1aad-4519-81fb-0792ebf3731a")
653 def test_list_portgroups_details_by_node(self):
654 self._microversion_test(
655 BaremetalClient.list_portgroups_details_by_node,
656 "1.24",
657 lib_exc.NotFound,
658 {"node_ident": self.node['uuid']}
659 )
660
661
662 class TestPortMicroversions(
663 BaseTestMicroversionEnforcement, MicroversionTestMixin
664 ):
665 """Tests for port-related API microversion enforcement."""
666
667 min_microversion = "1.1"
668
669 def setUp(self):
670 super(TestPortMicroversions, self).setUp()
671 _, self.chassis = self.create_chassis()
672 _, self.node = self.create_node(self.chassis["uuid"])
673 random_mac = (
674 f"02:00:00:{random.randint(0, 255):02x}"
675 f":{random.randint(0, 255):02x}"
676 f":{random.randint(0, 255):02x}"
677 )
678
679 _, self.port = self.create_port(
680 self.node["uuid"], address=random_mac
681 )
682
683 @decorators.idempotent_id("99e628a4-0d10-44a1-aed5-0b82d0155103")
684 def test_list_ports(self):
685 self._microversion_test(
686 BaremetalClient.list_ports,
687 "1.1",
688 lib_exc.NotAcceptable,
689 {}, # Empty dict for no required args
690 )
691
692 @decorators.idempotent_id("0c01ce9a-8945-4604-b315-3f8a1856c621")
693 def test_list_ports_detail(self):
694 self._microversion_test(
695 BaremetalClient.list_ports_detail,
696 "1.1",
697 lib_exc.NotAcceptable,
698 {}, # Empty dict for no required args
699 )
700
701 @decorators.idempotent_id("15b3f4d5-d8ca-44af-b0fe-75f9a86896b1")
702 def test_create_port(self):
703 self._microversion_test(
704 BaremetalClient.create_port,
705 "1.1",
706 lib_exc.NotAcceptable,
707 {
708 "node_id": self.node["uuid"],
709 "address": "11:11:11:11:11:11",
710 },
711 )
712
713 @decorators.idempotent_id("637f088f-1460-46c4-a3cf-3568c1997461")
714 def test_show_port(self):
715 self._microversion_test(
716 BaremetalClient.show_port,
717 "1.1",
718 lib_exc.NotAcceptable,
719 {"uuid": "fake_port"},
720 )
721
722 @decorators.idempotent_id("5cf7930d-3e0b-44f7-b9b8-a941dea2782e")
723 def test_update_port(self):
724 patch_doc = [
725 {"op": "replace", "path": "/address", "value": "22:22:22:22:22:22"}
726 ]
727 self._microversion_test(
728 BaremetalClient.update_port,
729 "1.1",
730 lib_exc.NotAcceptable,
731 {"uuid": self.port["uuid"], "patch": patch_doc},
732 )
733
734 @decorators.idempotent_id("b5d92c53-9d2e-485f-ac6c-1e0d020d5af3")
735 def test_delete_port(self):
736 self._microversion_test(
737 BaremetalClient.delete_port,
738 "1.1",
739 lib_exc.NotAcceptable,
740 {"uuid": self.port["uuid"]},
741 )
742
743
744 class TestNodePortsMicroversions(
745 BaseTestMicroversionEnforcement, MicroversionTestMixin
746 ):
747 """Tests for listing Ports by Node API microversion enforcement."""
748
749 min_microversion = "1.1"
750
751 def setUp(self):
752 super(TestNodePortsMicroversions, self).setUp()
753 _, self.chassis = self.create_chassis()
754 _, self.node = self.create_node(self.chassis["uuid"])
755
756 @decorators.idempotent_id("7a0acf09-d527-4d77-92bd-3eac81687bc7")
757 def test_list_ports_by_node(self):
758 self._microversion_test(
759 BaremetalClient.list_node_ports,
760 "1.1",
761 lib_exc.NotAcceptable,
762 {"uuid": self.node["uuid"]},
763 )
764
765 @decorators.idempotent_id("df017231-a8d3-4b6b-8583-0e6fbf61e834")
766 def test_list_ports_details_by_node(self):
767 self._microversion_test(
768 BaremetalClient.list_node_ports,
769 "1.1",
770 lib_exc.NotAcceptable,
771 {"uuid": self.node["uuid"]},
772 )
773
774
775 class TestPortgroupPortsMicroversions(
776 BaseTestMicroversionEnforcement, MicroversionTestMixin
777 ):
778 """Tests for listing Ports by Portgroup API microversion enforcement."""
779
780 min_microversion = "1.24"
781
782 def setUp(self):
783 super(TestPortgroupPortsMicroversions, self).setUp()
784 _, self.chassis = self.create_chassis()
785 _, self.node = self.create_node(self.chassis["uuid"])
786 _, self.portgroup = self.create_portgroup(self.node["uuid"])
787
788 @decorators.idempotent_id("bb3a1fa6-52cf-4e19-98d0-746c2421ff9a")
789 def test_list_ports_by_portgroup(self):
790 self._microversion_test(
791 BaremetalClient.list_ports,
792 "1.24",
793 lib_exc.NotAcceptable,
794 {"portgroup": self.portgroup["uuid"]},
795 )
796
797 @decorators.idempotent_id("6740fe09-539d-415b-bc44-f38f458f2547")
798 def test_list_ports_details_by_portgroup(self):
799 self._microversion_test(
800 BaremetalClient.list_ports_detail,
801 "1.24",
802 lib_exc.NotAcceptable,
803 {"portgroup": self.portgroup["uuid"]},
804 )
805
806
807 class TestVolumeConnectorMicroversions(
808 BaseTestMicroversionEnforcement, MicroversionTestMixin
809 ):
810 """Tests for volume connector-related API microversion enforcement."""
811
812 min_microversion = "1.32"
813
814 def setUp(self):
815 super(TestVolumeConnectorMicroversions, self).setUp()
816 _, self.chassis = self.create_chassis()
817 _, self.node = self.create_node(self.chassis["uuid"])
818
819 @decorators.idempotent_id("1bde0eb4-c63c-4d05-897d-b2247dd97863")
820 def test_list_volume_connectors(self):
821 self._microversion_test(
822 BaremetalClient.list_volume_connectors,
823 "1.32",
824 lib_exc.NotFound,
825 {},
826 )
827
828 @decorators.idempotent_id("7673b980-b882-45d7-bc89-8e255e2228cc")
829 def test_show_volume_connector(self):
830 self._microversion_test(
831 BaremetalClient.show_volume_connector,
832 "1.32",
833 lib_exc.NotFound,
834 {"volume_connector_ident": "fake_volume_connector"},
835 )
836
837 @decorators.idempotent_id("3e7d6a89-5302-4087-a10a-200b8d9dc026")
838 def test_create_volume_connector(self):
839 self._microversion_test(
840 BaremetalClient.create_volume_connector,
841 "1.32",
842 lib_exc.NotFound,
843 {
844 "node_uuid": self.node["uuid"],
845 "type": "iqn",
846 "connector_id": "fake_connector_id",
847 },
848 )
849
850 @decorators.idempotent_id("cca4b764-12cc-4d4d-a702-0b52ef1b0e94")
851 def test_update_volume_connector(self):
852 patch = [{"op": "replace", "path": "/connector_id", "value": "new_id"}]
853 self._microversion_test(
854 BaremetalClient.update_volume_connector,
855 "1.32",
856 lib_exc.NotFound,
857 {"uuid": "fake_volume_connector", "patch": patch},
858 )
859
860 @decorators.idempotent_id("e05e85d1-da6b-43b6-adc4-5e4bc8e4c72d")
861 def test_delete_volume_connector(self):
862 self._microversion_test(
863 BaremetalClient.delete_volume_connector,
864 "1.32",
865 lib_exc.NotFound,
866 {"volume_connector_ident": "fake_volume_connector"},
867 )
868
869
870 class TestVolumeTargetMicroversions(
871 BaseTestMicroversionEnforcement, MicroversionTestMixin
872 ):
873 """Tests for volume target-related API microversion enforcement."""
874
875 min_microversion = "1.32"
876
877 def setUp(self):
878 super(TestVolumeTargetMicroversions, self).setUp()
879 _, self.chassis = self.create_chassis()
880 _, self.node = self.create_node(self.chassis["uuid"])
881
882 @decorators.idempotent_id("c7511a8a-4d6b-4439-bfb1-c659808c0967")
883 def test_list_volume_targets(self):
884 self._microversion_test(
885 BaremetalClient.list_volume_targets, "1.32", lib_exc.NotFound, {}
886 )
887
888 @decorators.idempotent_id("ddb8223e-2f63-4a74-aa2f-229a522ae3e8")
889 def test_show_volume_target(self):
890 self._microversion_test(
891 BaremetalClient.show_volume_target,
892 "1.32",
893 lib_exc.NotFound,
894 {"volume_target_ident": "fake_volume_target"},
895 )
896
897 @decorators.idempotent_id("3fb1e9c5-8154-4308-a765-393ab80762c8")
898 def test_create_volume_target(self):
899 self._microversion_test(
900 BaremetalClient.create_volume_target,
901 "1.32",
902 lib_exc.NotFound,
903 {
904 "node_uuid": self.node["uuid"],
905 "volume_type": "iscsi",
906 "volume_id": "fake_volume_id",
907 "boot_index": 0,
908 },
909 )
910
911 @decorators.idempotent_id("16d83cd1-0425-4e28-bfd4-33199e5a87c7")
912 def test_update_volume_target(self):
913 patch = [{"op": "replace", "path": "/volume_id", "value": "new_id"}]
914 self._microversion_test(
915 BaremetalClient.update_volume_target,
916 "1.32",
917 lib_exc.NotFound,
918 {"uuid": "fake_volume_target", "patch": patch},
919 )
920
921 @decorators.idempotent_id("697b67be-ccc5-4a7b-99ca-276e5e8c931a")
922 def test_delete_volume_target(self):
923 self._microversion_test(
924 BaremetalClient.delete_volume_target,
925 "1.32",
926 lib_exc.NotFound,
927 {"volume_target_ident": "fake_volume_target"},
928 )
929
930
931 class TestNodeVolumeMicroversions(
932 BaseTestMicroversionEnforcement, MicroversionTestMixin
933 ):
934 """Tests for node volume-related API microversion enforcement."""
935
936 min_microversion = "1.32"
937
938 def setUp(self):
939 super(TestNodeVolumeMicroversions, self).setUp()
940 _, self.chassis = self.create_chassis()
941 _, self.node = self.create_node(self.chassis["uuid"])
942
943 @decorators.idempotent_id("2ff700e6-4914-4eed-8342-308a6f2134a5")
944 def test_list_node_volume(self):
945 self._microversion_test(
946 BaremetalClient._list_request,
947 "1.32",
948 lib_exc.NotFound,
949 {"resource": f"nodes/{self.node['uuid']}/volume"},
950 )
951
952 @decorators.idempotent_id("3e56f64f-6bac-4126-ba7d-d89275318975")
953 def test_list_node_volume_connectors(self):
954 self._microversion_test(
955 BaremetalClient._list_request,
956 "1.32",
957 lib_exc.NotFound,
958 {"resource": f"nodes/{self.node['uuid']}/volume/connectors"},
959 )
960
961 @decorators.idempotent_id("060008fe-d478-49d2-bdf0-d327f1e360a5")
962 def test_list_node_volume_targets(self):
963 self._microversion_test(
964 BaremetalClient._list_request,
965 "1.32",
966 lib_exc.NotFound,
967 {"resource": f"nodes/{self.node['uuid']}/volume/targets"},
968 )
969
970
971 class TestDriverMicroversions(
972 BaseTestMicroversionEnforcement, MicroversionTestMixin
973 ):
974 """Tests for driver-related API microversion enforcement."""
975
976 min_microversion = "1.1"
977
978 @decorators.idempotent_id("c5f179c9-3b8a-49c6-bee0-734979d544bc")
979 def test_list_drivers(self):
980 self._microversion_test(
981 BaremetalClient.list_drivers, "1.1", lib_exc.NotAcceptable, {}
982 )
983
984 @decorators.idempotent_id("f79931be-dc7b-4e60-89ce-90a4e2793714")
985 def test_show_driver(self):
986 self._microversion_test(
987 BaremetalClient.show_driver,
988 "1.1",
989 lib_exc.NotAcceptable,
990 {"driver_name": "testdriver"},
991 )
992
993 @decorators.idempotent_id("daef2f42-e343-4640-a5d4-d8938e956ddb")
994 def test_show_driver_properties(self):
995 self._microversion_test(
996 BaremetalClient.get_driver_properties,
997 "1.1",
998 lib_exc.NotAcceptable,
999 {"driver_name": "testdriver"},
1000 )
1001
1002 @decorators.idempotent_id("bade310a-0699-4470-8da3-6f8ae26e9d71")
1003 def test_show_driver_logical_disk_properties(self):
1004 self._microversion_test(
1005 BaremetalClient.get_driver_logical_disk_properties,
1006 "1.12",
1007 lib_exc.NotAcceptable,
1008 {"driver_name": "testdriver"},
1009 )
1010
1011
1012 class TestDriverVendorPassthruMicroversions(
1013 BaseTestMicroversionEnforcement, MicroversionTestMixin
1014 ):
1015 """Tests for driver vendor passthru API microversion enforcement."""
1016
1017 min_microversion = "1.1"
1018
1019 @decorators.idempotent_id("27c0157d-758a-40c9-b0fd-bde05ed8a6fc")
1020 def test_list_vendor_passthru_methods(self):
1021 self._microversion_test(
1022 BaremetalClient.list_vendor_passthru_methods,
1023 "1.1",
1024 lib_exc.NotAcceptable,
1025 {"node_uuid": "fake_node"},
1026 )
1027
1028
1029 class TestNodeBiosMicroversions(
1030 BaseTestMicroversionEnforcement, MicroversionTestMixin
1031 ):
1032 """Tests for node bios-related API microversion enforcement."""
1033
1034 min_microversion = "1.40"
1035
1036 def setUp(self):
1037 super(TestNodeBiosMicroversions, self).setUp()
1038 _, self.chassis = self.create_chassis()
1039 _, self.node = self.create_node(self.chassis["uuid"])
1040
1041 @decorators.idempotent_id("126de288-71f9-4e4f-8591-6ddfc9ac3095")
1042 def test_list_node_bios(self):
1043 self._microversion_test(
1044 BaremetalClient.list_node_bios_settings,
1045 "1.40",
1046 lib_exc.NotFound,
1047 {"uuid": self.node["uuid"]},
1048 )
1049
1050
1051 class TestNodeBiosDetailsMicroversions(
1052 BaseTestMicroversionEnforcement, MicroversionTestMixin
1053 ):
1054 """Tests for node bios details API microversion enforcement."""
1055
1056 min_microversion = "1.40"
1057
1058 def setUp(self):
1059 super(TestNodeBiosDetailsMicroversions, self).setUp()
1060 _, self.chassis = self.create_chassis()
1061 _, self.node = self.create_node(self.chassis["uuid"])
1062
1063 @decorators.idempotent_id("68583cd5-63d0-4bda-a836-9bda6d5b2ab4")
1064 def test_list_node_bios_details(self):
1065 self._microversion_test(
1066 BaremetalClient.list_node_bios_settings,
1067 "1.40",
1068 lib_exc.NotFound,
1069 {"uuid": self.node["uuid"]},
1070 )
1071
1072
1073 class TestNodeFirmwarenMicroversions(
1074 BaseTestMicroversionEnforcement,
1075 MicroversionTestMixin):
1076
1077 min_microversion = "1.86"
1078
1079 def setUp(self):
1080 super(TestNodeFirmwarenMicroversions, self).setUp()
1081 _, self.chassis = self.create_chassis()
1082 _, self.node = self.create_node(self.chassis['uuid'])
1083
1084 @decorators.idempotent_id('f50e9098-1870-46b1-b05c-660d0f8c534d')
1085 def test_list_node_firmware(self):
1086 self._microversion_test(
1087 BaremetalClient.list_node_firmware, "1.86",
1088 lib_exc.NotFound, {"node_uuid": self.node['uuid']}
1089 )
1090
1091
1092 class TestConductorMicroversions(
1093 BaseTestMicroversionEnforcement, MicroversionTestMixin
1094 ):
1095
1096 min_microversion = "1.49"
1097
1098 def setUp(self):
1099 super(TestConductorMicroversions, self).setUp()
1100
1101 @decorators.idempotent_id("412fde59-afe7-442d-83c9-538c87b95687")
1102 def test_list_conductors(self):
1103 self._microversion_test(
1104 BaremetalClient.list_conductors, "1.49", lib_exc.NotFound, {}
1105 )
1106
1107 @decorators.idempotent_id("ad496ff6-2d6e-4e63-9c64-60c5184a18a7")
1108 def test_show_conductor(self):
1109 _, conductors = self.client.list_conductors()
1110 self.assertTrue(len(conductors['conductors']) > 0)
1111 conductor = conductors['conductors'].pop()
1112
1113 _, conductor = self.client.show_conductor(conductor['hostname'])
1114 self._microversion_test(
1115 BaremetalClient.show_conductor,
1116 "1.49",
1117 lib_exc.NotFound,
1118 {"hostname": conductor['hostname']},
1119 )
1120
1121
1122 class TestAllocationMicroversions(
1123 BaseTestMicroversionEnforcement,
1124 MicroversionTestMixin):
1125 """Tests for allocation-related API microversion enforcement."""
1126
1127 min_microversion = "1.52"
1128
1129 @decorators.idempotent_id('ef7bd40a-c1ef-4d40-a0b6-f388d23943c3')
1130 def test_create_allocations(self):
1131 self._microversion_test(
1132 BaremetalClient.create_allocation, "1.52",
1133 lib_exc.UnexpectedResponseCode, {
1134 "resource_class": self.resource_class
1135 }
1136 )
1137
1138 @decorators.idempotent_id('511e0c4b-1320-4ac5-9c4a-fb0394d3ff67')
1139 def test_list_allocations(self):
1140 self._microversion_test(
1141 BaremetalClient.list_allocations, "1.52",
1142 lib_exc.NotFound, {}
1143 )
1144
1145 @decorators.idempotent_id('a0d17f90-baa0-4518-95f7-a7eab73ff6d1')
1146 def test_show_allocations(self):
1147 _, allocation = self.create_allocation(self.resource_class)
1148
1149 self._microversion_test(
1150 BaremetalClient.show_allocation, "1.52",
1151 lib_exc.NotFound, {
1152 "allocation_ident": allocation['uuid']
1153 }
1154 )
1155
1156 @decorators.idempotent_id('b05a9b1a-4a12-4b55-93c7-530c3f35c7d9')
1157 def test_delete_allocations(self):
1158 _, allocation = self.create_allocation(self.resource_class)
1159
1160 self._microversion_test(
1161 BaremetalClient.delete_allocation, "1.52",
1162 lib_exc.UnexpectedResponseCode, {
1163 "allocation_ident": allocation['uuid']
1164 }
1165 )
1166
1167
1168 class TestNodeAllocationMicroversions(
1169 BaseTestMicroversionEnforcement, MicroversionTestMixin
1170 ):
1171 """Tests for node allocation-related API microversion enforcement."""
1172
1173 min_microversion = "1.52"
1174
1175 def setUp(self):
1176 super(TestNodeAllocationMicroversions, self).setUp()
1177 _, self.chassis = self.create_chassis()
1178 _, self.node = self.create_node(self.chassis["uuid"])
1179
1180 @decorators.idempotent_id("9b170cac-18f7-4a17-be2e-314b548244ba")
1181 def test_show_allocation_by_node(self):
1182 _, body = self.create_allocation(self.resource_class)
1183
1184 self._microversion_test(
1185 BaremetalClient.show_node_allocation,
1186 "1.52",
1187 lib_exc.NotFound,
1188 {"node_ident": body["node_uuid"]},
1189 )
1190
1191
1192 class TestDeployTemplateMicroversions(
1193 BaseTestMicroversionEnforcement, MicroversionTestMixin
1194 ):
1195 """Tests for deploy template-related API microversion enforcement."""
1196
1197 min_microversion = "1.55"
1198
1199 def setUp(self):
1200 super(TestDeployTemplateMicroversions, self).setUp()
1201 self.deploy_template_name = "CUSTOM_TEMPLATE_123"
1202 self.steps = [
1203 {
1204 "interface": "bios",
1205 "step": "apply_configuration",
1206 "args": {
1207 "settings": [
1208 {"name": "LogicalProc", "value": "Enabled"}
1209 ]
1210 },
1211 "priority": 150,
1212 }
1213 ]
1214
1215 @decorators.idempotent_id("52806f1d-d64a-4b7f-a799-e623ecc09bda")
1216 def test_create_deploy_template(self):
1217 self._microversion_test(
1218 BaremetalClient.create_deploy_template,
1219 "1.55",
1220 lib_exc.UnexpectedResponseCode,
1221 {"name": self.deploy_template_name, "steps": self.steps},
1222 )
1223
1224 @decorators.idempotent_id("1a3bb543-faa9-4da6-a1c4-20cb8177f53d")
1225 def test_list_deploy_templates(self):
1226 self._microversion_test(
1227 BaremetalClient.list_deploy_templates, "1.55", lib_exc.NotFound, {}
1228 )
1229
1230 @decorators.idempotent_id("a0933551-8569-4638-acd4-fad0a9daefd9")
1231 def test_show_deploy_template(self):
1232 _, deploy_template = self.client.create_deploy_template(
1233 "CUSTOM_TEMPLATE_456", steps=self.steps
1234 )
1235 self._microversion_test(
1236 BaremetalClient.show_deploy_template,
1237 "1.55",
1238 lib_exc.NotFound,
1239 {"deploy_template_ident": deploy_template["uuid"]},
1240 )
1241
1242 @decorators.idempotent_id("f47a12a7-71b7-4ff0-ab17-9f45c9ac68e7")
1243 def test_update_deploy_template(self):
1244 patch = [{"op": "replace", "path": "/name", "value": "new_name"}]
1245 self._microversion_test(
1246 BaremetalClient.update_deploy_template,
1247 "1.55",
1248 lib_exc.UnexpectedResponseCode,
1249 {"deploy_template_ident": "fakedt", "patch": patch},
1250 )
1251
1252 @decorators.idempotent_id("b987a887-22ca-4ec9-a074-0a9bd3eac7ac")
1253 def test_delete_deploy_template(self):
1254 self._microversion_test(
1255 BaremetalClient.delete_deploy_template,
1256 "1.55",
1257 lib_exc.UnexpectedResponseCode,
1258 {"deploy_template_ident": "fakedt"},
1259 )
1260
1261
1262 class TestRunbookMicroversions(BaseTestMicroversionEnforcement,
1263 MicroversionTestMixin):
1264 """Tests for runbook-related API microversion enforcement.
1265
1266 The runbook API was introduced in microversion 1.92. Operations such as
1267 creating, updating, and deleting runbooks are expected to fail with an
1268 error if used with an unsupported microversion.
1269 """
1270
1271 min_microversion = "1.92"
1272
1273 @decorators.idempotent_id("e37be789-fcdf-435a-8a16-3d2f8f21e6e2")
1274 def test_create_runbook(self):
1275 # Define a minimal valid runbook payload.
1276 steps = [
1277 {
1278 "interface": "bios",
1279 "step": "apply_configuration",
1280 "order": 1,
1281 "args": {
1282 "settings": [
1283 {"name": "LogicalProc", "value": "Enabled"}
1284 ]
1285 }
1286 }
1287 ]
1288 self._microversion_test(
1289 BaremetalClient.create_runbook,
1290 "1.92",
1291 lib_exc.UnexpectedResponseCode,
1292 {"name": "CUSTOM_TEST", "steps": steps}
1293 )
1294
1295 @decorators.idempotent_id("f1b5b500-6b9c-41f6-bb99-3a77e3bd6ac4")
1296 def test_list_runbooks(self):
1297 self._microversion_test(
1298 BaremetalClient.list_runbooks,
1299 "1.92",
1300 lib_exc.NotFound,
1301 {}
1302 )
1303
1304 @decorators.idempotent_id("3d12345a-3d56-4fbb-afd2-7bd0ebc32e19")
1305 def test_show_runbook(self):
1306 steps = [
1307 {
1308 "interface": "bios",
1309 "step": "apply_configuration",
1310 "order": 1,
1311 "args": {
1312 "settings": [
1313 {"name": "LogicalProc", "value": "Enabled"}
1314 ]
1315 }
1316 }
1317 ]
1318 _, runbook = self.client.create_runbook("CUSTOM_TEST_2", steps=steps)
1319 self._microversion_test(
1320 BaremetalClient.show_runbook,
1321 "1.92",
1322 lib_exc.NotFound,
1323 {"runbook_ident": runbook['uuid']}
1324 )
1325
1326 @decorators.idempotent_id("a1e4cd23-56be-4b39-b756-9a9b73f21492")
1327 def test_update_runbook(self):
1328 # Using an example JSON PATCH document to update the runbook.
1329 patch_doc = [
1330 {"op": "replace", "path": "/name", "value": "CUSTOM_TEST2"}
1331 ]
1332 self._microversion_test(
1333 BaremetalClient.update_runbook,
1334 "1.92",
1335 lib_exc.UnexpectedResponseCode,
1336 {"runbook_ident": "fake_runbook", "patch": patch_doc}
1337 )
1338
1339 @decorators.idempotent_id("cb9cf9a6-2a3f-4aa7-9488-098f8aeeb5d9")
1340 def test_delete_runbook(self):
1341 self._microversion_test(
1342 BaremetalClient.delete_runbook,
1343 "1.92",
1344 lib_exc.UnexpectedResponseCode,
1345 {"runbook_ident": "fake_runbook"}
1346 )
1347
1348
1349 class TestNodeHistoryMicroversions(
1350 BaseTestMicroversionEnforcement, MicroversionTestMixin
1351 ):
1352 """Tests for node history-related API microversion enforcement."""
1353
1354 min_microversion = "1.78"
1355
1356 def setUp(self):
1357 super(TestNodeHistoryMicroversions, self).setUp()
1358 _, self.chassis = self.create_chassis()
1359 _, self.node = self.create_node(self.chassis["uuid"])
1360
1361 @decorators.idempotent_id("aea6cb45-6519-44d9-a33e-aab7cd72d769")
1362 def test_list_node_history(self):
1363 self._microversion_test(
1364 BaremetalClient.list_node_history,
1365 "1.78",
1366 lib_exc.NotFound,
1367 {"node_uuid": self.node["uuid"]},
1368 )
1369
1370
1371 # NOTE(adamcarthur) - The positive test for this will need a configured
1372 # node to have history.
1373 class TestNodeInventoryMicroversions(
1374 BaseTestMicroversionEnforcement, MicroversionTestMixin
1375 ):
1376 """Tests for node inventory-related API microversion enforcement."""
1377
1378 min_microversion = "1.81"
1379
1380 def setUp(self):
1381 super(TestNodeInventoryMicroversions, self).setUp()
1382 _, self.chassis = self.create_chassis()
1383 _, self.node = self.create_node(self.chassis["uuid"])
1384
1385 @decorators.idempotent_id("ca557dca-9b3e-44cb-a101-f31d58a0dedd")
1386 def test_show_node_inventory(self):
1387 _, node = self.client.show_node(self.node['uuid'])
1388 self._microversion_test(
1389 BaremetalClient.show_inventory,
1390 "1.81",
1391 lib_exc.NotFound,
1392 {"uuid": node["uuid"]},
1393 ignore_positive=True
1394 )
1395
1396
1397 class TestShardMicroversions(
1398 BaseTestMicroversionEnforcement,
1399 MicroversionTestMixin):
1400 """Tests for shard-related API microversion enforcement."""
1401
1402 min_microversion = "1.82"
1403
1404 @decorators.idempotent_id("e5403a31-e12b-4f97-a776-dcb819e5e9a0")
1405 def test_shard(self):
1406 self._microversion_test(
1407 BaremetalClient.get_shards, "1.82", lib_exc.NotFound, {}
1408 )
1409
1410 @decorators.idempotent_id("5df533c6-7a9c-4639-a47f-1377a2a87e6a")
1411 def test_list_node_filter_shard(self):
1412 self._microversion_test(
1413 BaremetalClient.list_nodes, "1.82",
1414 lib_exc.NotAcceptable, {"shard": "testshard"}
1415 )
1416
1417
1418 class TestChassisMicroversions(
1419 BaseTestMicroversionEnforcement, MicroversionTestMixin
1420 ):
1421 """Tests for chassis-related API microversion enforcement."""
1422
1423 min_microversion = "1.1"
1424
1425 def setUp(self):
1426 super(TestChassisMicroversions, self).setUp()
1427 _, self.chassis = self.create_chassis()
1428
1429 @decorators.idempotent_id("59c20dbf-280e-4148-ac8e-be3b8d75d021")
1430 def test_create_chassis(self):
1431 self._microversion_test(
1432 BaremetalClient.create_chassis, "1.1", lib_exc.NotAcceptable, {}
1433 )
1434
1435 @decorators.idempotent_id("0e840e17-5659-4ad9-a218-84b14bc8b013")
1436 def test_list_chassis(self):
1437 self._microversion_test(
1438 BaremetalClient.list_chassis, "1.1", lib_exc.NotAcceptable, {}
1439 )
1440
1441 @decorators.idempotent_id("6c3a5728-0d96-41aa-a3ca-295bfbbe341e")
1442 def test_show_chassis(self):
1443 self._microversion_test(
1444 BaremetalClient.show_chassis,
1445 "1.1",
1446 lib_exc.NotAcceptable,
1447 {"uuid": self.chassis["uuid"]},
1448 )
1449
1450 @decorators.idempotent_id("7ae8ca94-b7d9-4975-87c6-37d89779b8b5")
1451 def test_update_chassis(self):
1452 patch = [
1453 {"op": "replace", "path": "/description", "value": "new_desc"}
1454 ]
1455 self._microversion_test(
1456 BaremetalClient.update_chassis,
1457 "1.1",
1458 lib_exc.NotAcceptable,
1459 {"uuid": self.chassis["uuid"], "patch": patch},
1460 )
1461
1462 @decorators.idempotent_id("f6d70a3a-9212-46af-bb7b-c95a3043a722")
1463 def test_delete_chassis(self):
1464 self._microversion_test(
1465 BaremetalClient.delete_chassis,
1466 "1.1",
1467 lib_exc.NotAcceptable,
1468 {"uuid": self.chassis["uuid"]},
1469 )
1470
1471
1472 class TestUtilityMicroversions(
1473 BaseTestMicroversionEnforcement, MicroversionTestMixin
1474 ):
1475 """Tests for utility-related API microversion enforcement."""
1476
1477 min_microversion = "1.22"
1478
1479 def setUp(self):
1480 super(TestUtilityMicroversions, self).setUp()
1481 _, self.chassis = self.create_chassis()
1482 _, self.node = self.create_node(self.chassis["uuid"])
1483 self.callback_url = "http://example.com/callback"
1484 self.agent_version = "1.0"
1485 self.agent_token = "test_token"
1486
1487 @decorators.idempotent_id("dd2b17d9-c847-49bd-acfd-b3d63ae59f2f")
1488 def test_ipa_heartbeat(self):
1489 self._microversion_test(
1490 BaremetalClient.ipa_heartbeat,
1491 "1.22",
1492 lib_exc.NotFound,
1493 {
1494 "node_uuid": self.node["uuid"],
1495 "callback_url": self.callback_url,
1496 "agent_version": self.agent_version,
1497 "agent_token": self.agent_token,
1498 },
1499 )