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_rfc8040 # nopep8
26 class TransportOlmTesting(unittest.TestCase):
29 NODE_VERSION = '1.2.1'
33 cls.processes = test_utils_rfc8040.start_tpce()
34 cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION),
35 ('roadma-full', cls.NODE_VERSION),
36 ('roadmc-full', 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_rfc8040.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_rfc8040.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
53 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
55 def test_02_xpdrC_device_connected(self):
56 response = test_utils_rfc8040.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION))
57 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
59 def test_03_rdmA_device_connected(self):
60 response = test_utils_rfc8040.mount_device("ROADMA01", ('roadma-full', self.NODE_VERSION))
61 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
63 def test_04_rdmC_device_connected(self):
64 response = test_utils_rfc8040.mount_device("ROADMC01", ('roadmc-full', self.NODE_VERSION))
65 self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
67 def test_05_connect_xprdA_to_roadmA(self):
68 response = test_utils_rfc8040.transportpce_api_rpc_request(
69 'transportpce-networkutils', 'init-xpdr-rdm-links',
70 {'links-input': {'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.transportpce_api_rpc_request(
76 'transportpce-networkutils', 'init-rdm-xpdr-links',
77 {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
78 'rdm-node': 'ROADMA01', '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_rfc8040.transportpce_api_rpc_request(
83 'transportpce-networkutils', 'init-xpdr-rdm-links',
84 {'links-input': {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1',
85 'rdm-node': 'ROADMC01', '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_rfc8040.transportpce_api_rpc_request(
90 'transportpce-networkutils', 'init-rdm-xpdr-links',
91 {'links-input': {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1',
92 'rdm-node': 'ROADMC01', '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_rfc8040.transportpce_api_rpc_request(
97 'transportpce-device-renderer', 'create-ots-oms',
99 'node-id': 'ROADMA01',
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_rfc8040.transportpce_api_rpc_request(
106 'transportpce-device-renderer', 'create-ots-oms',
108 'node-id': 'ROADMC01',
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_rfc8040.transportpce_api_rpc_request(
115 'transportpce-olm', 'get-pm',
117 'node-id': 'ROADMA01',
118 'resource-type': 'interface',
119 'granularity': '15min',
120 'resource-identifier': {
121 'resource-name': 'OTS-DEG1-TTP-TXRX'
124 self.assertEqual(response['status_code'], requests.codes.ok)
126 'pmparameter-name': 'OpticalPowerOutput',
127 'pmparameter-value': '2.50'
128 }, response['output']['measurements'])
130 'pmparameter-name': 'OpticalReturnLoss',
131 'pmparameter-value': '49.90'
132 }, response['output']['measurements'])
134 'pmparameter-name': 'OpticalPowerInput',
135 'pmparameter-value': '3'
136 }, response['output']['measurements'])
138 def test_12_get_PM_ROADMC(self):
139 response = test_utils_rfc8040.transportpce_api_rpc_request(
140 'transportpce-olm', 'get-pm',
142 'node-id': 'ROADMC01',
143 'resource-type': 'interface',
144 'granularity': '15min',
145 'resource-identifier': {
146 'resource-name': 'OTS-DEG2-TTP-TXRX'
149 self.assertEqual(response['status_code'], requests.codes.ok)
151 'pmparameter-name': 'OpticalPowerOutput',
152 'pmparameter-value': '18.10'
153 }, response['output']['measurements'])
155 'pmparameter-name': 'OpticalReturnLoss',
156 'pmparameter-value': '48.80'
157 }, response['output']['measurements'])
159 'pmparameter-name': 'OpticalPowerInput',
160 'pmparameter-value': '-3.20'
161 }, response['output']['measurements'])
163 def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
164 response = test_utils_rfc8040.transportpce_api_rpc_request(
165 'transportpce-olm', 'calculate-spanloss-base',
168 'link-id': 'ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX'
170 self.assertEqual(response['status_code'], requests.codes.ok)
171 self.assertIn('Success',
172 response['output']['result'])
175 'link-id': 'ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX'
176 }, response['output']['spans'])
179 def test_14_calculate_span_loss_base_all(self):
180 response = test_utils_rfc8040.transportpce_api_rpc_request(
181 'transportpce-olm', 'calculate-spanloss-base',
185 self.assertEqual(response['status_code'], requests.codes.ok)
186 self.assertIn('Success',
187 response['output']['result'])
190 'link-id': 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX'
191 }, response['output']['spans'])
194 'link-id': 'ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX'
195 }, response['output']['spans'])
198 def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
199 response = test_utils_rfc8040.check_node_attribute2_request(
200 'ROADMA01', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
201 self.assertEqual(response['status_code'], requests.codes.ok)
202 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 5.7)
203 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 15.1)
204 # FIXME test_utils_rfc8040.check_node_attribute2_request retrives values in config DS
205 # but values are different (6 and 15) in nonconfig/operational DS and should not
206 # Honeynode simulator bug ?
207 # Reopen similar issues found in RSPN tests at TRNSPRTPCE-591
209 def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
210 response = test_utils_rfc8040.check_node_attribute2_request(
211 'ROADMC01', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
212 self.assertEqual(response['status_code'], requests.codes.ok)
213 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 15.1)
214 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 5.7)
216 def test_17_servicePath_create_AToZ(self):
217 response = test_utils_rfc8040.transportpce_api_rpc_request(
218 'transportpce-device-renderer', 'service-path',
220 'service-name': 'test',
222 'modulation-format': 'dp-qpsk',
223 'operation': 'create',
225 [{'node-id': 'XPDRA01',
226 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
227 {'node-id': 'ROADMA01',
228 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
229 {'node-id': 'ROADMC01',
230 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG2-TTP-TXRX'},
231 {'node-id': 'XPDRC01',
232 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
233 'center-freq': 196.1,
237 'lower-spectral-slot-number': 761,
238 'higher-spectral-slot-number': 768
240 self.assertEqual(response['status_code'], requests.codes.ok)
241 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
244 def test_18_servicePath_create_ZToA(self):
245 response = test_utils_rfc8040.transportpce_api_rpc_request(
246 'transportpce-device-renderer', 'service-path',
248 'service-name': 'test',
250 'modulation-format': 'dp-qpsk',
251 'operation': 'create',
253 [{'node-id': 'XPDRC01',
254 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
255 {'node-id': 'ROADMC01',
256 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
257 {'node-id': 'ROADMA01',
258 'src-tp': 'DEG1-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
259 {'node-id': 'XPDRA01',
260 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
261 'center-freq': 196.1,
265 'lower-spectral-slot-number': 761,
266 'higher-spectral-slot-number': 768
268 self.assertEqual(response['status_code'], requests.codes.ok)
269 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
272 def test_19_service_power_setup_XPDRA_XPDRC(self):
273 response = test_utils_rfc8040.transportpce_api_rpc_request(
274 'transportpce-olm', 'service-power-setup',
276 'service-name': 'test',
280 'dest-tp': 'XPDR1-NETWORK1',
281 'src-tp': 'XPDR1-CLIENT1',
285 'dest-tp': 'DEG1-TTP-TXRX',
286 'src-tp': 'SRG1-PP1-TXRX',
287 'node-id': 'ROADMA01'
290 'dest-tp': 'SRG1-PP1-TXRX',
291 'src-tp': 'DEG2-TTP-TXRX',
292 'node-id': 'ROADMC01'
295 'dest-tp': 'XPDR1-CLIENT1',
296 'src-tp': 'XPDR1-NETWORK1',
300 'center-freq': 196.1,
304 'lower-spectral-slot-number': 761,
305 'higher-spectral-slot-number': 768
307 self.assertEqual(response['status_code'], requests.codes.ok)
308 self.assertIn('Success', response['output']['result'])
310 def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
311 response = test_utils_rfc8040.check_node_attribute2_request(
312 'XPDRA01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
313 self.assertEqual(response['status_code'], requests.codes.ok)
314 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
315 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
317 def test_21_get_roadmconnection_ROADMA(self):
318 response = test_utils_rfc8040.check_node_attribute_request(
319 'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
320 self.assertEqual(response['status_code'], requests.codes.ok)
321 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
322 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -3.3)
324 def test_22_get_roadmconnection_ROADMC(self):
325 response = test_utils_rfc8040.check_node_attribute_request(
326 'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
327 self.assertEqual(response['status_code'], requests.codes.ok)
328 self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
330 def test_23_service_power_setup_XPDRC_XPDRA(self):
331 response = test_utils_rfc8040.transportpce_api_rpc_request(
332 'transportpce-olm', 'service-power-setup',
334 'service-name': 'test',
338 'dest-tp': 'XPDR1-NETWORK1',
339 'src-tp': 'XPDR1-CLIENT1',
343 'dest-tp': 'DEG2-TTP-TXRX',
344 'src-tp': 'SRG1-PP1-TXRX',
345 'node-id': 'ROADMC01'
348 'src-tp': 'DEG1-TTP-TXRX',
349 'dest-tp': 'SRG1-PP1-TXRX',
350 'node-id': 'ROADMA01'
353 'src-tp': 'XPDR1-NETWORK1',
354 'dest-tp': 'XPDR1-CLIENT1',
358 'center-freq': 196.1,
362 'lower-spectral-slot-number': 761,
363 'higher-spectral-slot-number': 768
365 self.assertEqual(response['status_code'], requests.codes.ok)
366 self.assertIn('Success', response['output']['result'])
368 def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
369 response = test_utils_rfc8040.check_node_attribute2_request(
370 'XPDRC01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
371 self.assertEqual(response['status_code'], requests.codes.ok)
372 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
373 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
375 def test_25_get_roadmconnection_ROADMC(self):
376 response = test_utils_rfc8040.check_node_attribute_request(
377 'ROADMC01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
378 self.assertEqual(response['status_code'], requests.codes.ok)
379 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
380 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -0.63)
382 def test_26_service_power_turndown_XPDRA_XPDRC(self):
383 response = test_utils_rfc8040.transportpce_api_rpc_request(
384 'transportpce-olm', 'service-power-turndown',
386 'service-name': 'test',
390 'dest-tp': 'XPDR1-NETWORK1',
391 'src-tp': 'XPDR1-CLIENT1',
395 'dest-tp': 'DEG1-TTP-TXRX',
396 'src-tp': 'SRG1-PP1-TXRX',
397 'node-id': 'ROADMA01'
400 'dest-tp': 'SRG1-PP1-TXRX',
401 'src-tp': 'DEG2-TTP-TXRX',
402 'node-id': 'ROADMC01'
405 'dest-tp': 'XPDR1-CLIENT1',
406 'src-tp': 'XPDR1-NETWORK1',
410 'center-freq': 196.1,
414 'lower-spectral-slot-number': 761,
415 'higher-spectral-slot-number': 768
417 self.assertEqual(response['status_code'], requests.codes.ok)
418 self.assertIn('Success', response['output']['result'])
420 def test_27_get_roadmconnection_ROADMA(self):
421 response = test_utils_rfc8040.check_node_attribute_request(
422 'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
423 self.assertEqual(response['status_code'], requests.codes.ok)
424 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
425 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
427 def test_28_get_roadmconnection_ROADMC(self):
428 response = test_utils_rfc8040.check_node_attribute_request(
429 'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
430 self.assertEqual(response['status_code'], requests.codes.ok)
431 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
433 def test_29_servicePath_delete_AToZ(self):
434 response = test_utils_rfc8040.transportpce_api_rpc_request(
435 'transportpce-device-renderer', 'service-path',
437 'service-name': 'test',
439 'modulation-format': 'dp-qpsk',
440 'operation': 'delete',
442 [{'node-id': 'XPDRA01',
443 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
444 {'node-id': 'ROADMA01',
445 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
446 {'node-id': 'ROADMC01',
447 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG2-TTP-TXRX'},
448 {'node-id': 'XPDRC01',
449 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
450 'center-freq': 196.1,
454 'lower-spectral-slot-number': 761,
455 'higher-spectral-slot-number': 768
457 self.assertEqual(response['status_code'], requests.codes.ok)
458 self.assertIn('Request processed', response['output']['result'])
461 def test_30_servicePath_delete_ZToA(self):
462 response = test_utils_rfc8040.transportpce_api_rpc_request(
463 'transportpce-device-renderer', 'service-path',
465 'service-name': 'test',
467 'modulation-format': 'dp-qpsk',
468 'operation': 'delete',
470 [{'node-id': 'XPDRC01',
471 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
472 {'node-id': 'ROADMC01',
473 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
474 {'node-id': 'ROADMA01',
475 'src-tp': 'DEG1-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
476 {'node-id': 'XPDRA01',
477 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
478 'center-freq': 196.1,
482 'lower-spectral-slot-number': 761,
483 'higher-spectral-slot-number': 768
485 self.assertEqual(response['status_code'], requests.codes.ok)
486 self.assertIn('Request processed', response['output']['result'])
489 #"""to test case where SRG where the xpdr is connected to has no optical range data"""
491 def test_31_connect_xprdA_to_roadmA(self):
492 response = test_utils_rfc8040.transportpce_api_rpc_request(
493 'transportpce-networkutils', 'init-xpdr-rdm-links',
494 {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2',
495 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
496 self.assertEqual(response['status_code'], requests.codes.ok)
498 def test_32_connect_roadmA_to_xpdrA(self):
499 response = test_utils_rfc8040.transportpce_api_rpc_request(
500 'transportpce-networkutils', 'init-rdm-xpdr-links',
501 {'links-input': {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2',
502 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
503 self.assertEqual(response['status_code'], requests.codes.ok)
505 def test_33_servicePath_create_AToZ(self):
506 response = test_utils_rfc8040.transportpce_api_rpc_request(
507 'transportpce-device-renderer', 'service-path',
509 'service-name': 'test2',
511 'modulation-format': 'dp-qpsk',
512 'operation': 'create',
514 [{'node-id': 'XPDRA01',
515 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
516 {'node-id': 'ROADMA01',
517 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
518 'center-freq': 196.05,
522 'lower-spectral-slot-number': 753,
523 'higher-spectral-slot-number': 760
525 self.assertEqual(response['status_code'], requests.codes.ok)
526 self.assertIn('Interfaces created successfully for nodes', response['output']['result'])
529 def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
530 response = test_utils_rfc8040.check_node_attribute2_request(
531 'XPDRA01', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
532 self.assertEqual(response['status_code'], requests.codes.ok)
533 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
534 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 2)
536 def test_35_servicePath_delete_AToZ(self):
537 response = test_utils_rfc8040.transportpce_api_rpc_request(
538 'transportpce-device-renderer', 'service-path',
540 'service-name': 'test2',
542 'modulation-format': 'dp-qpsk',
543 'operation': 'delete',
545 [{'node-id': 'XPDRA01',
546 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
547 {'node-id': 'ROADMA01',
548 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
549 'center-freq': 196.05,
553 'lower-spectral-slot-number': 753,
554 'higher-spectral-slot-number': 760
556 self.assertEqual(response['status_code'], requests.codes.ok)
557 self.assertIn('Request processed', response['output']['result'])
560 def test_36_xpdrA_device_disconnected(self):
561 response = test_utils_rfc8040.unmount_device("XPDRA01")
562 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
564 def test_37_xpdrC_device_disconnected(self):
565 response = test_utils_rfc8040.unmount_device("XPDRC01")
566 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
568 def test_38_calculate_span_loss_current(self):
569 response = test_utils_rfc8040.transportpce_api_rpc_request(
570 'transportpce-olm', 'calculate-spanloss-current',
572 self.assertEqual(response['status_code'], requests.codes.ok)
573 self.assertIn('Success',
574 response["output"]["result"])
577 def test_39_rdmA_device_disconnected(self):
578 response = test_utils_rfc8040.unmount_device("ROADMA01")
579 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
581 def test_40_rdmC_device_disconnected(self):
582 response = test_utils_rfc8040.unmount_device("ROADMC01")
583 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
586 if __name__ == "__main__":
587 unittest.main(verbosity=2)