2 ##############################################################################
3 # Copyright (c) 2017 Orange, Inc. and others. All rights reserved.
5 # All rights reserved. This program and the accompanying materials
6 # are made available under the terms of the Apache License, Version 2.0
7 # which accompanies this distribution, and is available at
8 # http://www.apache.org/licenses/LICENSE-2.0
9 ##############################################################################
17 from common import test_utils
20 class TransportPCEFulltesting(unittest.TestCase):
22 WAITING = 20 # nominal value is 300
28 cls.processes = test_utils.start_tpce()
29 cls.processes = test_utils.start_sims(['xpdra', 'roadma-full', 'roadmc-full', 'xpdrc'])
32 def tearDownClass(cls):
33 for process in cls.processes:
34 test_utils.shutdown_process(process)
35 print("all processes killed")
37 def setUp(self): # instruction executed before each test method
38 print("execution of {}".format(self.id().split(".")[-1]))
40 # connect netconf devices
41 def test_01_connect_xpdrA(self):
42 response = test_utils.mount_device("XPDRA01", 'xpdra')
43 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
45 def test_02_connect_xpdrC(self):
46 response = test_utils.mount_device("XPDRC01", 'xpdrc')
47 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
49 def test_03_connect_rdmA(self):
50 response = test_utils.mount_device("ROADMA01", 'roadma-full')
51 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
53 def test_04_connect_rdmC(self):
54 response = test_utils.mount_device("ROADMC01", 'roadmc-full')
55 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
57 def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
58 response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
59 "ROADMA01", "1", "SRG1-PP1-TXRX")
60 self.assertEqual(response.status_code, requests.codes.ok)
62 self.assertIn('Xponder Roadm Link created successfully',
63 res["output"]["result"])
66 def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
67 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
69 "networkutils:input": {
70 "networkutils:links-input": {
71 "networkutils:xpdr-node": "XPDRA01",
72 "networkutils:xpdr-num": "1",
73 "networkutils:network-num": "1",
74 "networkutils:rdm-node": "ROADMA01",
75 "networkutils:srg-num": "1",
76 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
80 response = test_utils.post_request(url, data)
81 response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
82 "ROADMA01", "1", "SRG1-PP1-TXRX")
83 self.assertEqual(response.status_code, requests.codes.ok)
85 self.assertIn('Roadm Xponder links created successfully',
86 res["output"]["result"])
89 def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
90 response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "1",
91 "ROADMC01", "1", "SRG1-PP1-TXRX")
92 self.assertEqual(response.status_code, requests.codes.ok)
94 self.assertIn('Xponder Roadm Link created successfully',
95 res["output"]["result"])
98 def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
99 response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "1",
100 "ROADMC01", "1", "SRG1-PP1-TXRX")
101 self.assertEqual(response.status_code, requests.codes.ok)
102 res = response.json()
103 self.assertIn('Roadm Xponder links created successfully',
104 res["output"]["result"])
107 def test_09_add_omsAttributes_ROADMA_ROADMC(self):
108 # Config ROADMA-ROADMC oms-attributes
110 "{}/config/ietf-network:"
111 "networks/network/openroadm-topology/ietf-network-topology:"
112 "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/"
113 "org-openroadm-network-topology:"
114 "OMS-attributes/span"
118 "auto-spanloss": "true",
119 "spanloss-base": 11.4,
120 "spanloss-current": 12,
121 "engineered-spanloss": 12.2,
122 "link-concatenation": [{
125 "SRLG-length": 100000,
127 response = test_utils.put_request(url, data)
128 self.assertEqual(response.status_code, requests.codes.created)
130 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
131 # Config ROADMC-ROADMA oms-attributes
133 "{}/config/ietf-network:"
134 "networks/network/openroadm-topology/ietf-network-topology:"
135 "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/"
136 "org-openroadm-network-topology:"
137 "OMS-attributes/span"
141 "auto-spanloss": "true",
142 "spanloss-base": 11.4,
143 "spanloss-current": 12,
144 "engineered-spanloss": 12.2,
145 "link-concatenation": [{
148 "SRLG-length": 100000,
150 response = test_utils.put_request(url, data)
151 self.assertEqual(response.status_code, requests.codes.created)
153 # test service-create for Eth service from xpdr to xpdr
154 def test_11_create_eth_service1(self):
155 url = "{}/operations/org-openroadm-service:service-create"
158 "sdnc-request-header": {
159 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
160 "rpc-action": "service-create",
161 "request-system-id": "appname",
163 "http://localhost:8585/NotificationServer/notify"
165 "service-name": "service1",
166 "common-id": "ASATT1234567",
167 "connection-type": "service",
169 "service-rate": "100",
170 "node-id": "XPDRA01",
171 "service-format": "Ethernet",
172 "clli": "SNJSCAMCJP8",
176 "ROUTER_SNJSCAMCJP8_000000.00_00",
177 "port-type": "router",
178 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
179 "port-rack": "000000.00",
184 "LGX Panel_SNJSCAMCJP8_000000.00_00",
185 "lgx-port-name": "LGX Back.3",
186 "lgx-port-rack": "000000.00",
187 "lgx-port-shelf": "00"
193 "ROUTER_SNJSCAMCJP8_000000.00_00",
194 "port-type": "router",
195 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
196 "port-rack": "000000.00",
201 "LGX Panel_SNJSCAMCJP8_000000.00_00",
202 "lgx-port-name": "LGX Back.4",
203 "lgx-port-rack": "000000.00",
204 "lgx-port-shelf": "00"
210 "service-rate": "100",
211 "node-id": "XPDRC01",
212 "service-format": "Ethernet",
213 "clli": "SNJSCAMCJT4",
217 "ROUTER_SNJSCAMCJT4_000000.00_00",
218 "port-type": "router",
219 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
220 "port-rack": "000000.00",
225 "LGX Panel_SNJSCAMCJT4_000000.00_00",
226 "lgx-port-name": "LGX Back.29",
227 "lgx-port-rack": "000000.00",
228 "lgx-port-shelf": "00"
234 "ROUTER_SNJSCAMCJT4_000000.00_00",
235 "port-type": "router",
236 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
237 "port-rack": "000000.00",
242 "LGX Panel_SNJSCAMCJT4_000000.00_00",
243 "lgx-port-name": "LGX Back.30",
244 "lgx-port-rack": "000000.00",
245 "lgx-port-shelf": "00"
250 "due-date": "2016-11-28T00:00:01Z",
251 "operator-contact": "pw1234"
254 response = test_utils.post_request(url, data)
255 self.assertEqual(response.status_code, requests.codes.ok)
256 res = response.json()
257 self.assertIn('PCE calculation in progress',
258 res['output']['configuration-response-common'][
260 time.sleep(self.WAITING)
262 def test_12_get_eth_service1(self):
263 url = "{}/operational/org-openroadm-service:service-list/services/service1"
264 response = test_utils.get_request(url)
265 self.assertEqual(response.status_code, requests.codes.ok)
266 res = response.json()
268 res['services'][0]['administrative-state'],
271 res['services'][0]['service-name'], 'service1')
273 res['services'][0]['connection-type'], 'service')
275 res['services'][0]['lifecycle-state'], 'planned')
278 def test_13_check_xc1_ROADMA(self):
280 "{}/config/network-topology:"
281 "network-topology/topology/topology-netconf/"
282 "node/ROADMA01/yang-ext:"
283 "mount/org-openroadm-device:org-openroadm-device/"
284 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
286 response = test_utils.get_request(url)
287 self.assertEqual(response.status_code, requests.codes.ok)
288 res = response.json()
289 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
290 self.assertDictEqual(
292 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
293 'wavelength-number': 1,
294 'opticalControlMode': 'gainLoss',
295 'target-output-power': -3.0
296 }, **res['roadm-connections'][0]),
297 res['roadm-connections'][0]
299 self.assertDictEqual(
300 {'src-if': 'SRG1-PP1-TXRX-1'},
301 res['roadm-connections'][0]['source'])
302 self.assertDictEqual(
303 {'dst-if': 'DEG1-TTP-TXRX-1'},
304 res['roadm-connections'][0]['destination'])
307 def test_14_check_xc1_ROADMC(self):
309 "{}/config/network-topology:"
310 "network-topology/topology/topology-netconf/"
311 "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
312 "org-openroadm-device/"
313 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
315 response = test_utils.get_request(url)
316 self.assertEqual(response.status_code, requests.codes.ok)
317 res = response.json()
318 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
319 self.assertDictEqual(
321 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
322 'wavelength-number': 1,
323 'opticalControlMode': 'gainLoss',
324 'target-output-power': 2.0
325 }, **res['roadm-connections'][0]),
326 res['roadm-connections'][0]
328 self.assertDictEqual(
329 {'src-if': 'SRG1-PP1-TXRX-1'},
330 res['roadm-connections'][0]['source'])
331 self.assertDictEqual(
332 {'dst-if': 'DEG2-TTP-TXRX-1'},
333 res['roadm-connections'][0]['destination'])
336 def test_15_check_topo_XPDRA(self):
337 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
338 response = test_utils.get_request(url)
339 self.assertEqual(response.status_code, requests.codes.ok)
340 res = response.json()
341 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
343 if ele['tp-id'] == 'XPDR1-NETWORK1':
344 self.assertEqual({u'frequency': 196.1, u'width': 40},
345 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
346 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
348 'org-openroadm-network-topology:xpdr-client-attributes',
350 if ele['tp-id'] == 'XPDR1-NETWORK2':
352 'org-openroadm-network-topology:xpdr-network-attributes',
356 def test_16_check_topo_ROADMA_SRG1(self):
357 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
358 response = test_utils.get_request(url)
359 self.assertEqual(response.status_code, requests.codes.ok)
360 res = response.json()
361 self.assertNotIn({u'index': 1},
363 u'org-openroadm-network-topology:srg-attributes'][
364 'available-wavelengths'])
365 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
367 if ele['tp-id'] == 'SRG1-PP1-TXRX':
368 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
369 ele['org-openroadm-network-topology:'
370 'pp-attributes']['used-wavelength']
372 if ele['tp-id'] == 'SRG1-PP2-TXRX':
373 self.assertNotIn('used-wavelength', dict.keys(ele))
376 def test_17_check_topo_ROADMA_DEG1(self):
377 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
378 response = test_utils.get_request(url)
379 self.assertEqual(response.status_code, requests.codes.ok)
380 res = response.json()
381 self.assertNotIn({u'index': 1},
383 u'org-openroadm-network-topology:'
384 u'degree-attributes'][
385 'available-wavelengths'])
386 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
388 if ele['tp-id'] == 'DEG1-CTP-TXRX':
389 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
390 ele['org-openroadm-network-topology:'
393 if ele['tp-id'] == 'DEG1-TTP-TXRX':
394 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
395 ele['org-openroadm-network-topology:'
396 'tx-ttp-attributes'][
400 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
401 response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "2",
402 "ROADMA01", "1", "SRG1-PP2-TXRX")
403 self.assertEqual(response.status_code, requests.codes.ok)
404 res = response.json()
405 self.assertIn('Xponder Roadm Link created successfully',
406 res["output"]["result"])
409 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
410 response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2",
411 "ROADMA01", "1", "SRG1-PP2-TXRX")
412 self.assertEqual(response.status_code, requests.codes.ok)
413 res = response.json()
414 self.assertIn('Roadm Xponder links created successfully',
415 res["output"]["result"])
418 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
419 response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "2",
420 "ROADMC01", "1", "SRG1-PP2-TXRX")
421 self.assertEqual(response.status_code, requests.codes.ok)
422 res = response.json()
423 self.assertIn('Xponder Roadm Link created successfully',
424 res["output"]["result"])
427 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
428 response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "2",
429 "ROADMC01", "1", "SRG1-PP2-TXRX")
430 self.assertEqual(response.status_code, requests.codes.ok)
431 res = response.json()
432 self.assertIn('Roadm Xponder links created successfully',
433 res["output"]["result"])
436 def test_22_create_eth_service2(self):
437 url = "{}/operations/org-openroadm-service:service-create"
440 "sdnc-request-header": {
441 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
442 "rpc-action": "service-create",
443 "request-system-id": "appname",
445 "http://localhost:8585/NotificationServer/notify"
447 "service-name": "service2",
448 "common-id": "ASATT1234567",
449 "connection-type": "service",
451 "service-rate": "100",
452 "node-id": "XPDRA01",
453 "service-format": "Ethernet",
454 "clli": "SNJSCAMCJP8",
458 "ROUTER_SNJSCAMCJP8_000000.00_00",
459 "port-type": "router",
460 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
461 "port-rack": "000000.00",
466 "LGX Panel_SNJSCAMCJP8_000000.00_00",
467 "lgx-port-name": "LGX Back.3",
468 "lgx-port-rack": "000000.00",
469 "lgx-port-shelf": "00"
475 "ROUTER_SNJSCAMCJP8_000000.00_00",
476 "port-type": "router",
477 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
478 "port-rack": "000000.00",
483 "LGX Panel_SNJSCAMCJP8_000000.00_00",
484 "lgx-port-name": "LGX Back.4",
485 "lgx-port-rack": "000000.00",
486 "lgx-port-shelf": "00"
492 "service-rate": "100",
493 "node-id": "XPDRC01",
494 "service-format": "Ethernet",
495 "clli": "SNJSCAMCJT4",
499 "ROUTER_SNJSCAMCJT4_000000.00_00",
500 "port-type": "router",
501 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
502 "port-rack": "000000.00",
507 "LGX Panel_SNJSCAMCJT4_000000.00_00",
508 "lgx-port-name": "LGX Back.29",
509 "lgx-port-rack": "000000.00",
510 "lgx-port-shelf": "00"
516 "ROUTER_SNJSCAMCJT4_000000.00_00",
517 "port-type": "router",
518 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
519 "port-rack": "000000.00",
524 "LGX Panel_SNJSCAMCJT4_000000.00_00",
525 "lgx-port-name": "LGX Back.30",
526 "lgx-port-rack": "000000.00",
527 "lgx-port-shelf": "00"
532 "due-date": "2016-11-28T00:00:01Z",
533 "operator-contact": "pw1234"
536 response = test_utils.post_request(url, data)
537 self.assertEqual(response.status_code, requests.codes.ok)
538 res = response.json()
539 self.assertIn('PCE calculation in progress',
540 res['output']['configuration-response-common'][
542 time.sleep(self.WAITING)
544 def test_23_get_eth_service2(self):
545 url = "{}/operational/org-openroadm-service:service-list/services/service2"
546 response = test_utils.get_request(url)
547 self.assertEqual(response.status_code, requests.codes.ok)
548 res = response.json()
550 res['services'][0]['administrative-state'],
553 res['services'][0]['service-name'], 'service2')
555 res['services'][0]['connection-type'], 'service')
557 res['services'][0]['lifecycle-state'], 'planned')
560 def test_24_check_xc2_ROADMA(self):
562 "{}/config/network-topology:"
563 "network-topology/topology/topology-netconf/"
564 "node/ROADMA01/yang-ext:"
565 "mount/org-openroadm-device:org-openroadm-device/"
566 "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
568 response = test_utils.get_request(url)
569 self.assertEqual(response.status_code, requests.codes.ok)
570 res = response.json()
571 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
572 self.assertDictEqual(
574 'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
575 'wavelength-number': 2,
576 'opticalControlMode': 'power'
577 }, **res['roadm-connections'][0]),
578 res['roadm-connections'][0]
580 self.assertDictEqual(
581 {'src-if': 'DEG1-TTP-TXRX-2'},
582 res['roadm-connections'][0]['source'])
583 self.assertDictEqual(
584 {'dst-if': 'SRG1-PP2-TXRX-2'},
585 res['roadm-connections'][0]['destination'])
587 def test_25_check_topo_XPDRA(self):
588 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
589 response = test_utils.get_request(url)
590 self.assertEqual(response.status_code, requests.codes.ok)
591 res = response.json()
592 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
594 if ele['tp-id'] == 'XPDR1-NETWORK1':
595 self.assertEqual({u'frequency': 196.1, u'width': 40},
596 ele['org-openroadm-network-topology:'
597 'xpdr-network-attributes'][
599 if ele['tp-id'] == 'XPDR1-NETWORK2':
600 self.assertEqual({u'frequency': 196.05, u'width': 40},
601 ele['org-openroadm-network-topology:'
602 'xpdr-network-attributes'][
604 if ele['tp-id'] == 'XPDR1-CLIENT1' or \
605 ele['tp-id'] == 'XPDR1-CLIENT3':
607 'org-openroadm-network-topology:xpdr-client-attributes',
611 def test_26_check_topo_ROADMA_SRG1(self):
612 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
613 response = test_utils.get_request(url)
614 self.assertEqual(response.status_code, requests.codes.ok)
615 res = response.json()
616 self.assertNotIn({u'index': 1}, res['node'][0][
617 u'org-openroadm-network-topology:srg-attributes'][
618 'available-wavelengths'])
619 self.assertNotIn({u'index': 2}, res['node'][0][
620 u'org-openroadm-network-topology:srg-attributes'][
621 'available-wavelengths'])
622 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
624 if ele['tp-id'] == 'SRG1-PP1-TXRX':
625 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
626 ele['org-openroadm-network-topology:'
627 'pp-attributes']['used-wavelength'])
628 self.assertNotIn({u'index': 2, u'frequency': 196.05,
630 ele['org-openroadm-network-topology:'
631 'pp-attributes']['used-wavelength'])
632 if ele['tp-id'] == 'SRG1-PP2-TXRX':
633 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
634 ele['org-openroadm-network-topology:'
635 'pp-attributes']['used-wavelength'])
636 self.assertNotIn({u'index': 1, u'frequency': 196.1,
638 ele['org-openroadm-network-topology:'
639 'pp-attributes']['used-wavelength'])
640 if ele['tp-id'] == 'SRG1-PP3-TXRX':
641 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
645 def test_27_check_topo_ROADMA_DEG1(self):
646 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
647 response = test_utils.get_request(url)
648 self.assertEqual(response.status_code, requests.codes.ok)
649 res = response.json()
650 self.assertNotIn({u'index': 1}, res['node'][0][
651 u'org-openroadm-network-topology:degree-attributes'][
652 'available-wavelengths'])
653 self.assertNotIn({u'index': 2}, res['node'][0][
654 u'org-openroadm-network-topology:degree-attributes'][
655 'available-wavelengths'])
656 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
658 if ele['tp-id'] == 'DEG1-CTP-TXRX':
659 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
660 ele['org-openroadm-network-topology:'
661 'ctp-attributes']['used-wavelengths'])
662 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
663 ele['org-openroadm-network-topology:'
664 'ctp-attributes']['used-wavelengths'])
665 if ele['tp-id'] == 'DEG1-TTP-TXRX':
666 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
667 ele['org-openroadm-network-topology:'
668 'tx-ttp-attributes']['used-wavelengths'])
669 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
670 ele['org-openroadm-network-topology:'
671 'tx-ttp-attributes']['used-wavelengths'])
674 # creation service test on a non-available resource
675 def test_28_create_eth_service3(self):
676 url = "{}/operations/org-openroadm-service:service-create"
679 "sdnc-request-header": {
680 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
681 "rpc-action": "service-create",
682 "request-system-id": "appname",
684 "http://localhost:8585/NotificationServer/notify"
686 "service-name": "service3",
687 "common-id": "ASATT1234567",
688 "connection-type": "service",
690 "service-rate": "100",
691 "node-id": "XPDRA01",
692 "service-format": "Ethernet",
693 "clli": "SNJSCAMCJP8",
697 "ROUTER_SNJSCAMCJP8_000000.00_00",
698 "port-type": "router",
699 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
700 "port-rack": "000000.00",
705 "LGX Panel_SNJSCAMCJP8_000000.00_00",
706 "lgx-port-name": "LGX Back.3",
707 "lgx-port-rack": "000000.00",
708 "lgx-port-shelf": "00"
714 "ROUTER_SNJSCAMCJP8_000000.00_00",
715 "port-type": "router",
716 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
717 "port-rack": "000000.00",
722 "LGX Panel_SNJSCAMCJP8_000000.00_00",
723 "lgx-port-name": "LGX Back.4",
724 "lgx-port-rack": "000000.00",
725 "lgx-port-shelf": "00"
731 "service-rate": "100",
732 "node-id": "XPDRC01",
733 "service-format": "Ethernet",
734 "clli": "SNJSCAMCJT4",
738 "ROUTER_SNJSCAMCJT4_000000.00_00",
739 "port-type": "router",
740 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
741 "port-rack": "000000.00",
746 "LGX Panel_SNJSCAMCJT4_000000.00_00",
747 "lgx-port-name": "LGX Back.29",
748 "lgx-port-rack": "000000.00",
749 "lgx-port-shelf": "00"
755 "ROUTER_SNJSCAMCJT4_000000.00_00",
756 "port-type": "router",
757 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
758 "port-rack": "000000.00",
763 "LGX Panel_SNJSCAMCJT4_000000.00_00",
764 "lgx-port-name": "LGX Back.30",
765 "lgx-port-rack": "000000.00",
766 "lgx-port-shelf": "00"
771 "due-date": "2016-11-28T00:00:01Z",
772 "operator-contact": "pw1234"
775 response = test_utils.post_request(url, data)
776 self.assertEqual(response.status_code, requests.codes.ok)
777 res = response.json()
778 self.assertIn('PCE calculation in progress',
779 res['output']['configuration-response-common'][
781 self.assertIn('200', res['output']['configuration-response-common'][
783 time.sleep(self.WAITING)
785 # add a test that check the openroadm-service-list still only
786 # contains 2 elements
788 def test_29_delete_eth_service3(self):
789 url = "{}/operations/org-openroadm-service:service-delete"
791 "sdnc-request-header": {
792 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
793 "rpc-action": "service-delete",
794 "request-system-id": "appname",
796 "http://localhost:8585/NotificationServer/notify"
798 "service-delete-req-info": {
799 "service-name": "service3",
800 "tail-retention": "no"
804 response = test_utils.post_request(url, data)
805 self.assertEqual(response.status_code, requests.codes.ok)
806 res = response.json()
807 self.assertIn('Service \'service3\' does not exist in datastore',
808 res['output']['configuration-response-common'][
810 self.assertIn('500', res['output']['configuration-response-common'][
814 def test_30_delete_eth_service1(self):
815 url = "{}/operations/org-openroadm-service:service-delete"
817 "sdnc-request-header": {
818 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
819 "rpc-action": "service-delete",
820 "request-system-id": "appname",
822 "http://localhost:8585/NotificationServer/notify"
824 "service-delete-req-info": {
825 "service-name": "service1",
826 "tail-retention": "no"
830 response = test_utils.post_request(url, data)
831 self.assertEqual(response.status_code, requests.codes.ok)
832 res = response.json()
833 self.assertIn('Renderer service delete in progress',
834 res['output']['configuration-response-common'][
838 def test_31_delete_eth_service2(self):
839 url = "{}/operations/org-openroadm-service:service-delete"
841 "sdnc-request-header": {
842 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
843 "rpc-action": "service-delete",
844 "request-system-id": "appname",
846 "http://localhost:8585/NotificationServer/notify"
848 "service-delete-req-info": {
849 "service-name": "service2",
850 "tail-retention": "no"
854 response = test_utils.post_request(url, data)
855 self.assertEqual(response.status_code, requests.codes.ok)
856 res = response.json()
857 self.assertIn('Renderer service delete in progress',
858 res['output']['configuration-response-common'][
862 def test_32_check_no_xc_ROADMA(self):
864 "{}/config/network-topology:"
865 "network-topology/topology/topology-netconf/"
866 "node/ROADMA01/yang-ext:"
867 "mount/org-openroadm-device:org-openroadm-device/"
869 response = test_utils.get_request(url)
870 res = response.json()
871 self.assertEqual(response.status_code, requests.codes.ok)
872 self.assertNotIn('roadm-connections',
873 dict.keys(res['org-openroadm-device']))
876 def test_33_check_topo_XPDRA(self):
877 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
878 response = test_utils.get_request(url)
879 self.assertEqual(response.status_code, requests.codes.ok)
880 res = response.json()
881 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
883 if ((ele[u'org-openroadm-common-network:tp-type'] ==
885 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele[
886 'tp-id'] == 'XPDR1-CLIENT3')):
888 'org-openroadm-network-topology:xpdr-client-attributes',
890 elif (ele[u'org-openroadm-common-network:tp-type'] ==
892 self.assertIn(u'tail-equipment-id', dict.keys(
893 ele[u'org-openroadm-network-topology:'
894 u'xpdr-network-attributes']))
895 self.assertNotIn('wavelength', dict.keys(
896 ele[u'org-openroadm-network-topology:'
897 u'xpdr-network-attributes']))
900 def test_34_check_topo_ROADMA_SRG1(self):
901 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
902 response = test_utils.get_request(url)
903 self.assertEqual(response.status_code, requests.codes.ok)
904 res = response.json()
905 self.assertIn({u'index': 1}, res['node'][0][
906 u'org-openroadm-network-topology:srg-attributes'][
907 'available-wavelengths'])
908 self.assertIn({u'index': 2}, res['node'][0][
909 u'org-openroadm-network-topology:srg-attributes'][
910 'available-wavelengths'])
911 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
913 if ele['tp-id'] == 'SRG1-PP1-TXRX' or \
914 ele['tp-id'] == 'SRG1-PP1-TXRX':
915 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
918 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
922 def test_35_check_topo_ROADMA_DEG1(self):
923 url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
924 response = test_utils.get_request(url)
925 self.assertEqual(response.status_code, requests.codes.ok)
926 res = response.json()
927 self.assertIn({u'index': 1}, res['node'][0][
928 u'org-openroadm-network-topology:degree-attributes'][
929 'available-wavelengths'])
930 self.assertIn({u'index': 2}, res['node'][0][
931 u'org-openroadm-network-topology:degree-attributes'][
932 'available-wavelengths'])
933 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
935 if ele['tp-id'] == 'DEG1-CTP-TXRX':
936 self.assertNotIn('org-openroadm-network-topology:'
937 'ctp-attributes', dict.keys(ele))
938 if ele['tp-id'] == 'DEG1-TTP-TXRX':
939 self.assertNotIn('org-openroadm-network-topology:'
940 'tx-ttp-attributes', dict.keys(ele))
943 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
944 def test_36_create_oc_service1(self):
945 url = "{}/operations/org-openroadm-service:service-create"
948 "sdnc-request-header": {
949 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
950 "rpc-action": "service-create",
951 "request-system-id": "appname",
953 "http://localhost:8585/NotificationServer/notify"
955 "service-name": "service1",
956 "common-id": "ASATT1234567",
957 "connection-type": "roadm-line",
959 "service-rate": "100",
960 "node-id": "ROADMA01",
961 "service-format": "OC",
962 "clli": "SNJSCAMCJP8",
966 "ROUTER_SNJSCAMCJP8_000000.00_00",
967 "port-type": "router",
968 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
969 "port-rack": "000000.00",
974 "LGX Panel_SNJSCAMCJP8_000000.00_00",
975 "lgx-port-name": "LGX Back.3",
976 "lgx-port-rack": "000000.00",
977 "lgx-port-shelf": "00"
983 "ROUTER_SNJSCAMCJP8_000000.00_00",
984 "port-type": "router",
985 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
986 "port-rack": "000000.00",
991 "LGX Panel_SNJSCAMCJP8_000000.00_00",
992 "lgx-port-name": "LGX Back.4",
993 "lgx-port-rack": "000000.00",
994 "lgx-port-shelf": "00"
1000 "service-rate": "100",
1001 "node-id": "ROADMC01",
1002 "service-format": "OC",
1003 "clli": "SNJSCAMCJT4",
1007 "ROUTER_SNJSCAMCJT4_000000.00_00",
1008 "port-type": "router",
1009 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1010 "port-rack": "000000.00",
1015 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1016 "lgx-port-name": "LGX Back.29",
1017 "lgx-port-rack": "000000.00",
1018 "lgx-port-shelf": "00"
1024 "ROUTER_SNJSCAMCJT4_000000.00_00",
1025 "port-type": "router",
1026 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1027 "port-rack": "000000.00",
1032 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1033 "lgx-port-name": "LGX Back.30",
1034 "lgx-port-rack": "000000.00",
1035 "lgx-port-shelf": "00"
1038 "optic-type": "gray"
1040 "due-date": "2016-11-28T00:00:01Z",
1041 "operator-contact": "pw1234"
1044 response = test_utils.post_request(url, data)
1045 self.assertEqual(response.status_code, requests.codes.ok)
1046 res = response.json()
1047 self.assertIn('PCE calculation in progress',
1048 res['output']['configuration-response-common'][
1049 'response-message'])
1050 time.sleep(self.WAITING)
1052 def test_37_get_oc_service1(self):
1053 url = "{}/operational/org-openroadm-service:service-list/services/service1"
1054 response = test_utils.get_request(url)
1055 self.assertEqual(response.status_code, requests.codes.ok)
1056 res = response.json()
1058 res['services'][0]['administrative-state'],
1061 res['services'][0]['service-name'], 'service1')
1063 res['services'][0]['connection-type'], 'roadm-line')
1065 res['services'][0]['lifecycle-state'], 'planned')
1068 def test_38_check_xc1_ROADMA(self):
1070 "{}/config/network-topology:"
1071 "network-topology/topology/topology-netconf/"
1072 "node/ROADMA01/yang-ext:"
1073 "mount/org-openroadm-device:org-openroadm-device/"
1074 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1076 response = test_utils.get_request(url)
1077 self.assertEqual(response.status_code, requests.codes.ok)
1078 res = response.json()
1079 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1080 self.assertDictEqual(
1082 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1083 'wavelength-number': 1,
1084 'opticalControlMode': 'gainLoss',
1085 'target-output-power': -3.0
1086 }, **res['roadm-connections'][0]),
1087 res['roadm-connections'][0]
1089 self.assertDictEqual(
1090 {'src-if': 'SRG1-PP1-TXRX-1'},
1091 res['roadm-connections'][0]['source'])
1092 self.assertDictEqual(
1093 {'dst-if': 'DEG1-TTP-TXRX-1'},
1094 res['roadm-connections'][0]['destination'])
1097 def test_39_check_xc1_ROADMC(self):
1099 "{}/config/network-topology:"
1100 "network-topology/topology/topology-netconf/"
1101 "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
1102 "org-openroadm-device/"
1103 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1105 response = test_utils.get_request(url)
1106 self.assertEqual(response.status_code, requests.codes.ok)
1107 res = response.json()
1108 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1109 self.assertDictEqual(
1111 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1112 'wavelength-number': 1,
1113 'opticalControlMode': 'gainLoss',
1114 'target-output-power': 2.0
1115 }, **res['roadm-connections'][0]),
1116 res['roadm-connections'][0]
1118 self.assertDictEqual(
1119 {'src-if': 'SRG1-PP1-TXRX-1'},
1120 res['roadm-connections'][0]['source'])
1121 self.assertDictEqual(
1122 {'dst-if': 'DEG2-TTP-TXRX-1'},
1123 res['roadm-connections'][0]['destination'])
1126 def test_40_create_oc_service2(self):
1127 url = "{}/operations/org-openroadm-service:service-create"
1130 "sdnc-request-header": {
1131 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1132 "rpc-action": "service-create",
1133 "request-system-id": "appname",
1135 "http://localhost:8585/NotificationServer/notify"
1137 "service-name": "service2",
1138 "common-id": "ASATT1234567",
1139 "connection-type": "roadm-line",
1141 "service-rate": "100",
1142 "node-id": "ROADMA01",
1143 "service-format": "OC",
1144 "clli": "SNJSCAMCJP8",
1148 "ROUTER_SNJSCAMCJP8_000000.00_00",
1149 "port-type": "router",
1150 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1151 "port-rack": "000000.00",
1156 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1157 "lgx-port-name": "LGX Back.3",
1158 "lgx-port-rack": "000000.00",
1159 "lgx-port-shelf": "00"
1165 "ROUTER_SNJSCAMCJP8_000000.00_00",
1166 "port-type": "router",
1167 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1168 "port-rack": "000000.00",
1173 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1174 "lgx-port-name": "LGX Back.4",
1175 "lgx-port-rack": "000000.00",
1176 "lgx-port-shelf": "00"
1179 "optic-type": "gray"
1182 "service-rate": "100",
1183 "node-id": "ROADMC01",
1184 "service-format": "OC",
1185 "clli": "SNJSCAMCJT4",
1189 "ROUTER_SNJSCAMCJT4_000000.00_00",
1190 "port-type": "router",
1191 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1192 "port-rack": "000000.00",
1197 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1198 "lgx-port-name": "LGX Back.29",
1199 "lgx-port-rack": "000000.00",
1200 "lgx-port-shelf": "00"
1206 "ROUTER_SNJSCAMCJT4_000000.00_00",
1207 "port-type": "router",
1208 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1209 "port-rack": "000000.00",
1214 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1215 "lgx-port-name": "LGX Back.30",
1216 "lgx-port-rack": "000000.00",
1217 "lgx-port-shelf": "00"
1220 "optic-type": "gray"
1222 "due-date": "2016-11-28T00:00:01Z",
1223 "operator-contact": "pw1234"
1226 response = test_utils.post_request(url, data)
1227 self.assertEqual(response.status_code, requests.codes.ok)
1228 res = response.json()
1229 self.assertIn('PCE calculation in progress',
1230 res['output']['configuration-response-common'][
1231 'response-message'])
1232 time.sleep(self.WAITING)
1234 def test_41_get_oc_service2(self):
1235 url = "{}/operational/org-openroadm-service:service-list/services/service2"
1236 response = test_utils.get_request(url)
1237 self.assertEqual(response.status_code, requests.codes.ok)
1238 res = response.json()
1240 res['services'][0]['administrative-state'],
1243 res['services'][0]['service-name'], 'service2')
1245 res['services'][0]['connection-type'], 'roadm-line')
1247 res['services'][0]['lifecycle-state'], 'planned')
1250 def test_42_check_xc2_ROADMA(self):
1252 "{}/config/network-topology:"
1253 "network-topology/topology/topology-netconf/"
1254 "node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1255 "org-openroadm-device/"
1256 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1258 response = test_utils.get_request(url)
1259 self.assertEqual(response.status_code, requests.codes.ok)
1260 res = response.json()
1261 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1262 self.assertDictEqual(
1264 'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1265 'wavelength-number': 2,
1266 'opticalControlMode': 'gainLoss',
1267 'target-output-power': -3.0
1268 }, **res['roadm-connections'][0]),
1269 res['roadm-connections'][0]
1271 self.assertDictEqual(
1272 {'src-if': 'SRG1-PP2-TXRX-2'},
1273 res['roadm-connections'][0]['source'])
1274 self.assertDictEqual(
1275 {'dst-if': 'DEG1-TTP-TXRX-2'},
1276 res['roadm-connections'][0]['destination'])
1279 def test_43_check_topo_ROADMA(self):
1280 self.test_26_check_topo_ROADMA_SRG1()
1281 self.test_27_check_topo_ROADMA_DEG1()
1284 def test_44_delete_oc_service1(self):
1285 url = "{}/operations/org-openroadm-service:service-delete"
1287 "sdnc-request-header": {
1288 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1289 "rpc-action": "service-delete",
1290 "request-system-id": "appname",
1292 "http://localhost:8585/NotificationServer/notify"
1294 "service-delete-req-info": {
1295 "service-name": "service1",
1296 "tail-retention": "no"
1300 response = test_utils.post_request(url, data)
1301 self.assertEqual(response.status_code, requests.codes.ok)
1302 res = response.json()
1303 self.assertIn('Renderer service delete in progress',
1304 res['output']['configuration-response-common'][
1305 'response-message'])
1308 def test_45_delete_oc_service2(self):
1309 url = "{}/operations/org-openroadm-service:service-delete"
1311 "sdnc-request-header": {
1312 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1313 "rpc-action": "service-delete",
1314 "request-system-id": "appname",
1316 "http://localhost:8585/NotificationServer/notify"
1318 "service-delete-req-info": {
1319 "service-name": "service2",
1320 "tail-retention": "no"
1324 response = test_utils.post_request(url, data)
1325 self.assertEqual(response.status_code, requests.codes.ok)
1326 res = response.json()
1327 self.assertIn('Renderer service delete in progress',
1328 res['output']['configuration-response-common'][
1329 'response-message'])
1332 def test_46_get_no_oc_services(self):
1334 url = ("{}/operational/org-openroadm-service:service-list"
1336 response = test_utils.get_request(url)
1337 self.assertEqual(response.status_code, requests.codes.not_found)
1338 res = response.json()
1341 "error-type": "application",
1342 "error-tag": "data-missing",
1344 "Request could not be completed because the relevant data "
1345 "model content does not exist"
1347 res['errors']['error'])
1350 def test_47_get_no_xc_ROADMA(self):
1352 "{}/config/network-topology:"
1353 "network-topology/topology/topology-netconf"
1354 "/node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1355 "org-openroadm-device/"
1357 response = test_utils.get_request(url)
1358 self.assertEqual(response.status_code, requests.codes.ok)
1359 res = response.json()
1360 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1363 def test_48_check_topo_ROADMA(self):
1364 self.test_34_check_topo_ROADMA_SRG1()
1365 self.test_35_check_topo_ROADMA_DEG1()
1367 def test_49_loop_create_eth_service(self):
1368 for i in range(1, 6):
1369 print("iteration number {}".format(i))
1370 print("eth service creation")
1371 self.test_11_create_eth_service1()
1372 print("check xc in ROADMA01")
1373 self.test_13_check_xc1_ROADMA()
1374 print("check xc in ROADMC01")
1375 self.test_14_check_xc1_ROADMC()
1376 print("eth service deletion\n")
1377 self.test_30_delete_eth_service1()
1379 def test_50_loop_create_oc_service(self):
1380 url = "{}/operational/org-openroadm-service:service-list/services/service1"
1381 response = test_utils.get_request(url)
1382 if response.status_code != 404:
1383 url = ("{}/operations/org-openroadm-service:service-delete"
1386 "sdnc-request-header": {
1387 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1388 "rpc-action": "service-delete",
1389 "request-system-id": "appname",
1391 "http://localhost:8585/NotificationServer/notify"
1393 "service-delete-req-info": {
1394 "service-name": "service1",
1395 "tail-retention": "no"
1399 test_utils.post_request(url, data)
1402 for i in range(1, 6):
1403 print("iteration number {}".format(i))
1404 print("oc service creation")
1405 self.test_36_create_oc_service1()
1406 print("check xc in ROADMA01")
1407 self.test_38_check_xc1_ROADMA()
1408 print("check xc in ROADMC01")
1409 self.test_39_check_xc1_ROADMC()
1410 print("oc service deletion\n")
1411 self.test_44_delete_oc_service1()
1413 def test_51_disconnect_XPDRA(self):
1414 response = test_utils.unmount_device("XPDRA01")
1415 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1417 def test_52_disconnect_XPDRC(self):
1418 response = test_utils.unmount_device("XPDRC01")
1419 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1421 def test_53_disconnect_ROADMA(self):
1422 response = test_utils.unmount_device("ROADMA01")
1423 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1425 def test_54_disconnect_ROADMC(self):
1426 response = test_utils.unmount_device("ROADMC01")
1427 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1430 if __name__ == "__main__":
1431 unittest.main(verbosity=2)