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
19 sys.path.append('transportpce_tests/common/')
20 import test_utils # nopep8
23 class TransportOlmTesting(unittest.TestCase):
26 NODE_VERSION = '1.2.1'
30 cls.processes = test_utils.start_tpce()
31 cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION),
32 ('roadma-full', cls.NODE_VERSION),
33 ('roadmc-full', cls.NODE_VERSION),
34 ('xpdrc', cls.NODE_VERSION)])
37 def tearDownClass(cls):
38 # pylint: disable=not-an-iterable
39 for process in cls.processes:
40 test_utils.shutdown_process(process)
41 print("all processes killed")
44 print("execution of {}".format(self.id().split(".")[-1]))
47 def test_01_xpdrA_device_connected(self):
48 response = test_utils.mount_device("XPDRA01", ('xpdra', self.NODE_VERSION))
49 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
51 def test_02_xpdrC_device_connected(self):
52 response = test_utils.mount_device("XPDRC01", ('xpdrc', self.NODE_VERSION))
53 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
55 def test_03_rdmA_device_connected(self):
56 response = test_utils.mount_device("ROADMA01", ('roadma-full', self.NODE_VERSION))
57 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
59 def test_04_rdmC_device_connected(self):
60 response = test_utils.mount_device("ROADMC01", ('roadmc-full', self.NODE_VERSION))
61 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
63 def test_05_connect_xprdA_to_roadmA(self):
64 response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
65 "ROADMA01", "1", "SRG1-PP1-TXRX")
66 self.assertEqual(response.status_code, requests.codes.ok)
68 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
70 def test_06_connect_roadmA_to_xpdrA(self):
71 response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
72 "ROADMA01", "1", "SRG1-PP1-TXRX")
73 self.assertEqual(response.status_code, requests.codes.ok)
75 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
77 def test_07_connect_xprdC_to_roadmC(self):
78 response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "1",
79 "ROADMC01", "1", "SRG1-PP1-TXRX")
80 self.assertEqual(response.status_code, requests.codes.ok)
82 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
84 def test_08_connect_roadmC_to_xpdrC(self):
85 response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "1",
86 "ROADMC01", "1", "SRG1-PP1-TXRX")
87 self.assertEqual(response.status_code, requests.codes.ok)
89 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
91 def test_09_create_OTS_ROADMA(self):
92 response = test_utils.create_ots_oms_request("ROADMA01", "DEG1-TTP-TXRX")
93 self.assertEqual(response.status_code, requests.codes.ok)
95 self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADMA01',
96 res["output"]["result"])
98 def test_10_create_OTS_ROADMC(self):
99 response = test_utils.create_ots_oms_request("ROADMC01", "DEG2-TTP-TXRX")
100 self.assertEqual(response.status_code, requests.codes.ok)
101 res = response.json()
102 self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADMC01',
103 res["output"]["result"])
105 def test_11_get_PM_ROADMA(self):
106 url = "{}/operations/transportpce-olm:get-pm"
109 "node-id": "ROADMA01",
110 "resource-type": "interface",
111 "granularity": "15min",
112 "resource-identifier": {
113 "resource-name": "OTS-DEG1-TTP-TXRX"
117 response = test_utils.post_request(url, data)
118 self.assertEqual(response.status_code, requests.codes.ok)
119 res = response.json()
121 "pmparameter-name": "OpticalPowerOutput",
122 "pmparameter-value": "2.5"
123 }, res["output"]["measurements"])
125 "pmparameter-name": "OpticalReturnLoss",
126 "pmparameter-value": "49.9"
127 }, res["output"]["measurements"])
129 "pmparameter-name": "OpticalPowerInput",
130 "pmparameter-value": "3"
131 }, res["output"]["measurements"])
133 def test_12_get_PM_ROADMC(self):
134 url = "{}/operations/transportpce-olm:get-pm"
137 "node-id": "ROADMC01",
138 "resource-type": "interface",
139 "granularity": "15min",
140 "resource-identifier": {
141 "resource-name": "OTS-DEG2-TTP-TXRX"
145 response = test_utils.post_request(url, data)
146 self.assertEqual(response.status_code, requests.codes.ok)
147 res = response.json()
149 "pmparameter-name": "OpticalPowerOutput",
150 "pmparameter-value": "18.1"
151 }, res["output"]["measurements"])
153 "pmparameter-name": "OpticalReturnLoss",
154 "pmparameter-value": "48.8"
155 }, res["output"]["measurements"])
157 "pmparameter-name": "OpticalPowerInput",
158 "pmparameter-value": "-3.2"
159 }, res["output"]["measurements"])
161 def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
162 url = "{}/operations/transportpce-olm:calculate-spanloss-base"
166 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
169 response = test_utils.post_request(url, data)
170 self.assertEqual(response.status_code, requests.codes.ok)
171 res = response.json()
172 self.assertIn('Success',
173 res["output"]["result"])
176 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
177 }, res["output"]["spans"])
180 def test_14_calculate_span_loss_base_all(self):
181 url = "{}/operations/transportpce-olm:calculate-spanloss-base"
187 response = test_utils.post_request(url, data)
188 self.assertEqual(response.status_code, requests.codes.ok)
189 res = response.json()
190 self.assertIn('Success',
191 res["output"]["result"])
194 "link-id": "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX"
195 }, res["output"]["spans"])
198 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
199 }, res["output"]["spans"])
202 def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
203 response = test_utils.check_netconf_node_request(
205 "interface/OTS-DEG1-TTP-TXRX/org-openroadm-optical-transport-interfaces:ots")
206 self.assertEqual(response.status_code, requests.codes.ok)
207 res = response.json()
208 self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
209 self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
211 def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
212 response = test_utils.check_netconf_node_request(
214 "interface/OTS-DEG2-TTP-TXRX/org-openroadm-optical-transport-interfaces:ots")
215 self.assertEqual(response.status_code, requests.codes.ok)
216 res = response.json()
217 self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
218 self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
220 def test_17_servicePath_create_AToZ(self):
221 response = test_utils.service_path_request("create", "test", "1",
222 [{"node-id": "XPDRA01",
223 "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
224 {"node-id": "ROADMA01",
225 "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
226 {"node-id": "ROADMC01",
227 "dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG2-TTP-TXRX"},
228 {"node-id": "XPDRC01",
229 "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
230 196.1, 40, 196.075, 196.125, 761,
232 self.assertEqual(response.status_code, requests.codes.ok)
233 res = response.json()
234 self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
238 def test_18_servicePath_create_ZToA(self):
239 response = test_utils.service_path_request("create", "test", "1",
240 [{"node-id": "XPDRC01",
241 "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
242 {"node-id": "ROADMC01",
243 "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
244 {"node-id": "ROADMA01",
245 "src-tp": "DEG1-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
246 {"node-id": "XPDRA01",
247 "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
248 196.1, 40, 196.075, 196.125, 761,
250 self.assertEqual(response.status_code, requests.codes.ok)
251 res = response.json()
252 self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
256 def test_19_service_power_setup_XPDRA_XPDRC(self):
257 url = "{}/operations/transportpce-olm:service-power-setup"
260 "service-name": "test",
264 "dest-tp": "XPDR1-NETWORK1",
265 "src-tp": "XPDR1-CLIENT1",
269 "dest-tp": "DEG1-TTP-TXRX",
270 "src-tp": "SRG1-PP1-TXRX",
271 "node-id": "ROADMA01"
274 "dest-tp": "SRG1-PP1-TXRX",
275 "src-tp": "DEG2-TTP-TXRX",
276 "node-id": "ROADMC01"
279 "dest-tp": "XPDR1-CLIENT1",
280 "src-tp": "XPDR1-NETWORK1",
284 "center-freq": 196.1,
288 "lower-spectral-slot-number": 761,
289 "higher-spectral-slot-number": 768
292 response = test_utils.post_request(url, data)
293 self.assertEqual(response.status_code, requests.codes.ok)
294 res = response.json()
295 self.assertIn('Success', res["output"]["result"])
297 def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
298 response = test_utils.check_netconf_node_request(
300 "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
301 self.assertEqual(response.status_code, requests.codes.ok)
302 res = response.json()
303 self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
304 self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
306 def test_21_get_roadmconnection_ROADMA(self):
307 response = test_utils.check_netconf_node_request(
308 "ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
309 self.assertEqual(response.status_code, requests.codes.ok)
310 res = response.json()
311 self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
312 self.assertEqual(-3.3, res['roadm-connections'][0]['target-output-power'])
314 def test_22_get_roadmconnection_ROADMC(self):
315 response = test_utils.check_netconf_node_request(
316 "ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768")
317 self.assertEqual(response.status_code, requests.codes.ok)
318 res = response.json()
319 self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
321 def test_23_service_power_setup_XPDRC_XPDRA(self):
322 url = "{}/operations/transportpce-olm:service-power-setup"
325 "service-name": "test",
329 "dest-tp": "XPDR1-NETWORK1",
330 "src-tp": "XPDR1-CLIENT1",
334 "dest-tp": "DEG2-TTP-TXRX",
335 "src-tp": "SRG1-PP1-TXRX",
336 "node-id": "ROADMC01"
339 "src-tp": "DEG1-TTP-TXRX",
340 "dest-tp": "SRG1-PP1-TXRX",
341 "node-id": "ROADMA01"
344 "src-tp": "XPDR1-NETWORK1",
345 "dest-tp": "XPDR1-CLIENT1",
349 "center-freq": 196.1,
353 "lower-spectral-slot-number": 761,
354 "higher-spectral-slot-number": 768
357 response = test_utils.post_request(url, data)
358 self.assertEqual(response.status_code, requests.codes.ok)
359 res = response.json()
360 self.assertIn('Success', res["output"]["result"])
362 def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
363 response = test_utils.check_netconf_node_request(
365 "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
366 self.assertEqual(response.status_code, requests.codes.ok)
367 res = response.json()
368 self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
369 self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
371 def test_25_get_roadmconnection_ROADMC(self):
372 response = test_utils.check_netconf_node_request(
373 "ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
374 self.assertEqual(response.status_code, requests.codes.ok)
375 res = response.json()
376 self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
377 self.assertEqual(2, res['roadm-connections'][0]['target-output-power'])
379 def test_26_service_power_turndown_XPDRA_XPDRC(self):
380 url = "{}/operations/transportpce-olm:service-power-turndown"
383 "service-name": "test",
387 "dest-tp": "XPDR1-NETWORK1",
388 "src-tp": "XPDR1-CLIENT1",
392 "dest-tp": "DEG1-TTP-TXRX",
393 "src-tp": "SRG1-PP1-TXRX",
394 "node-id": "ROADMA01"
397 "dest-tp": "SRG1-PP1-TXRX",
398 "src-tp": "DEG2-TTP-TXRX",
399 "node-id": "ROADMC01"
402 "dest-tp": "XPDR1-CLIENT1",
403 "src-tp": "XPDR1-NETWORK1",
407 "center-freq": 196.1,
411 "lower-spectral-slot-number": 761,
412 "higher-spectral-slot-number": 768
415 response = test_utils.post_request(url, data)
416 print(response.json())
417 self.assertEqual(response.status_code, requests.codes.ok)
418 res = response.json()
419 self.assertIn('Success', res["output"]["result"])
421 def test_27_get_roadmconnection_ROADMA(self):
422 response = test_utils.check_netconf_node_request(
423 "ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
424 self.assertEqual(response.status_code, requests.codes.ok)
425 res = response.json()
426 self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
427 self.assertEqual(-60, res['roadm-connections'][0]['target-output-power'])
429 def test_28_get_roadmconnection_ROADMC(self):
430 response = test_utils.check_netconf_node_request(
431 "ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768")
432 self.assertEqual(response.status_code, requests.codes.ok)
433 res = response.json()
434 self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
436 def test_29_servicePath_delete_AToZ(self):
437 response = test_utils.service_path_request("delete", "test", "1",
438 [{"node-id": "XPDRA01",
439 "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
440 {"node-id": "ROADMA01",
441 "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
442 {"node-id": "ROADMC01",
443 "dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG2-TTP-TXRX"},
444 {"node-id": "XPDRC01",
445 "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
446 196.1, 40, 196.075, 196.125, 761,
448 self.assertEqual(response.status_code, requests.codes.ok)
449 res = response.json()
450 self.assertIn('Request processed', res["output"]["result"])
453 def test_30_servicePath_delete_ZToA(self):
454 response = test_utils.service_path_request("delete", "test", "1",
455 [{"node-id": "XPDRC01",
456 "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
457 {"node-id": "ROADMC01",
458 "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
459 {"node-id": "ROADMA01",
460 "src-tp": "DEG1-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
461 {"node-id": "XPDRA01",
462 "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
463 196.1, 40, 196.075, 196.125, 761,
465 self.assertEqual(response.status_code, requests.codes.ok)
466 res = response.json()
467 self.assertIn('Request processed', res["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.connect_xpdr_to_rdm_request("XPDRA01", "1", "2",
474 "ROADMA01", "1", "SRG1-PP2-TXRX")
475 self.assertEqual(response.status_code, requests.codes.ok)
476 res = response.json()
477 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
479 def test_32_connect_roadmA_to_xpdrA(self):
480 response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2",
481 "ROADMA01", "1", "SRG1-PP2-TXRX")
482 self.assertEqual(response.status_code, requests.codes.ok)
483 res = response.json()
484 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
486 def test_33_servicePath_create_AToZ(self):
487 response = test_utils.service_path_request("create", "test2", "2",
488 [{"node-id": "XPDRA01",
489 "dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
490 {"node-id": "ROADMA01",
491 "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
492 196.05, 40, 196.025, 196.075, 753,
494 self.assertEqual(response.status_code, requests.codes.ok)
495 res = response.json()
496 self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
500 def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
501 response = test_utils.check_netconf_node_request(
503 "interface/XPDR1-NETWORK2-753:760/org-openroadm-optical-channel-interfaces:och")
504 self.assertEqual(response.status_code, requests.codes.ok)
505 res = response.json()
506 self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
507 self.assertEqual(2, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
509 def test_35_servicePath_delete_AToZ(self):
510 response = test_utils.service_path_request("delete", "test", "1",
511 [{"node-id": "XPDRA01",
512 "dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
513 {"node-id": "ROADMA01",
514 "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
515 196.1, 40, 196.075, 196.125, 761,
517 self.assertEqual(response.status_code, requests.codes.ok)
518 res = response.json()
519 self.assertIn('Request processed', res["output"]["result"])
522 def test_36_xpdrA_device_disconnected(self):
523 response = test_utils.unmount_device("XPDRA01")
524 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
526 def test_37_xpdrC_device_disconnected(self):
527 response = test_utils.unmount_device("XPDRC01")
528 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
530 def test_38_calculate_span_loss_current(self):
531 url = "{}/operations/transportpce-olm:calculate-spanloss-current"
532 response = test_utils.post_request(url, None)
533 self.assertEqual(response.status_code, requests.codes.ok)
534 res = response.json()
535 self.assertIn('Success',
536 res["output"]["result"])
539 def test_39_rdmA_device_disconnected(self):
540 response = test_utils.unmount_device("ROADMA01")
541 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
543 def test_40_rdmC_device_disconnected(self):
544 response = test_utils.unmount_device("ROADMC01")
545 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
548 if __name__ == "__main__":
549 unittest.main(verbosity=2)