3 #############################################################################
4 # Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
6 # All rights reserved. This program and the accompanying materials
7 # are made available under the terms of the Apache License, Version 2.0
8 # which accompanies this distribution, and is available at
9 # http://www.apache.org/licenses/LICENSE-2.0
10 #############################################################################
12 # pylint: disable=no-member
13 # pylint: disable=too-many-public-methods
18 # pylint: disable=wrong-import-order
20 sys.path.append('transportpce_tests/common/')
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-error
23 import test_utils # nopep8
24 import test_utils_rfc8040 # nopep8
27 class TransportOlmTesting(unittest.TestCase):
30 NODE_VERSION = '1.2.1'
34 cls.processes = test_utils_rfc8040.start_tpce()
35 cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION),
36 ('roadma-full', cls.NODE_VERSION),
37 ('roadmc-full', cls.NODE_VERSION),
38 ('xpdrc', cls.NODE_VERSION)])
41 def tearDownClass(cls):
42 # pylint: disable=not-an-iterable
43 for process in cls.processes:
44 test_utils_rfc8040.shutdown_process(process)
45 print("all processes killed")
48 # pylint: disable=consider-using-f-string
49 print("execution of {}".format(self.id().split(".")[-1]))
52 def test_01_xpdrA_device_connected(self):
53 response = test_utils_rfc8040.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
54 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
56 def test_02_xpdrC_device_connected(self):
57 response = test_utils_rfc8040.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION))
58 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
60 def test_03_rdmA_device_connected(self):
61 response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma-full', self.NODE_VERSION))
62 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
64 def test_04_rdmC_device_connected(self):
65 response = test_utils_rfc8040.mount_device("ROADMC01", ('roadmc-full', self.NODE_VERSION))
66 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
68 def test_05_connect_xprdA_to_roadmA(self):
69 response = test_utils_rfc8040.connect_xpdr_to_rdm_request(
70 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
71 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
72 self.assertEqual(response.status_code, requests.codes.ok)
74 def test_06_connect_roadmA_to_xpdrA(self):
75 response = test_utils_rfc8040.connect_rdm_to_xpdr_request(
76 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
77 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
78 self.assertEqual(response.status_code, requests.codes.ok)
80 def test_07_connect_xprdC_to_roadmC(self):
81 response = test_utils_rfc8040.connect_xpdr_to_rdm_request(
82 {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1',
83 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
84 self.assertEqual(response.status_code, requests.codes.ok)
86 def test_08_connect_roadmC_to_xpdrC(self):
87 response = test_utils_rfc8040.connect_rdm_to_xpdr_request(
88 {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1',
89 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
90 self.assertEqual(response.status_code, requests.codes.ok)
92 def test_09_create_OTS_ROADMA(self):
93 response = test_utils.create_ots_oms_request("ROADMA01", "DEG1-TTP-TXRX")
94 self.assertEqual(response.status_code, requests.codes.ok)
96 self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADMA01',
97 res["output"]["result"])
99 def test_10_create_OTS_ROADMC(self):
100 response = test_utils.create_ots_oms_request("ROADMC01", "DEG2-TTP-TXRX")
101 self.assertEqual(response.status_code, requests.codes.ok)
102 res = response.json()
103 self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADMC01',
104 res["output"]["result"])
106 def test_11_get_PM_ROADMA(self):
107 url = "{}/operations/transportpce-olm:get-pm"
110 "node-id": "ROADMA01",
111 "resource-type": "interface",
112 "granularity": "15min",
113 "resource-identifier": {
114 "resource-name": "OTS-DEG1-TTP-TXRX"
118 response = test_utils.post_request(url, data)
119 self.assertEqual(response.status_code, requests.codes.ok)
120 res = response.json()
122 "pmparameter-name": "OpticalPowerOutput",
123 "pmparameter-value": "2.5"
124 }, res["output"]["measurements"])
126 "pmparameter-name": "OpticalReturnLoss",
127 "pmparameter-value": "49.9"
128 }, res["output"]["measurements"])
130 "pmparameter-name": "OpticalPowerInput",
131 "pmparameter-value": "3"
132 }, res["output"]["measurements"])
134 def test_12_get_PM_ROADMC(self):
135 url = "{}/operations/transportpce-olm:get-pm"
138 "node-id": "ROADMC01",
139 "resource-type": "interface",
140 "granularity": "15min",
141 "resource-identifier": {
142 "resource-name": "OTS-DEG2-TTP-TXRX"
146 response = test_utils.post_request(url, data)
147 self.assertEqual(response.status_code, requests.codes.ok)
148 res = response.json()
150 "pmparameter-name": "OpticalPowerOutput",
151 "pmparameter-value": "18.1"
152 }, res["output"]["measurements"])
154 "pmparameter-name": "OpticalReturnLoss",
155 "pmparameter-value": "48.8"
156 }, res["output"]["measurements"])
158 "pmparameter-name": "OpticalPowerInput",
159 "pmparameter-value": "-3.2"
160 }, res["output"]["measurements"])
162 def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
163 url = "{}/operations/transportpce-olm:calculate-spanloss-base"
167 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
170 response = test_utils.post_request(url, data)
171 self.assertEqual(response.status_code, requests.codes.ok)
172 res = response.json()
173 self.assertIn('Success',
174 res["output"]["result"])
177 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
178 }, res["output"]["spans"])
181 def test_14_calculate_span_loss_base_all(self):
182 url = "{}/operations/transportpce-olm:calculate-spanloss-base"
188 response = test_utils.post_request(url, data)
189 self.assertEqual(response.status_code, requests.codes.ok)
190 res = response.json()
191 self.assertIn('Success',
192 res["output"]["result"])
195 "link-id": "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX"
196 }, res["output"]["spans"])
199 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
200 }, res["output"]["spans"])
203 def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
204 response = test_utils_rfc8040.check_node_attribute2_request(
205 'ROADMA01', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
206 self.assertEqual(response['status_code'], requests.codes.ok)
207 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 5.7)
208 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 15.1)
209 # FIXME test_utils_rfc8040.check_node_attribute2_request retrives values in config DS
210 # but values are different (6 and 15) in nonconfig/operational DS and should not
211 # Honeynode simulator bug ?
212 # Reopen similar issues found in RSPN tests at TRNSPRTPCE-591
214 def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
215 response = test_utils_rfc8040.check_node_attribute2_request(
216 'ROADMC01', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
217 self.assertEqual(response['status_code'], requests.codes.ok)
218 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 15.1)
219 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 5.7)
221 def test_17_servicePath_create_AToZ(self):
222 response = test_utils_rfc8040.device_renderer_service_path_request({
223 'service-name': 'test',
225 'modulation-format': 'dp-qpsk',
226 'operation': 'create',
228 [{'node-id': 'XPDRA01',
229 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
230 {'node-id': 'ROADMA01',
231 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
232 {'node-id': 'ROADMC01',
233 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG2-TTP-TXRX'},
234 {'node-id': 'XPDRC01',
235 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
236 'center-freq': 196.1,
240 'lower-spectral-slot-number': 761,
241 'higher-spectral-slot-number': 768
243 self.assertEqual(response['status_code'], requests.codes.ok)
244 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
247 def test_18_servicePath_create_ZToA(self):
248 response = test_utils_rfc8040.device_renderer_service_path_request({
249 'service-name': 'test',
251 'modulation-format': 'dp-qpsk',
252 'operation': 'create',
254 [{'node-id': 'XPDRC01',
255 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
256 {'node-id': 'ROADMC01',
257 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
258 {'node-id': 'ROADMA01',
259 'src-tp': 'DEG1-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
260 {'node-id': 'XPDRA01',
261 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
262 'center-freq': 196.1,
266 'lower-spectral-slot-number': 761,
267 'higher-spectral-slot-number': 768
269 self.assertEqual(response['status_code'], requests.codes.ok)
270 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
273 def test_19_service_power_setup_XPDRA_XPDRC(self):
274 url = "{}/operations/transportpce-olm:service-power-setup"
277 "service-name": "test",
281 "dest-tp": "XPDR1-NETWORK1",
282 "src-tp": "XPDR1-CLIENT1",
286 "dest-tp": "DEG1-TTP-TXRX",
287 "src-tp": "SRG1-PP1-TXRX",
288 "node-id": "ROADMA01"
291 "dest-tp": "SRG1-PP1-TXRX",
292 "src-tp": "DEG2-TTP-TXRX",
293 "node-id": "ROADMC01"
296 "dest-tp": "XPDR1-CLIENT1",
297 "src-tp": "XPDR1-NETWORK1",
301 "center-freq": 196.1,
305 "lower-spectral-slot-number": 761,
306 "higher-spectral-slot-number": 768
309 response = test_utils.post_request(url, data)
310 self.assertEqual(response.status_code, requests.codes.ok)
311 res = response.json()
312 self.assertIn('Success', res["output"]["result"])
314 def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
315 response = test_utils_rfc8040.check_node_attribute2_request(
316 'XPDRA01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
317 self.assertEqual(response['status_code'], requests.codes.ok)
318 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
319 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
321 def test_21_get_roadmconnection_ROADMA(self):
322 response = test_utils_rfc8040.check_node_attribute_request(
323 'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
324 self.assertEqual(response['status_code'], requests.codes.ok)
325 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
326 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -3.3)
328 def test_22_get_roadmconnection_ROADMC(self):
329 response = test_utils_rfc8040.check_node_attribute_request(
330 'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
331 self.assertEqual(response['status_code'], requests.codes.ok)
332 self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
334 def test_23_service_power_setup_XPDRC_XPDRA(self):
335 url = "{}/operations/transportpce-olm:service-power-setup"
338 "service-name": "test",
342 "dest-tp": "XPDR1-NETWORK1",
343 "src-tp": "XPDR1-CLIENT1",
347 "dest-tp": "DEG2-TTP-TXRX",
348 "src-tp": "SRG1-PP1-TXRX",
349 "node-id": "ROADMC01"
352 "src-tp": "DEG1-TTP-TXRX",
353 "dest-tp": "SRG1-PP1-TXRX",
354 "node-id": "ROADMA01"
357 "src-tp": "XPDR1-NETWORK1",
358 "dest-tp": "XPDR1-CLIENT1",
362 "center-freq": 196.1,
366 "lower-spectral-slot-number": 761,
367 "higher-spectral-slot-number": 768
370 response = test_utils.post_request(url, data)
371 self.assertEqual(response.status_code, requests.codes.ok)
372 res = response.json()
373 self.assertIn('Success', res["output"]["result"])
375 def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
376 response = test_utils_rfc8040.check_node_attribute2_request(
377 'XPDRC01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
378 self.assertEqual(response['status_code'], requests.codes.ok)
379 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
380 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
382 def test_25_get_roadmconnection_ROADMC(self):
383 response = test_utils_rfc8040.check_node_attribute_request(
384 'ROADMC01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
385 self.assertEqual(response['status_code'], requests.codes.ok)
386 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
387 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -0.63)
389 def test_26_service_power_turndown_XPDRA_XPDRC(self):
390 url = "{}/operations/transportpce-olm:service-power-turndown"
393 "service-name": "test",
397 "dest-tp": "XPDR1-NETWORK1",
398 "src-tp": "XPDR1-CLIENT1",
402 "dest-tp": "DEG1-TTP-TXRX",
403 "src-tp": "SRG1-PP1-TXRX",
404 "node-id": "ROADMA01"
407 "dest-tp": "SRG1-PP1-TXRX",
408 "src-tp": "DEG2-TTP-TXRX",
409 "node-id": "ROADMC01"
412 "dest-tp": "XPDR1-CLIENT1",
413 "src-tp": "XPDR1-NETWORK1",
417 "center-freq": 196.1,
421 "lower-spectral-slot-number": 761,
422 "higher-spectral-slot-number": 768
425 response = test_utils.post_request(url, data)
426 print(response.json())
427 self.assertEqual(response.status_code, requests.codes.ok)
428 res = response.json()
429 self.assertIn('Success', res["output"]["result"])
431 def test_27_get_roadmconnection_ROADMA(self):
432 response = test_utils_rfc8040.check_node_attribute_request(
433 'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
434 self.assertEqual(response['status_code'], requests.codes.ok)
435 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
436 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
438 def test_28_get_roadmconnection_ROADMC(self):
439 response = test_utils_rfc8040.check_node_attribute_request(
440 'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
441 self.assertEqual(response['status_code'], requests.codes.ok)
442 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
444 def test_29_servicePath_delete_AToZ(self):
445 response = test_utils_rfc8040.device_renderer_service_path_request({
446 'service-name': 'test',
448 'modulation-format': 'dp-qpsk',
449 'operation': 'delete',
451 [{'node-id': 'XPDRA01',
452 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
453 {'node-id': 'ROADMA01',
454 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
455 {'node-id': 'ROADMC01',
456 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG2-TTP-TXRX'},
457 {'node-id': 'XPDRC01',
458 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
459 'center-freq': 196.1,
463 'lower-spectral-slot-number': 761,
464 'higher-spectral-slot-number': 768
466 self.assertEqual(response['status_code'], requests.codes.ok)
467 self.assertIn('Request processed', response['output']['result'])
470 def test_30_servicePath_delete_ZToA(self):
471 response = test_utils_rfc8040.device_renderer_service_path_request({
472 'service-name': 'test',
474 'modulation-format': 'dp-qpsk',
475 'operation': 'delete',
477 [{'node-id': 'XPDRC01',
478 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
479 {'node-id': 'ROADMC01',
480 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
481 {'node-id': 'ROADMA01',
482 'src-tp': 'DEG1-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
483 {'node-id': 'XPDRA01',
484 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
485 'center-freq': 196.1,
489 'lower-spectral-slot-number': 761,
490 'higher-spectral-slot-number': 768
492 self.assertEqual(response['status_code'], requests.codes.ok)
493 self.assertIn('Request processed', response['output']['result'])
496 #"""to test case where SRG where the xpdr is connected to has no optical range data"""
498 def test_31_connect_xprdA_to_roadmA(self):
499 response = test_utils_rfc8040.connect_xpdr_to_rdm_request(
500 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2',
501 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'})
502 self.assertEqual(response.status_code, requests.codes.ok)
504 def test_32_connect_roadmA_to_xpdrA(self):
505 response = test_utils_rfc8040.connect_rdm_to_xpdr_request(
506 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2',
507 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'})
508 self.assertEqual(response.status_code, requests.codes.ok)
510 def test_33_servicePath_create_AToZ(self):
511 response = test_utils_rfc8040.device_renderer_service_path_request({
512 'service-name': 'test2',
514 'modulation-format': 'dp-qpsk',
515 'operation': 'create',
517 [{'node-id': 'XPDRA01',
518 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
519 {'node-id': 'ROADMA01',
520 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
521 'center-freq': 196.05,
525 'lower-spectral-slot-number': 753,
526 'higher-spectral-slot-number': 760
528 self.assertEqual(response['status_code'], requests.codes.ok)
529 self.assertIn('Interfaces created successfully for nodes', response['output']['result'])
532 def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
533 response = test_utils_rfc8040.check_node_attribute2_request(
534 'XPDRA01', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
535 self.assertEqual(response['status_code'], requests.codes.ok)
536 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
537 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 2)
539 def test_35_servicePath_delete_AToZ(self):
540 response = test_utils_rfc8040.device_renderer_service_path_request({
541 'service-name': 'test2',
543 'modulation-format': 'dp-qpsk',
544 'operation': 'delete',
546 [{'node-id': 'XPDRA01',
547 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
548 {'node-id': 'ROADMA01',
549 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
550 'center-freq': 196.05,
554 'lower-spectral-slot-number': 753,
555 'higher-spectral-slot-number': 760
557 self.assertEqual(response['status_code'], requests.codes.ok)
558 self.assertIn('Request processed', response['output']['result'])
561 def test_36_xpdrA_device_disconnected(self):
562 response = test_utils_rfc8040.unmount_device("XPDRA01")
563 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
565 def test_37_xpdrC_device_disconnected(self):
566 response = test_utils_rfc8040.unmount_device("XPDRC01")
567 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
569 def test_38_calculate_span_loss_current(self):
570 url = "{}/operations/transportpce-olm:calculate-spanloss-current"
571 response = test_utils.post_request(url, None)
572 self.assertEqual(response.status_code, requests.codes.ok)
573 res = response.json()
574 self.assertIn('Success',
575 res["output"]["result"])
578 def test_39_rdmA_device_disconnected(self):
579 response = test_utils_rfc8040.unmount_device("ROADMA01")
580 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
582 def test_40_rdmC_device_disconnected(self):
583 response = test_utils_rfc8040.unmount_device("ROADMC01")
584 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
587 if __name__ == "__main__":
588 unittest.main(verbosity=2)