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.connect_xpdr_to_rdm_request(
69 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
70 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
71 self.assertEqual(response.status_code, requests.codes.ok)
73 def test_06_connect_roadmA_to_xpdrA(self):
74 response = test_utils_rfc8040.connect_rdm_to_xpdr_request(
75 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '1',
76 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
77 self.assertEqual(response.status_code, requests.codes.ok)
79 def test_07_connect_xprdC_to_roadmC(self):
80 response = test_utils_rfc8040.connect_xpdr_to_rdm_request(
81 {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1',
82 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
83 self.assertEqual(response.status_code, requests.codes.ok)
85 def test_08_connect_roadmC_to_xpdrC(self):
86 response = test_utils_rfc8040.connect_rdm_to_xpdr_request(
87 {'xpdr-node': 'XPDRC01', 'xpdr-num': '1', 'network-num': '1',
88 'rdm-node': 'ROADMC01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'})
89 self.assertEqual(response.status_code, requests.codes.ok)
91 def test_09_create_OTS_ROADMA(self):
92 response = test_utils_rfc8040.device_renderer_create_ots_oms_request('ROADMA01', 'DEG1-TTP-TXRX')
93 self.assertEqual(response.status_code, requests.codes.ok)
95 def test_10_create_OTS_ROADMC(self):
96 response = test_utils_rfc8040.device_renderer_create_ots_oms_request('ROADMC01', 'DEG2-TTP-TXRX')
97 self.assertEqual(response.status_code, requests.codes.ok)
99 def test_11_get_PM_ROADMA(self):
100 response = test_utils_rfc8040.olm_get_pm_request({
101 'node-id': 'ROADMA01',
102 'resource-type': 'interface',
103 'granularity': '15min',
104 'resource-identifier': {
105 'resource-name': 'OTS-DEG1-TTP-TXRX'
108 self.assertEqual(response['status_code'], requests.codes.ok)
110 'pmparameter-name': 'OpticalPowerOutput',
111 'pmparameter-value': '2.5'
112 }, response['output']['measurements'])
114 'pmparameter-name': 'OpticalReturnLoss',
115 'pmparameter-value': '49.9'
116 }, response['output']['measurements'])
118 'pmparameter-name': 'OpticalPowerInput',
119 'pmparameter-value': '3'
120 }, response['output']['measurements'])
122 def test_12_get_PM_ROADMC(self):
123 response = test_utils_rfc8040.olm_get_pm_request({
124 'node-id': 'ROADMC01',
125 'resource-type': 'interface',
126 'granularity': '15min',
127 'resource-identifier': {
128 'resource-name': 'OTS-DEG2-TTP-TXRX'
131 self.assertEqual(response['status_code'], requests.codes.ok)
133 'pmparameter-name': 'OpticalPowerOutput',
134 'pmparameter-value': '18.1'
135 }, response['output']['measurements'])
137 'pmparameter-name': 'OpticalReturnLoss',
138 'pmparameter-value': '48.8'
139 }, response['output']['measurements'])
141 'pmparameter-name': 'OpticalPowerInput',
142 'pmparameter-value': '-3.2'
143 }, response['output']['measurements'])
145 def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
146 response = test_utils_rfc8040.olm_calculate_spanloss_base_request({
148 'link-id': 'ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX'
150 self.assertEqual(response['status_code'], requests.codes.ok)
151 self.assertIn('Success',
152 response['output']['result'])
155 'link-id': 'ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX'
156 }, response['output']['spans'])
159 def test_14_calculate_span_loss_base_all(self):
160 response = test_utils_rfc8040.olm_calculate_spanloss_base_request({
163 self.assertEqual(response['status_code'], requests.codes.ok)
164 self.assertIn('Success',
165 response['output']['result'])
168 'link-id': 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX'
169 }, response['output']['spans'])
172 'link-id': 'ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX'
173 }, response['output']['spans'])
176 def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
177 response = test_utils_rfc8040.check_node_attribute2_request(
178 'ROADMA01', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
179 self.assertEqual(response['status_code'], requests.codes.ok)
180 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 5.7)
181 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 15.1)
182 # FIXME test_utils_rfc8040.check_node_attribute2_request retrives values in config DS
183 # but values are different (6 and 15) in nonconfig/operational DS and should not
184 # Honeynode simulator bug ?
185 # Reopen similar issues found in RSPN tests at TRNSPRTPCE-591
187 def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
188 response = test_utils_rfc8040.check_node_attribute2_request(
189 'ROADMC01', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
190 self.assertEqual(response['status_code'], requests.codes.ok)
191 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 15.1)
192 self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 5.7)
194 def test_17_servicePath_create_AToZ(self):
195 response = test_utils_rfc8040.device_renderer_service_path_request({
196 'service-name': 'test',
198 'modulation-format': 'dp-qpsk',
199 'operation': 'create',
201 [{'node-id': 'XPDRA01',
202 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
203 {'node-id': 'ROADMA01',
204 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
205 {'node-id': 'ROADMC01',
206 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG2-TTP-TXRX'},
207 {'node-id': 'XPDRC01',
208 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
209 'center-freq': 196.1,
213 'lower-spectral-slot-number': 761,
214 'higher-spectral-slot-number': 768
216 self.assertEqual(response['status_code'], requests.codes.ok)
217 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
220 def test_18_servicePath_create_ZToA(self):
221 response = test_utils_rfc8040.device_renderer_service_path_request({
222 'service-name': 'test',
224 'modulation-format': 'dp-qpsk',
225 'operation': 'create',
227 [{'node-id': 'XPDRC01',
228 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
229 {'node-id': 'ROADMC01',
230 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
231 {'node-id': 'ROADMA01',
232 'src-tp': 'DEG1-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
233 {'node-id': 'XPDRA01',
234 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
235 'center-freq': 196.1,
239 'lower-spectral-slot-number': 761,
240 'higher-spectral-slot-number': 768
242 self.assertEqual(response['status_code'], requests.codes.ok)
243 self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
246 def test_19_service_power_setup_XPDRA_XPDRC(self):
247 response = test_utils_rfc8040.olm_service_power_setup_request({
248 'service-name': 'test',
252 'dest-tp': 'XPDR1-NETWORK1',
253 'src-tp': 'XPDR1-CLIENT1',
257 'dest-tp': 'DEG1-TTP-TXRX',
258 'src-tp': 'SRG1-PP1-TXRX',
259 'node-id': 'ROADMA01'
262 'dest-tp': 'SRG1-PP1-TXRX',
263 'src-tp': 'DEG2-TTP-TXRX',
264 'node-id': 'ROADMC01'
267 'dest-tp': 'XPDR1-CLIENT1',
268 'src-tp': 'XPDR1-NETWORK1',
272 'center-freq': 196.1,
276 'lower-spectral-slot-number': 761,
277 'higher-spectral-slot-number': 768
279 self.assertEqual(response['status_code'], requests.codes.ok)
280 self.assertIn('Success', response['output']['result'])
282 def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
283 response = test_utils_rfc8040.check_node_attribute2_request(
284 'XPDRA01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
285 self.assertEqual(response['status_code'], requests.codes.ok)
286 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
287 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
289 def test_21_get_roadmconnection_ROADMA(self):
290 response = test_utils_rfc8040.check_node_attribute_request(
291 'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
292 self.assertEqual(response['status_code'], requests.codes.ok)
293 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
294 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -3.3)
296 def test_22_get_roadmconnection_ROADMC(self):
297 response = test_utils_rfc8040.check_node_attribute_request(
298 'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
299 self.assertEqual(response['status_code'], requests.codes.ok)
300 self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
302 def test_23_service_power_setup_XPDRC_XPDRA(self):
303 response = test_utils_rfc8040.olm_service_power_setup_request({
304 'service-name': 'test',
308 'dest-tp': 'XPDR1-NETWORK1',
309 'src-tp': 'XPDR1-CLIENT1',
313 'dest-tp': 'DEG2-TTP-TXRX',
314 'src-tp': 'SRG1-PP1-TXRX',
315 'node-id': 'ROADMC01'
318 'src-tp': 'DEG1-TTP-TXRX',
319 'dest-tp': 'SRG1-PP1-TXRX',
320 'node-id': 'ROADMA01'
323 'src-tp': 'XPDR1-NETWORK1',
324 'dest-tp': 'XPDR1-CLIENT1',
328 'center-freq': 196.1,
332 'lower-spectral-slot-number': 761,
333 'higher-spectral-slot-number': 768
335 self.assertEqual(response['status_code'], requests.codes.ok)
336 self.assertIn('Success', response['output']['result'])
338 def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
339 response = test_utils_rfc8040.check_node_attribute2_request(
340 'XPDRC01', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
341 self.assertEqual(response['status_code'], requests.codes.ok)
342 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), 0)
343 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 1)
345 def test_25_get_roadmconnection_ROADMC(self):
346 response = test_utils_rfc8040.check_node_attribute_request(
347 'ROADMC01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
348 self.assertEqual(response['status_code'], requests.codes.ok)
349 self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
350 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -0.63)
352 def test_26_service_power_turndown_XPDRA_XPDRC(self):
353 response = test_utils_rfc8040.olm_service_power_turndown_request({
354 'service-name': 'test',
358 'dest-tp': 'XPDR1-NETWORK1',
359 'src-tp': 'XPDR1-CLIENT1',
363 'dest-tp': 'DEG1-TTP-TXRX',
364 'src-tp': 'SRG1-PP1-TXRX',
365 'node-id': 'ROADMA01'
368 'dest-tp': 'SRG1-PP1-TXRX',
369 'src-tp': 'DEG2-TTP-TXRX',
370 'node-id': 'ROADMC01'
373 'dest-tp': 'XPDR1-CLIENT1',
374 'src-tp': 'XPDR1-NETWORK1',
378 'center-freq': 196.1,
382 'lower-spectral-slot-number': 761,
383 'higher-spectral-slot-number': 768
385 self.assertEqual(response['status_code'], requests.codes.ok)
386 self.assertIn('Success', response['output']['result'])
388 def test_27_get_roadmconnection_ROADMA(self):
389 response = test_utils_rfc8040.check_node_attribute_request(
390 'ROADMA01', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
391 self.assertEqual(response['status_code'], requests.codes.ok)
392 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
393 self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
395 def test_28_get_roadmconnection_ROADMC(self):
396 response = test_utils_rfc8040.check_node_attribute_request(
397 'ROADMC01', 'roadm-connections', 'DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768')
398 self.assertEqual(response['status_code'], requests.codes.ok)
399 self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
401 def test_29_servicePath_delete_AToZ(self):
402 response = test_utils_rfc8040.device_renderer_service_path_request({
403 'service-name': 'test',
405 'modulation-format': 'dp-qpsk',
406 'operation': 'delete',
408 [{'node-id': 'XPDRA01',
409 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
410 {'node-id': 'ROADMA01',
411 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
412 {'node-id': 'ROADMC01',
413 'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG2-TTP-TXRX'},
414 {'node-id': 'XPDRC01',
415 'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
416 'center-freq': 196.1,
420 'lower-spectral-slot-number': 761,
421 'higher-spectral-slot-number': 768
423 self.assertEqual(response['status_code'], requests.codes.ok)
424 self.assertIn('Request processed', response['output']['result'])
427 def test_30_servicePath_delete_ZToA(self):
428 response = test_utils_rfc8040.device_renderer_service_path_request({
429 'service-name': 'test',
431 'modulation-format': 'dp-qpsk',
432 'operation': 'delete',
434 [{'node-id': 'XPDRC01',
435 'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
436 {'node-id': 'ROADMC01',
437 'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
438 {'node-id': 'ROADMA01',
439 'src-tp': 'DEG1-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
440 {'node-id': 'XPDRA01',
441 'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
442 'center-freq': 196.1,
446 'lower-spectral-slot-number': 761,
447 'higher-spectral-slot-number': 768
449 self.assertEqual(response['status_code'], requests.codes.ok)
450 self.assertIn('Request processed', response['output']['result'])
453 #"""to test case where SRG where the xpdr is connected to has no optical range data"""
455 def test_31_connect_xprdA_to_roadmA(self):
456 response = test_utils_rfc8040.connect_xpdr_to_rdm_request(
457 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2',
458 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'})
459 self.assertEqual(response.status_code, requests.codes.ok)
461 def test_32_connect_roadmA_to_xpdrA(self):
462 response = test_utils_rfc8040.connect_rdm_to_xpdr_request(
463 {'xpdr-node': 'XPDRA01', 'xpdr-num': '1', 'network-num': '2',
464 'rdm-node': 'ROADMA01', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'})
465 self.assertEqual(response.status_code, requests.codes.ok)
467 def test_33_servicePath_create_AToZ(self):
468 response = test_utils_rfc8040.device_renderer_service_path_request({
469 'service-name': 'test2',
471 'modulation-format': 'dp-qpsk',
472 'operation': 'create',
474 [{'node-id': 'XPDRA01',
475 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
476 {'node-id': 'ROADMA01',
477 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
478 'center-freq': 196.05,
482 'lower-spectral-slot-number': 753,
483 'higher-spectral-slot-number': 760
485 self.assertEqual(response['status_code'], requests.codes.ok)
486 self.assertIn('Interfaces created successfully for nodes', response['output']['result'])
489 def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
490 response = test_utils_rfc8040.check_node_attribute2_request(
491 'XPDRA01', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
492 self.assertEqual(response['status_code'], requests.codes.ok)
493 self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
494 self.assertEqual(int(response['org-openroadm-optical-channel-interfaces:och']['wavelength-number']), 2)
496 def test_35_servicePath_delete_AToZ(self):
497 response = test_utils_rfc8040.device_renderer_service_path_request({
498 'service-name': 'test2',
500 'modulation-format': 'dp-qpsk',
501 'operation': 'delete',
503 [{'node-id': 'XPDRA01',
504 'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
505 {'node-id': 'ROADMA01',
506 'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
507 'center-freq': 196.05,
511 'lower-spectral-slot-number': 753,
512 'higher-spectral-slot-number': 760
514 self.assertEqual(response['status_code'], requests.codes.ok)
515 self.assertIn('Request processed', response['output']['result'])
518 def test_36_xpdrA_device_disconnected(self):
519 response = test_utils_rfc8040.unmount_device("XPDRA01")
520 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
522 def test_37_xpdrC_device_disconnected(self):
523 response = test_utils_rfc8040.unmount_device("XPDRC01")
524 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
526 def test_38_calculate_span_loss_current(self):
527 response = test_utils_rfc8040.olm_calculate_spanloss_current_request()
528 self.assertEqual(response['status_code'], requests.codes.ok)
529 self.assertIn('Success',
530 response["output"]["result"])
533 def test_39_rdmA_device_disconnected(self):
534 response = test_utils_rfc8040.unmount_device("ROADMA01")
535 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
537 def test_40_rdmC_device_disconnected(self):
538 response = test_utils_rfc8040.unmount_device("ROADMC01")
539 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
542 if __name__ == "__main__":
543 unittest.main(verbosity=2)