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 = '2.2.1'
33 cls.processes = test_utils_rfc8040.start_tpce()
34 cls.processes = test_utils_rfc8040.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_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("XPDR-A1", ('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("XPDR-C1", ('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("ROADM-A1", ('roadma', 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("ROADM-C1", ('roadmc', 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': '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_rfc8040.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_rfc8040.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_rfc8040.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_rfc8040.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_rfc8040.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_rfc8040.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 'pmparameter-name': 'OpticalPowerOutput',
128 'pmparameter-value': '2.50'
129 }, response['output']['measurements'])
131 'pmparameter-name': 'OpticalReturnLoss',
132 'pmparameter-value': '40'
133 }, response['output']['measurements'])
135 'pmparameter-name': 'OpticalPowerInput',
136 'pmparameter-value': '-21.10'
137 }, response['output']['measurements'])
139 def test_12_get_PM_ROADMC(self):
140 response = test_utils_rfc8040.transportpce_api_rpc_request(
141 'transportpce-olm', 'get-pm',
143 'node-id': 'ROADM-C1',
144 'resource-type': 'interface',
145 'granularity': '15min',
146 'resource-identifier': {
147 'resource-name': 'OTS-DEG1-TTP-TXRX'
150 self.assertEqual(response['status_code'], requests.codes.ok)
152 'pmparameter-name': 'OpticalPowerOutput',
153 'pmparameter-value': '4.60'
154 }, response['output']['measurements'])
156 'pmparameter-name': 'OpticalReturnLoss',
157 'pmparameter-value': '49.10'
158 }, response['output']['measurements'])
160 'pmparameter-name': 'OpticalPowerInput',
161 'pmparameter-value': '-15.10'
162 }, response['output']['measurements'])
164 def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
165 response = test_utils_rfc8040.transportpce_api_rpc_request(
166 'transportpce-olm', 'calculate-spanloss-base',
169 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
171 self.assertEqual(response['status_code'], requests.codes.ok)
172 self.assertIn('Success',
173 response['output']['result'])
176 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
177 }, response['output']['spans'])
180 def test_14_calculate_span_loss_base_all(self):
181 response = test_utils_rfc8040.transportpce_api_rpc_request(
182 'transportpce-olm', 'calculate-spanloss-base',
186 self.assertEqual(response['status_code'], requests.codes.ok)
187 self.assertIn('Success',
188 response['output']['result'])
191 'link-id': 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'
192 }, response['output']['spans'])
195 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
196 }, response['output']['spans'])
199 def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
200 response = test_utils_rfc8040.check_node_attribute2_request(
201 'ROADM-A1', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
202 self.assertEqual(response['status_code'], requests.codes.ok)
203 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 17.6)
204 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 25.7)
206 def test_16_get_OTS_DEG1_TTP_TXRX_ROADMC(self):
207 response = test_utils_rfc8040.check_node_attribute2_request(
208 'ROADM-C1', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
209 self.assertEqual(response['status_code'], requests.codes.ok)
210 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 25.7)
211 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 17.6)
213 def test_17_servicePath_create_AToZ(self):
214 response = test_utils_rfc8040.transportpce_api_rpc_request(
215 'transportpce-device-renderer', 'service-path',
217 'service-name': 'test',
219 'modulation-format': 'dp-qpsk',
220 'operation': 'create',
222 [{'node-id': 'XPDR-A1',
223 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
224 {'node-id': 'ROADM-A1',
225 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
226 {'node-id': 'ROADM-C1',
227 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG1-TTP-TXRX'},
228 {'node-id': 'XPDR-C1',
229 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
230 'center-freq': 196.1,
234 'lower-spectral-slot-number': 761,
235 'higher-spectral-slot-number': 768
237 self.assertEqual(response['status_code'], requests.codes.ok)
238 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
241 def test_18_servicePath_create_ZToA(self):
242 response = test_utils_rfc8040.transportpce_api_rpc_request(
243 'transportpce-device-renderer', 'service-path',
245 'service-name': 'test',
247 'modulation-format': 'dp-qpsk',
248 'operation': 'create',
250 [{'node-id': 'XPDR-C1',
251 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
252 {'node-id': 'ROADM-C1',
253 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
254 {'node-id': 'ROADM-A1',
255 'src-tp': 'DEG2-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
256 {'node-id': 'XPDR-A1',
257 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
258 'center-freq': 196.1,
262 'lower-spectral-slot-number': 761,
263 'higher-spectral-slot-number': 768
265 self.assertEqual(response['status_code'], requests.codes.ok)
266 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
269 def test_19_service_power_setup_XPDRA_XPDRC(self):
270 response = test_utils_rfc8040.transportpce_api_rpc_request(
271 'transportpce-olm', 'service-power-setup',
273 'service-name': 'test',
277 'dest-tp': 'XPDR1-NETWORK1',
278 'src-tp': 'XPDR1-CLIENT1',
282 'dest-tp': 'DEG2-TTP-TXRX',
283 'src-tp': 'SRG1-PP1-TXRX',
284 'node-id': 'ROADM-A1'
287 'dest-tp': 'SRG1-PP1-TXRX',
288 'src-tp': 'DEG1-TTP-TXRX',
289 'node-id': 'ROADM-C1'
292 'dest-tp': 'XPDR1-CLIENT1',
293 'src-tp': 'XPDR1-NETWORK1',
297 'lower-spectral-slot-number': 761,
298 'higher-spectral-slot-number': 768
300 self.assertEqual(response['status_code'], requests.codes.ok)
301 self.assertIn('Success', response['output']['result'])
303 def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
304 response = test_utils_rfc8040.check_node_attribute2_request(
305 'XPDR-A1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
306 self.assertEqual(response['status_code'], requests.codes.ok)
307 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
308 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
310 def test_21_get_roadmconnection_ROADMA(self):
311 response = test_utils_rfc8040.check_node_attribute_request(
312 'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
313 self.assertEqual(response['status_code'], requests.codes.ok)
314 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
315 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 0.21)
317 def test_22_get_roadmconnection_ROADMC(self):
318 response = test_utils_rfc8040.check_node_attribute_request(
319 'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
320 self.assertEqual(response['status_code'], requests.codes.ok)
321 self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
323 def test_23_service_power_setup_XPDRC_XPDRA(self):
324 response = test_utils_rfc8040.transportpce_api_rpc_request(
325 'transportpce-olm', 'service-power-setup',
327 'service-name': 'test',
331 'dest-tp': 'XPDR1-NETWORK1',
332 'src-tp': 'XPDR1-CLIENT1',
336 'dest-tp': 'DEG1-TTP-TXRX',
337 'src-tp': 'SRG1-PP1-TXRX',
338 'node-id': 'ROADM-C1'
341 'src-tp': 'DEG2-TTP-TXRX',
342 'dest-tp': 'SRG1-PP1-TXRX',
343 'node-id': 'ROADM-A1'
346 'src-tp': 'XPDR1-NETWORK1',
347 'dest-tp': 'XPDR1-CLIENT1',
351 'lower-spectral-slot-number': 761,
352 'higher-spectral-slot-number': 768
354 self.assertEqual(response['status_code'], requests.codes.ok)
355 self.assertIn('Success', response['output']['result'])
357 def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
358 response = test_utils_rfc8040.check_node_attribute2_request(
359 'XPDR-C1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
360 self.assertEqual(response['status_code'], requests.codes.ok)
361 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
362 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
364 def test_25_get_roadmconnection_ROADMC(self):
365 response = test_utils_rfc8040.check_node_attribute_request(
366 'ROADM-C1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
367 self.assertEqual(response['status_code'], requests.codes.ok)
368 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
369 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 2.0)
371 def test_26_service_power_turndown_XPDRA_XPDRC(self):
372 response = test_utils_rfc8040.transportpce_api_rpc_request(
373 'transportpce-olm', 'service-power-turndown',
375 'service-name': 'test',
379 'dest-tp': 'XPDR1-NETWORK1',
380 'src-tp': 'XPDR1-CLIENT1',
384 'dest-tp': 'DEG2-TTP-TXRX',
385 'src-tp': 'SRG1-PP1-TXRX',
386 'node-id': 'ROADM-A1'
389 'dest-tp': 'SRG1-PP1-TXRX',
390 'src-tp': 'DEG1-TTP-TXRX',
391 'node-id': 'ROADM-C1'
394 'dest-tp': 'XPDR1-CLIENT1',
395 'src-tp': 'XPDR1-NETWORK1',
399 'lower-spectral-slot-number': 761,
400 'higher-spectral-slot-number': 768
402 self.assertEqual(response['status_code'], requests.codes.ok)
403 self.assertIn('Success', response['output']['result'])
405 def test_27_get_roadmconnection_ROADMA(self):
406 response = test_utils_rfc8040.check_node_attribute_request(
407 'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
408 self.assertEqual(response['status_code'], requests.codes.ok)
409 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
410 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
412 def test_28_get_roadmconnection_ROADMC(self):
413 response = test_utils_rfc8040.check_node_attribute_request(
414 'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
415 self.assertEqual(response['status_code'], requests.codes.ok)
416 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
418 def test_29_servicePath_delete_AToZ(self):
419 response = test_utils_rfc8040.transportpce_api_rpc_request(
420 'transportpce-device-renderer', 'service-path',
422 'service-name': 'test',
424 'modulation-format': 'dp-qpsk',
425 'operation': 'delete',
427 [{'node-id': 'XPDR-A1',
428 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
429 {'node-id': 'ROADM-A1',
430 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
431 {'node-id': 'ROADM-C1',
432 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG1-TTP-TXRX'},
433 {'node-id': 'XPDR-C1',
434 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
435 'center-freq': 196.1,
439 'lower-spectral-slot-number': 761,
440 'higher-spectral-slot-number': 768
442 self.assertEqual(response['status_code'], requests.codes.ok)
443 self.assertIn('Request processed', response['output']['result'])
446 def test_30_servicePath_delete_ZToA(self):
447 response = test_utils_rfc8040.transportpce_api_rpc_request(
448 'transportpce-device-renderer', 'service-path',
450 'service-name': 'test',
452 'modulation-format': 'dp-qpsk',
453 'operation': 'delete',
455 [{'node-id': 'XPDR-C1',
456 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
457 {'node-id': 'ROADM-C1',
458 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
459 {'node-id': 'ROADM-A1',
460 'src-tp': 'DEG2-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
461 {'node-id': 'XPDR-A1',
462 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
463 'center-freq': 196.1,
467 'lower-spectral-slot-number': 761,
468 'higher-spectral-slot-number': 768
470 self.assertEqual(response['status_code'], requests.codes.ok)
471 self.assertIn('Request processed', response['output']['result'])
474 #"""to test case where SRG where the xpdr is connected to has no optical range data"""
476 def test_31_connect_xprdA_to_roadmA(self):
477 response = test_utils_rfc8040.transportpce_api_rpc_request(
478 'transportpce-networkutils', 'init-xpdr-rdm-links',
479 {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2',
480 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
481 self.assertEqual(response['status_code'], requests.codes.ok)
483 def test_32_connect_roadmA_to_xpdrA(self):
484 response = test_utils_rfc8040.transportpce_api_rpc_request(
485 'transportpce-networkutils', 'init-rdm-xpdr-links',
486 {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2',
487 'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
488 self.assertEqual(response['status_code'], requests.codes.ok)
490 def test_33_servicePath_create_AToZ(self):
491 response = test_utils_rfc8040.transportpce_api_rpc_request(
492 'transportpce-device-renderer', 'service-path',
494 'service-name': 'test2',
496 'modulation-format': 'dp-qpsk',
497 'operation': 'create',
499 [{'node-id': 'XPDR-A1',
500 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
501 {'node-id': 'ROADM-A1',
502 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
503 'center-freq': 196.1,
507 'lower-spectral-slot-number': 753,
508 'higher-spectral-slot-number': 760
510 self.assertEqual(response['status_code'], requests.codes.ok)
511 self.assertIn('Interfaces created successfully for nodes', response['output']['result'])
514 def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
515 response = test_utils_rfc8040.check_node_attribute2_request(
516 'XPDR-A1', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
517 self.assertEqual(response['status_code'], requests.codes.ok)
518 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
519 # self.assertEqual(2, response['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
521 def test_35_servicePath_delete_AToZ(self):
522 response = test_utils_rfc8040.transportpce_api_rpc_request(
523 'transportpce-device-renderer', 'service-path',
525 'service-name': 'test2',
527 'modulation-format': 'dp-qpsk',
528 'operation': 'delete',
530 [{'node-id': 'XPDR-A1',
531 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
532 {'node-id': 'ROADM-A1',
533 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
534 'center-freq': 196.1,
538 'lower-spectral-slot-number': 753,
539 'higher-spectral-slot-number': 760
541 self.assertEqual(response['status_code'], requests.codes.ok)
542 self.assertIn('Request processed', response['output']['result'])
545 def test_36_xpdrA_device_disconnected(self):
546 response = test_utils_rfc8040.unmount_device("XPDR-A1")
547 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
549 def test_37_xpdrC_device_disconnected(self):
550 response = test_utils_rfc8040.unmount_device("XPDR-C1")
551 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
553 def test_38_calculate_span_loss_current(self):
554 response = test_utils_rfc8040.transportpce_api_rpc_request(
555 'transportpce-olm', 'calculate-spanloss-current',
557 self.assertEqual(response['status_code'], requests.codes.ok)
558 self.assertIn('Success',
559 response["output"]["result"])
562 def test_39_rdmA_device_disconnected(self):
563 response = test_utils_rfc8040.unmount_device("ROADM-A1")
564 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
566 def test_40_rdmC_device_disconnected(self):
567 response = test_utils_rfc8040.unmount_device("ROADM-C1")
568 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
571 if __name__ == "__main__":
572 unittest.main(verbosity=2)