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
26 class TransportOlmTesting(unittest.TestCase):
29 NODE_VERSION = '2.2.1'
33 cls.processes = test_utils.start_tpce()
34 cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION),
35 ('roadma', cls.NODE_VERSION),
36 ('roadmc', cls.NODE_VERSION),
37 ('xpdrc', cls.NODE_VERSION)])
40 def tearDownClass(cls):
41 # pylint: disable=not-an-iterable
42 for process in cls.processes:
43 test_utils.shutdown_process(process)
44 print("all processes killed")
47 # pylint: disable=consider-using-f-string
48 print("execution of {}".format(self.id().split(".")[-1]))
51 def test_01_xpdrA_device_connected(self):
52 response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
53 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
55 def test_02_xpdrC_device_connected(self):
56 response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION))
57 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
59 def test_03_rdmA_device_connected(self):
60 response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
61 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
63 def test_04_rdmC_device_connected(self):
64 response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
65 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
67 def test_05_connect_xprdA_to_roadmA(self):
68 response = test_utils.transportpce_api_rpc_request(
69 'transportpce-networkutils', 'init-xpdr-rdm-links',
70 {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1',
71 'rdm-node': 'ROADM-A1', '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.transportpce_api_rpc_request(
76 'transportpce-networkutils', 'init-rdm-xpdr-links',
77 {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1',
78 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
79 self.assertEqual(response['status_code'], requests.codes.ok)
81 def test_07_connect_xprdC_to_roadmC(self):
82 response = test_utils.transportpce_api_rpc_request(
83 'transportpce-networkutils', 'init-xpdr-rdm-links',
84 {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '1', 'network-num': '1',
85 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
86 self.assertEqual(response['status_code'], requests.codes.ok)
88 def test_08_connect_roadmC_to_xpdrC(self):
89 response = test_utils.transportpce_api_rpc_request(
90 'transportpce-networkutils', 'init-rdm-xpdr-links',
91 {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '1', 'network-num': '1',
92 'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
93 self.assertEqual(response['status_code'], requests.codes.ok)
95 def test_09_create_OTS_ROADMA(self):
96 response = test_utils.transportpce_api_rpc_request(
97 'transportpce-device-renderer', 'create-ots-oms',
99 'node-id': 'ROADM-A1',
100 'logical-connection-point': 'DEG1-TTP-TXRX'
102 self.assertEqual(response['status_code'], requests.codes.ok)
104 def test_10_create_OTS_ROADMC(self):
105 response = test_utils.transportpce_api_rpc_request(
106 'transportpce-device-renderer', 'create-ots-oms',
108 'node-id': 'ROADM-C1',
109 'logical-connection-point': 'DEG2-TTP-TXRX'
111 self.assertEqual(response['status_code'], requests.codes.ok)
113 def test_11_get_PM_ROADMA(self):
114 response = test_utils.transportpce_api_rpc_request(
115 'transportpce-olm', 'get-pm',
117 'node-id': 'ROADM-A1',
118 'resource-type': 'interface',
119 'granularity': '15min',
120 'resource-identifier': {
121 'resource-name': 'OTS-DEG2-TTP-TXRX'
125 self.assertEqual(response['status_code'], requests.codes.ok)
127 for measure in response['output']['measurements']:
128 if bool(measure['pmparameter-name']) and bool(measure['pmparameter-value']):
129 measures[measure['pmparameter-name']] = float(measure['pmparameter-value'])
130 self.assertIn('OpticalPowerOutput', list(measures.keys()))
131 self.assertIn('OpticalReturnLoss', list(measures.keys()))
132 self.assertIn('OpticalPowerInput', list(measures.keys()))
133 self.assertEqual(measures['OpticalPowerOutput'], 2.5)
134 self.assertEqual(measures['OpticalReturnLoss'], 40)
135 self.assertEqual(measures['OpticalPowerInput'], -21.1)
137 def test_12_get_PM_ROADMC(self):
138 response = test_utils.transportpce_api_rpc_request(
139 'transportpce-olm', 'get-pm',
141 'node-id': 'ROADM-C1',
142 'resource-type': 'interface',
143 'granularity': '15min',
144 'resource-identifier': {
145 'resource-name': 'OTS-DEG1-TTP-TXRX'
148 self.assertEqual(response['status_code'], requests.codes.ok)
150 for measure in response['output']['measurements']:
151 if bool(measure['pmparameter-name']) and bool(measure['pmparameter-value']):
152 measures[measure['pmparameter-name']] = float(measure['pmparameter-value'])
153 self.assertIn('OpticalPowerOutput', list(measures.keys()))
154 self.assertIn('OpticalReturnLoss', list(measures.keys()))
155 self.assertIn('OpticalPowerInput', list(measures.keys()))
156 self.assertEqual(measures['OpticalPowerOutput'], 4.6)
157 self.assertEqual(measures['OpticalReturnLoss'], 49.1)
158 self.assertEqual(measures['OpticalPowerInput'], -15.1)
160 def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
161 response = test_utils.transportpce_api_rpc_request(
162 'transportpce-olm', 'calculate-spanloss-base',
165 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
167 self.assertEqual(response['status_code'], requests.codes.ok)
168 self.assertIn('Success',
169 response['output']['result'])
172 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
173 }, response['output']['spans'])
176 def test_14_calculate_span_loss_base_all(self):
177 response = test_utils.transportpce_api_rpc_request(
178 'transportpce-olm', 'calculate-spanloss-base',
182 self.assertEqual(response['status_code'], requests.codes.ok)
183 self.assertIn('Success',
184 response['output']['result'])
187 'link-id': 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'
188 }, response['output']['spans'])
191 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
192 }, response['output']['spans'])
195 def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
196 response = test_utils.check_node_attribute2_request(
197 'ROADM-A1', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
198 self.assertEqual(response['status_code'], requests.codes.ok)
199 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 17.6)
200 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 25.7)
202 def test_16_get_OTS_DEG1_TTP_TXRX_ROADMC(self):
203 response = test_utils.check_node_attribute2_request(
204 'ROADM-C1', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
205 self.assertEqual(response['status_code'], requests.codes.ok)
206 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 25.7)
207 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 17.6)
209 def test_17_servicePath_create_AToZ(self):
210 response = test_utils.transportpce_api_rpc_request(
211 'transportpce-device-renderer', 'service-path',
213 'service-name': 'test',
215 'modulation-format': 'dp-qpsk',
216 'operation': 'create',
218 [{'node-id': 'XPDR-A1',
219 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
220 {'node-id': 'ROADM-A1',
221 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
222 {'node-id': 'ROADM-C1',
223 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG1-TTP-TXRX'},
224 {'node-id': 'XPDR-C1',
225 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
226 'center-freq': 196.1,
230 'lower-spectral-slot-number': 761,
231 'higher-spectral-slot-number': 768
233 self.assertEqual(response['status_code'], requests.codes.ok)
234 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
237 def test_18_servicePath_create_ZToA(self):
238 response = test_utils.transportpce_api_rpc_request(
239 'transportpce-device-renderer', 'service-path',
241 'service-name': 'test',
243 'modulation-format': 'dp-qpsk',
244 'operation': 'create',
246 [{'node-id': 'XPDR-C1',
247 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
248 {'node-id': 'ROADM-C1',
249 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
250 {'node-id': 'ROADM-A1',
251 'src-tp': 'DEG2-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
252 {'node-id': 'XPDR-A1',
253 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
254 'center-freq': 196.1,
258 'lower-spectral-slot-number': 761,
259 'higher-spectral-slot-number': 768
261 self.assertEqual(response['status_code'], requests.codes.ok)
262 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
265 def test_19_service_power_setup_XPDRA_XPDRC(self):
266 response = test_utils.transportpce_api_rpc_request(
267 'transportpce-olm', 'service-power-setup',
269 'service-name': 'test',
273 'dest-tp': 'XPDR1-NETWORK1',
274 'src-tp': 'XPDR1-CLIENT1',
278 'dest-tp': 'DEG2-TTP-TXRX',
279 'src-tp': 'SRG1-PP1-TXRX',
280 'node-id': 'ROADM-A1'
283 'dest-tp': 'SRG1-PP1-TXRX',
284 'src-tp': 'DEG1-TTP-TXRX',
285 'node-id': 'ROADM-C1'
288 'dest-tp': 'XPDR1-CLIENT1',
289 'src-tp': 'XPDR1-NETWORK1',
293 'lower-spectral-slot-number': 761,
294 'higher-spectral-slot-number': 768
296 self.assertEqual(response['status_code'], requests.codes.ok)
297 self.assertIn('Success', response['output']['result'])
299 def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
300 response = test_utils.check_node_attribute2_request(
301 'XPDR-A1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
302 self.assertEqual(response['status_code'], requests.codes.ok)
303 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
304 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
306 def test_21_get_roadmconnection_ROADMA(self):
307 response = test_utils.check_node_attribute_request(
308 'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
309 self.assertEqual(response['status_code'], requests.codes.ok)
310 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
311 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 0.21)
313 def test_22_get_roadmconnection_ROADMC(self):
314 response = test_utils.check_node_attribute_request(
315 'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
316 self.assertEqual(response['status_code'], requests.codes.ok)
317 self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
319 def test_23_service_power_setup_XPDRC_XPDRA(self):
320 response = test_utils.transportpce_api_rpc_request(
321 'transportpce-olm', 'service-power-setup',
323 'service-name': 'test',
327 'dest-tp': 'XPDR1-NETWORK1',
328 'src-tp': 'XPDR1-CLIENT1',
332 'dest-tp': 'DEG1-TTP-TXRX',
333 'src-tp': 'SRG1-PP1-TXRX',
334 'node-id': 'ROADM-C1'
337 'src-tp': 'DEG2-TTP-TXRX',
338 'dest-tp': 'SRG1-PP1-TXRX',
339 'node-id': 'ROADM-A1'
342 'src-tp': 'XPDR1-NETWORK1',
343 'dest-tp': 'XPDR1-CLIENT1',
347 'lower-spectral-slot-number': 761,
348 'higher-spectral-slot-number': 768
350 self.assertEqual(response['status_code'], requests.codes.ok)
351 self.assertIn('Success', response['output']['result'])
353 def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
354 response = test_utils.check_node_attribute2_request(
355 'XPDR-C1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
356 self.assertEqual(response['status_code'], requests.codes.ok)
357 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
358 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
360 def test_25_get_roadmconnection_ROADMC(self):
361 response = test_utils.check_node_attribute_request(
362 'ROADM-C1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
363 self.assertEqual(response['status_code'], requests.codes.ok)
364 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
365 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 2.0)
367 def test_26_service_power_turndown_XPDRA_XPDRC(self):
368 response = test_utils.transportpce_api_rpc_request(
369 'transportpce-olm', 'service-power-turndown',
371 'service-name': 'test',
375 'dest-tp': 'XPDR1-NETWORK1',
376 'src-tp': 'XPDR1-CLIENT1',
380 'dest-tp': 'DEG2-TTP-TXRX',
381 'src-tp': 'SRG1-PP1-TXRX',
382 'node-id': 'ROADM-A1'
385 'dest-tp': 'SRG1-PP1-TXRX',
386 'src-tp': 'DEG1-TTP-TXRX',
387 'node-id': 'ROADM-C1'
390 'dest-tp': 'XPDR1-CLIENT1',
391 'src-tp': 'XPDR1-NETWORK1',
395 'lower-spectral-slot-number': 761,
396 'higher-spectral-slot-number': 768
398 self.assertEqual(response['status_code'], requests.codes.ok)
399 self.assertIn('Success', response['output']['result'])
401 def test_27_get_roadmconnection_ROADMA(self):
402 response = test_utils.check_node_attribute_request(
403 'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
404 self.assertEqual(response['status_code'], requests.codes.ok)
405 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
406 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
408 def test_28_get_roadmconnection_ROADMC(self):
409 response = test_utils.check_node_attribute_request(
410 'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
411 self.assertEqual(response['status_code'], requests.codes.ok)
412 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
414 def test_29_servicePath_delete_AToZ(self):
415 response = test_utils.transportpce_api_rpc_request(
416 'transportpce-device-renderer', 'service-path',
418 'service-name': 'test',
420 'modulation-format': 'dp-qpsk',
421 'operation': 'delete',
423 [{'node-id': 'XPDR-A1',
424 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
425 {'node-id': 'ROADM-A1',
426 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
427 {'node-id': 'ROADM-C1',
428 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG1-TTP-TXRX'},
429 {'node-id': 'XPDR-C1',
430 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
431 'center-freq': 196.1,
435 'lower-spectral-slot-number': 761,
436 'higher-spectral-slot-number': 768
438 self.assertEqual(response['status_code'], requests.codes.ok)
439 self.assertIn('Request processed', response['output']['result'])
442 def test_30_servicePath_delete_ZToA(self):
443 response = test_utils.transportpce_api_rpc_request(
444 'transportpce-device-renderer', 'service-path',
446 'service-name': 'test',
448 'modulation-format': 'dp-qpsk',
449 'operation': 'delete',
451 [{'node-id': 'XPDR-C1',
452 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
453 {'node-id': 'ROADM-C1',
454 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
455 {'node-id': 'ROADM-A1',
456 'src-tp': 'DEG2-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
457 {'node-id': 'XPDR-A1',
458 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
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 # """to test case where SRG where the xpdr is connected to has no optical range data"""
472 def test_31_connect_xprdA_to_roadmA(self):
473 response = test_utils.transportpce_api_rpc_request(
474 'transportpce-networkutils', 'init-xpdr-rdm-links',
475 {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2',
476 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
477 self.assertEqual(response['status_code'], requests.codes.ok)
479 def test_32_connect_roadmA_to_xpdrA(self):
480 response = test_utils.transportpce_api_rpc_request(
481 'transportpce-networkutils', 'init-rdm-xpdr-links',
482 {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2',
483 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
484 self.assertEqual(response['status_code'], requests.codes.ok)
486 def test_33_servicePath_create_AToZ(self):
487 response = test_utils.transportpce_api_rpc_request(
488 'transportpce-device-renderer', 'service-path',
490 'service-name': 'test2',
492 'modulation-format': 'dp-qpsk',
493 'operation': 'create',
495 [{'node-id': 'XPDR-A1',
496 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
497 {'node-id': 'ROADM-A1',
498 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
499 'center-freq': 196.1,
503 'lower-spectral-slot-number': 753,
504 'higher-spectral-slot-number': 760
506 self.assertEqual(response['status_code'], requests.codes.ok)
507 self.assertIn('Interfaces created successfully for nodes', response['output']['result'])
510 def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
511 response = test_utils.check_node_attribute2_request(
512 'XPDR-A1', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
513 self.assertEqual(response['status_code'], requests.codes.ok)
514 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
515 # self.assertEqual(2, response['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
517 def test_35_servicePath_delete_AToZ(self):
518 response = test_utils.transportpce_api_rpc_request(
519 'transportpce-device-renderer', 'service-path',
521 'service-name': 'test2',
523 'modulation-format': 'dp-qpsk',
524 'operation': 'delete',
526 [{'node-id': 'XPDR-A1',
527 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
528 {'node-id': 'ROADM-A1',
529 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
530 'center-freq': 196.1,
534 'lower-spectral-slot-number': 753,
535 'higher-spectral-slot-number': 760
537 self.assertEqual(response['status_code'], requests.codes.ok)
538 self.assertIn('Request processed', response['output']['result'])
541 def test_36_xpdrA_device_disconnected(self):
542 response = test_utils.unmount_device("XPDR-A1")
543 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
545 def test_37_xpdrC_device_disconnected(self):
546 response = test_utils.unmount_device("XPDR-C1")
547 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
549 def test_38_calculate_span_loss_current(self):
550 response = test_utils.transportpce_api_rpc_request(
551 'transportpce-olm', 'calculate-spanloss-current',
553 self.assertEqual(response['status_code'], requests.codes.ok)
554 self.assertIn('Success',
555 response["output"]["result"])
558 def test_39_rdmA_device_disconnected(self):
559 response = test_utils.unmount_device("ROADM-A1")
560 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
562 def test_40_rdmC_device_disconnected(self):
563 response = test_utils.unmount_device("ROADM-C1")
564 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
567 if __name__ == "__main__":
568 unittest.main(verbosity=2)