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 ##############################################################################
22 class TransportPCEFulltesting(unittest.TestCase):
23 headers = {'content-type': 'application/json'}
25 honeynode_process1 = None
26 honeynode_process2 = None
27 honeynode_process3 = None
28 honeynode_process4 = None
29 restconf_baseurl = "http://localhost:8181/restconf"
30 WAITING = 20 # nominal value is 300
32 # START_IGNORE_XTESTING
36 print("starting honeynode1...")
37 cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
40 print("starting honeynode2...")
41 cls.honeynode_process2 = test_utils.start_roadma_full_honeynode()
44 print("starting honeynode3...")
45 cls.honeynode_process3 = test_utils.start_roadmc_full_honeynode()
48 print("starting honeynode4...")
49 cls.honeynode_process4 = test_utils.start_xpdrc_honeynode()
51 print("all honeynodes started")
53 print("starting opendaylight...")
54 cls.odl_process = test_utils.start_tpce()
56 print("opendaylight started")
59 def tearDownClass(cls):
60 for child in psutil.Process(cls.odl_process.pid).children():
61 child.send_signal(signal.SIGINT)
63 cls.odl_process.send_signal(signal.SIGINT)
64 cls.odl_process.wait()
65 for child in psutil.Process(cls.honeynode_process1.pid).children():
66 child.send_signal(signal.SIGINT)
68 cls.honeynode_process1.send_signal(signal.SIGINT)
69 cls.honeynode_process1.wait()
70 for child in psutil.Process(cls.honeynode_process2.pid).children():
71 child.send_signal(signal.SIGINT)
73 cls.honeynode_process2.send_signal(signal.SIGINT)
74 cls.honeynode_process2.wait()
75 for child in psutil.Process(cls.honeynode_process3.pid).children():
76 child.send_signal(signal.SIGINT)
78 cls.honeynode_process3.send_signal(signal.SIGINT)
79 cls.honeynode_process3.wait()
80 for child in psutil.Process(cls.honeynode_process4.pid).children():
81 child.send_signal(signal.SIGINT)
83 cls.honeynode_process4.send_signal(signal.SIGINT)
84 cls.honeynode_process4.wait()
85 print("all processes killed")
87 def setUp(self): # instruction executed before each test method
88 print("execution of {}".format(self.id().split(".")[-1]))
92 # connect netconf devices
93 def test_01_connect_xpdrA(self):
94 url = ("{}/config/network-topology:"
95 "network-topology/topology/topology-netconf/node/XPDRA01"
96 .format(self.restconf_baseurl))
99 "netconf-node-topology:username": "admin",
100 "netconf-node-topology:password": "admin",
101 "netconf-node-topology:host": "127.0.0.1",
102 "netconf-node-topology:port": "17830",
103 "netconf-node-topology:tcp-only": "false",
104 "netconf-node-topology:pass-through": {}}]}
105 headers = {'content-type': 'application/json'}
106 response = requests.request(
107 "PUT", url, data=json.dumps(data), headers=headers,
108 auth=('admin', 'admin'))
109 self.assertEqual(response.status_code, requests.codes.created)
112 def test_02_connect_xpdrC(self):
113 url = ("{}/config/network-topology:"
114 "network-topology/topology/topology-netconf/node/XPDRC01"
115 .format(self.restconf_baseurl))
117 "node-id": "XPDRC01",
118 "netconf-node-topology:username": "admin",
119 "netconf-node-topology:password": "admin",
120 "netconf-node-topology:host": "127.0.0.1",
121 "netconf-node-topology:port": "17834",
122 "netconf-node-topology:tcp-only": "false",
123 "netconf-node-topology:pass-through": {}}]}
124 headers = {'content-type': 'application/json'}
125 response = requests.request(
126 "PUT", url, data=json.dumps(data), headers=headers,
127 auth=('admin', 'admin'))
128 self.assertEqual(response.status_code, requests.codes.created)
131 def test_03_connect_rdmA(self):
132 url = ("{}/config/network-topology:"
133 "network-topology/topology/topology-netconf/node/ROADMA01"
134 .format(self.restconf_baseurl))
136 "node-id": "ROADMA01",
137 "netconf-node-topology:username": "admin",
138 "netconf-node-topology:password": "admin",
139 "netconf-node-topology:host": "127.0.0.1",
140 "netconf-node-topology:port": "17821",
141 "netconf-node-topology:tcp-only": "false",
142 "netconf-node-topology:pass-through": {}}]}
143 headers = {'content-type': 'application/json'}
144 response = requests.request(
145 "PUT", url, data=json.dumps(data), headers=headers,
146 auth=('admin', 'admin'))
147 self.assertEqual(response.status_code, requests.codes.created)
150 def test_04_connect_rdmC(self):
151 url = ("{}/config/network-topology:"
152 "network-topology/topology/topology-netconf/node/ROADMC01"
153 .format(self.restconf_baseurl))
155 "node-id": "ROADMC01",
156 "netconf-node-topology:username": "admin",
157 "netconf-node-topology:password": "admin",
158 "netconf-node-topology:host": "127.0.0.1",
159 "netconf-node-topology:port": "17823",
160 "netconf-node-topology:tcp-only": "false",
161 "netconf-node-topology:pass-through": {}}]}
162 headers = {'content-type': 'application/json'}
163 response = requests.request(
164 "PUT", url, data=json.dumps(data), headers=headers,
165 auth=('admin', 'admin'))
166 self.assertEqual(response.status_code, requests.codes.created)
169 def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
170 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
171 format(self.restconf_baseurl)
173 "networkutils:input": {
174 "networkutils:links-input": {
175 "networkutils:xpdr-node": "XPDRA01",
176 "networkutils:xpdr-num": "1",
177 "networkutils:network-num": "1",
178 "networkutils:rdm-node": "ROADMA01",
179 "networkutils:srg-num": "1",
180 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
184 headers = {'content-type': 'application/json'}
185 response = requests.request(
186 "POST", url, data=json.dumps(data),
187 headers=headers, auth=('admin', 'admin'))
188 self.assertEqual(response.status_code, requests.codes.ok)
189 res = response.json()
190 self.assertIn('Xponder Roadm Link created successfully',
191 res["output"]["result"])
194 def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
195 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
196 format(self.restconf_baseurl)
198 "networkutils:input": {
199 "networkutils:links-input": {
200 "networkutils:xpdr-node": "XPDRA01",
201 "networkutils:xpdr-num": "1",
202 "networkutils:network-num": "1",
203 "networkutils:rdm-node": "ROADMA01",
204 "networkutils:srg-num": "1",
205 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
209 headers = {'content-type': 'application/json'}
210 response = requests.request(
211 "POST", url, data=json.dumps(data),
212 headers=headers, auth=('admin', 'admin'))
213 self.assertEqual(response.status_code, requests.codes.ok)
214 res = response.json()
215 self.assertIn('Roadm Xponder links created successfully',
216 res["output"]["result"])
219 def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
220 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
221 format(self.restconf_baseurl)
223 "networkutils:input": {
224 "networkutils:links-input": {
225 "networkutils:xpdr-node": "XPDRC01",
226 "networkutils:xpdr-num": "1",
227 "networkutils:network-num": "1",
228 "networkutils:rdm-node": "ROADMC01",
229 "networkutils:srg-num": "1",
230 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
234 headers = {'content-type': 'application/json'}
235 response = requests.request(
236 "POST", url, data=json.dumps(data),
237 headers=headers, auth=('admin', 'admin'))
238 self.assertEqual(response.status_code, requests.codes.ok)
239 res = response.json()
240 self.assertIn('Xponder Roadm Link created successfully',
241 res["output"]["result"])
244 def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
245 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
246 format(self.restconf_baseurl)
248 "networkutils:input": {
249 "networkutils:links-input": {
250 "networkutils:xpdr-node": "XPDRC01",
251 "networkutils:xpdr-num": "1",
252 "networkutils:network-num": "1",
253 "networkutils:rdm-node": "ROADMC01",
254 "networkutils:srg-num": "1",
255 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
259 headers = {'content-type': 'application/json'}
260 response = requests.request(
261 "POST", url, data=json.dumps(data),
262 headers=headers, auth=('admin', 'admin'))
263 self.assertEqual(response.status_code, requests.codes.ok)
264 res = response.json()
265 self.assertIn('Roadm Xponder links created successfully',
266 res["output"]["result"])
269 def test_09_add_omsAttributes_ROADMA_ROADMC(self):
270 # Config ROADMA-ROADMC oms-attributes
272 "{}/config/ietf-network:"
273 "networks/network/openroadm-topology/ietf-network-topology:"
274 "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/"
275 "org-openroadm-network-topology:"
276 "OMS-attributes/span"
277 .format(self.restconf_baseurl))
280 "auto-spanloss": "true",
281 "spanloss-base": 11.4,
282 "spanloss-current": 12,
283 "engineered-spanloss": 12.2,
284 "link-concatenation": [{
287 "SRLG-length": 100000,
289 headers = {'content-type': 'application/json'}
290 response = requests.request(
291 "PUT", url, data=json.dumps(data), headers=headers,
292 auth=('admin', 'admin'))
293 self.assertEqual(response.status_code, requests.codes.created)
295 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
296 # Config ROADMC-ROADMA oms-attributes
298 "{}/config/ietf-network:"
299 "networks/network/openroadm-topology/ietf-network-topology:"
300 "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/"
301 "org-openroadm-network-topology:"
302 "OMS-attributes/span"
303 .format(self.restconf_baseurl))
306 "auto-spanloss": "true",
307 "spanloss-base": 11.4,
308 "spanloss-current": 12,
309 "engineered-spanloss": 12.2,
310 "link-concatenation": [{
313 "SRLG-length": 100000,
315 headers = {'content-type': 'application/json'}
316 response = requests.request(
317 "PUT", url, data=json.dumps(data), headers=headers,
318 auth=('admin', 'admin'))
319 self.assertEqual(response.status_code, requests.codes.created)
321 # test service-create for Eth service from xpdr to xpdr
322 def test_11_create_eth_service1(self):
323 url = ("{}/operations/org-openroadm-service:service-create"
324 .format(self.restconf_baseurl))
327 "sdnc-request-header": {
328 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
329 "rpc-action": "service-create",
330 "request-system-id": "appname",
332 "http://localhost:8585/NotificationServer/notify"
334 "service-name": "service1",
335 "common-id": "ASATT1234567",
336 "connection-type": "service",
338 "service-rate": "100",
339 "node-id": "XPDRA01",
340 "service-format": "Ethernet",
341 "clli": "SNJSCAMCJP8",
345 "ROUTER_SNJSCAMCJP8_000000.00_00",
346 "port-type": "router",
347 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
348 "port-rack": "000000.00",
353 "LGX Panel_SNJSCAMCJP8_000000.00_00",
354 "lgx-port-name": "LGX Back.3",
355 "lgx-port-rack": "000000.00",
356 "lgx-port-shelf": "00"
362 "ROUTER_SNJSCAMCJP8_000000.00_00",
363 "port-type": "router",
364 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
365 "port-rack": "000000.00",
370 "LGX Panel_SNJSCAMCJP8_000000.00_00",
371 "lgx-port-name": "LGX Back.4",
372 "lgx-port-rack": "000000.00",
373 "lgx-port-shelf": "00"
379 "service-rate": "100",
380 "node-id": "XPDRC01",
381 "service-format": "Ethernet",
382 "clli": "SNJSCAMCJT4",
386 "ROUTER_SNJSCAMCJT4_000000.00_00",
387 "port-type": "router",
388 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
389 "port-rack": "000000.00",
394 "LGX Panel_SNJSCAMCJT4_000000.00_00",
395 "lgx-port-name": "LGX Back.29",
396 "lgx-port-rack": "000000.00",
397 "lgx-port-shelf": "00"
403 "ROUTER_SNJSCAMCJT4_000000.00_00",
404 "port-type": "router",
405 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
406 "port-rack": "000000.00",
411 "LGX Panel_SNJSCAMCJT4_000000.00_00",
412 "lgx-port-name": "LGX Back.30",
413 "lgx-port-rack": "000000.00",
414 "lgx-port-shelf": "00"
419 "due-date": "2016-11-28T00:00:01Z",
420 "operator-contact": "pw1234"
423 headers = {'content-type': 'application/json',
424 "Accept": "application/json"}
425 response = requests.request(
426 "POST", url, data=json.dumps(data), headers=headers,
427 auth=('admin', 'admin'))
428 self.assertEqual(response.status_code, requests.codes.ok)
429 res = response.json()
430 self.assertIn('PCE calculation in progress',
431 res['output']['configuration-response-common'][
433 time.sleep(self.WAITING)
435 def test_12_get_eth_service1(self):
436 url = ("{}/operational/org-openroadm-service:service-list/services/"
437 "service1".format(self.restconf_baseurl))
438 headers = {'content-type': 'application/json',
439 "Accept": "application/json"}
440 response = requests.request(
441 "GET", url, headers=headers, auth=('admin', 'admin'))
442 self.assertEqual(response.status_code, requests.codes.ok)
443 res = response.json()
445 res['services'][0]['administrative-state'],
448 res['services'][0]['service-name'], 'service1')
450 res['services'][0]['connection-type'], 'service')
452 res['services'][0]['lifecycle-state'], 'planned')
455 def test_13_check_xc1_ROADMA(self):
457 "{}/config/network-topology:"
458 "network-topology/topology/topology-netconf/"
459 "node/ROADMA01/yang-ext:"
460 "mount/org-openroadm-device:org-openroadm-device/"
461 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
462 .format(self.restconf_baseurl))
463 headers = {'content-type': 'application/json'}
464 response = requests.request(
465 "GET", url, headers=headers, auth=('admin', 'admin'))
466 self.assertEqual(response.status_code, requests.codes.ok)
467 res = response.json()
468 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
469 self.assertDictEqual(
471 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
472 'wavelength-number': 1,
473 'opticalControlMode': 'gainLoss',
474 'target-output-power': -3.0
475 }, **res['roadm-connections'][0]),
476 res['roadm-connections'][0]
478 self.assertDictEqual(
479 {'src-if': 'SRG1-PP1-TXRX-1'},
480 res['roadm-connections'][0]['source'])
481 self.assertDictEqual(
482 {'dst-if': 'DEG1-TTP-TXRX-1'},
483 res['roadm-connections'][0]['destination'])
486 def test_14_check_xc1_ROADMC(self):
488 "{}/config/network-topology:"
489 "network-topology/topology/topology-netconf/"
490 "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
491 "org-openroadm-device/"
492 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
493 .format(self.restconf_baseurl))
494 headers = {'content-type': 'application/json'}
495 response = requests.request(
496 "GET", url, headers=headers, auth=('admin', 'admin'))
497 self.assertEqual(response.status_code, requests.codes.ok)
498 res = response.json()
499 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
500 self.assertDictEqual(
502 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
503 'wavelength-number': 1,
504 'opticalControlMode': 'gainLoss',
505 'target-output-power': 2.0
506 }, **res['roadm-connections'][0]),
507 res['roadm-connections'][0]
509 self.assertDictEqual(
510 {'src-if': 'SRG1-PP1-TXRX-1'},
511 res['roadm-connections'][0]['source'])
512 self.assertDictEqual(
513 {'dst-if': 'DEG2-TTP-TXRX-1'},
514 res['roadm-connections'][0]['destination'])
517 def test_15_check_topo_XPDRA(self):
519 "{}/config/ietf-network:"
520 "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
521 .format(self.restconf_baseurl))
522 response = requests.request(
523 "GET", url1, auth=('admin', 'admin'))
524 self.assertEqual(response.status_code, requests.codes.ok)
525 res = response.json()
526 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
528 if ele['tp-id'] == 'XPDR1-NETWORK1':
529 self.assertEqual({u'frequency': 196.1, u'width': 40},
531 'org-openroadm-network-topology:'
532 'xpdr-network-attributes'][
534 if ele['tp-id'] == 'XPDR1-CLIENT1' or \
535 ele['tp-id'] == 'XPDR1-CLIENT3':
537 'org-openroadm-network-topology:xpdr-client-attributes',
539 if ele['tp-id'] == 'XPDR1-NETWORK2':
541 'org-openroadm-network-topology:xpdr-network-attributes',
545 def test_16_check_topo_ROADMA_SRG1(self):
547 "{}/config/ietf-network:"
548 "networks/network/openroadm-topology/node/ROADMA01-SRG1"
549 .format(self.restconf_baseurl))
550 response = requests.request(
551 "GET", url1, auth=('admin', 'admin'))
552 self.assertEqual(response.status_code, requests.codes.ok)
553 res = response.json()
554 self.assertNotIn({u'index': 1},
556 u'org-openroadm-network-topology:srg-attributes'][
557 'available-wavelengths'])
558 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
560 if ele['tp-id'] == 'SRG1-PP1-TXRX':
561 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
562 ele['org-openroadm-network-topology:'
563 'pp-attributes']['used-wavelength']
565 if ele['tp-id'] == 'SRG1-PP2-TXRX':
566 self.assertNotIn('used-wavelength', dict.keys(ele))
569 def test_17_check_topo_ROADMA_DEG1(self):
571 "{}/config/ietf-network:"
572 "networks/network/openroadm-topology/node/ROADMA01-DEG1"
573 .format(self.restconf_baseurl))
574 response = requests.request(
575 "GET", url1, auth=('admin', 'admin'))
576 self.assertEqual(response.status_code, requests.codes.ok)
577 res = response.json()
578 self.assertNotIn({u'index': 1},
580 u'org-openroadm-network-topology:'
581 u'degree-attributes'][
582 'available-wavelengths'])
583 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
585 if ele['tp-id'] == 'DEG1-CTP-TXRX':
586 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
587 ele['org-openroadm-network-topology:'
590 if ele['tp-id'] == 'DEG1-TTP-TXRX':
591 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
592 ele['org-openroadm-network-topology:'
593 'tx-ttp-attributes'][
597 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
598 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
599 format(self.restconf_baseurl)
601 "networkutils:input": {
602 "networkutils:links-input": {
603 "networkutils:xpdr-node": "XPDRA01",
604 "networkutils:xpdr-num": "1",
605 "networkutils:network-num": "2",
606 "networkutils:rdm-node": "ROADMA01",
607 "networkutils:srg-num": "1",
608 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
612 headers = {'content-type': 'application/json'}
613 response = requests.request(
614 "POST", url, data=json.dumps(data),
615 headers=headers, auth=('admin', 'admin'))
616 self.assertEqual(response.status_code, requests.codes.ok)
617 res = response.json()
618 self.assertIn('Xponder Roadm Link created successfully',
619 res["output"]["result"])
622 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
623 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
624 format(self.restconf_baseurl)
626 "networkutils:input": {
627 "networkutils:links-input": {
628 "networkutils:xpdr-node": "XPDRA01",
629 "networkutils:xpdr-num": "1",
630 "networkutils:network-num": "2",
631 "networkutils:rdm-node": "ROADMA01",
632 "networkutils:srg-num": "1",
633 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
637 headers = {'content-type': 'application/json'}
638 response = requests.request(
639 "POST", url, data=json.dumps(data),
640 headers=headers, auth=('admin', 'admin'))
641 self.assertEqual(response.status_code, requests.codes.ok)
642 res = response.json()
643 self.assertIn('Roadm Xponder links created successfully',
644 res["output"]["result"])
647 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
648 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
649 format(self.restconf_baseurl)
651 "networkutils:input": {
652 "networkutils:links-input": {
653 "networkutils:xpdr-node": "XPDRC01",
654 "networkutils:xpdr-num": "1",
655 "networkutils:network-num": "2",
656 "networkutils:rdm-node": "ROADMC01",
657 "networkutils:srg-num": "1",
658 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
662 headers = {'content-type': 'application/json'}
663 response = requests.request(
664 "POST", url, data=json.dumps(data),
665 headers=headers, auth=('admin', 'admin'))
666 self.assertEqual(response.status_code, requests.codes.ok)
667 res = response.json()
668 self.assertIn('Xponder Roadm Link created successfully',
669 res["output"]["result"])
672 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
673 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
674 format(self.restconf_baseurl)
676 "networkutils:input": {
677 "networkutils:links-input": {
678 "networkutils:xpdr-node": "XPDRC01",
679 "networkutils:xpdr-num": "1",
680 "networkutils:network-num": "2",
681 "networkutils:rdm-node": "ROADMC01",
682 "networkutils:srg-num": "1",
683 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
687 headers = {'content-type': 'application/json'}
688 response = requests.request(
689 "POST", url, data=json.dumps(data),
690 headers=headers, auth=('admin', 'admin'))
691 self.assertEqual(response.status_code, requests.codes.ok)
692 res = response.json()
693 self.assertIn('Roadm Xponder links created successfully',
694 res["output"]["result"])
697 def test_22_create_eth_service2(self):
698 url = ("{}/operations/org-openroadm-service:service-create"
699 .format(self.restconf_baseurl))
702 "sdnc-request-header": {
703 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
704 "rpc-action": "service-create",
705 "request-system-id": "appname",
707 "http://localhost:8585/NotificationServer/notify"
709 "service-name": "service2",
710 "common-id": "ASATT1234567",
711 "connection-type": "service",
713 "service-rate": "100",
714 "node-id": "XPDRA01",
715 "service-format": "Ethernet",
716 "clli": "SNJSCAMCJP8",
720 "ROUTER_SNJSCAMCJP8_000000.00_00",
721 "port-type": "router",
722 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
723 "port-rack": "000000.00",
728 "LGX Panel_SNJSCAMCJP8_000000.00_00",
729 "lgx-port-name": "LGX Back.3",
730 "lgx-port-rack": "000000.00",
731 "lgx-port-shelf": "00"
737 "ROUTER_SNJSCAMCJP8_000000.00_00",
738 "port-type": "router",
739 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
740 "port-rack": "000000.00",
745 "LGX Panel_SNJSCAMCJP8_000000.00_00",
746 "lgx-port-name": "LGX Back.4",
747 "lgx-port-rack": "000000.00",
748 "lgx-port-shelf": "00"
754 "service-rate": "100",
755 "node-id": "XPDRC01",
756 "service-format": "Ethernet",
757 "clli": "SNJSCAMCJT4",
761 "ROUTER_SNJSCAMCJT4_000000.00_00",
762 "port-type": "router",
763 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
764 "port-rack": "000000.00",
769 "LGX Panel_SNJSCAMCJT4_000000.00_00",
770 "lgx-port-name": "LGX Back.29",
771 "lgx-port-rack": "000000.00",
772 "lgx-port-shelf": "00"
778 "ROUTER_SNJSCAMCJT4_000000.00_00",
779 "port-type": "router",
780 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
781 "port-rack": "000000.00",
786 "LGX Panel_SNJSCAMCJT4_000000.00_00",
787 "lgx-port-name": "LGX Back.30",
788 "lgx-port-rack": "000000.00",
789 "lgx-port-shelf": "00"
794 "due-date": "2016-11-28T00:00:01Z",
795 "operator-contact": "pw1234"
798 headers = {'content-type': 'application/json',
799 "Accept": "application/json"}
800 response = requests.request(
801 "POST", url, data=json.dumps(data), headers=headers,
802 auth=('admin', 'admin'))
803 self.assertEqual(response.status_code, requests.codes.ok)
804 res = response.json()
805 self.assertIn('PCE calculation in progress',
806 res['output']['configuration-response-common'][
808 time.sleep(self.WAITING)
810 def test_23_get_eth_service2(self):
811 url = ("{}/operational/org-openroadm-service:"
812 "service-list/services/service2"
813 .format(self.restconf_baseurl))
814 headers = {'content-type': 'application/json',
815 "Accept": "application/json"}
816 response = requests.request(
817 "GET", url, headers=headers, auth=('admin', 'admin'))
818 self.assertEqual(response.status_code, requests.codes.ok)
819 res = response.json()
821 res['services'][0]['administrative-state'],
824 res['services'][0]['service-name'], 'service2')
826 res['services'][0]['connection-type'], 'service')
828 res['services'][0]['lifecycle-state'], 'planned')
831 def test_24_check_xc2_ROADMA(self):
833 "{}/config/network-topology:"
834 "network-topology/topology/topology-netconf/"
835 "node/ROADMA01/yang-ext:"
836 "mount/org-openroadm-device:org-openroadm-device/"
837 "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
838 .format(self.restconf_baseurl))
839 headers = {'content-type': 'application/json'}
840 response = requests.request(
841 "GET", url, headers=headers, auth=('admin', 'admin'))
842 self.assertEqual(response.status_code, requests.codes.ok)
843 res = response.json()
844 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
845 self.assertDictEqual(
847 'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
848 'wavelength-number': 2,
849 'opticalControlMode': 'power'
850 }, **res['roadm-connections'][0]),
851 res['roadm-connections'][0]
853 self.assertDictEqual(
854 {'src-if': 'DEG1-TTP-TXRX-2'},
855 res['roadm-connections'][0]['source'])
856 self.assertDictEqual(
857 {'dst-if': 'SRG1-PP2-TXRX-2'},
858 res['roadm-connections'][0]['destination'])
860 def test_25_check_topo_XPDRA(self):
862 "{}/config/ietf-network:"
863 "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
864 .format(self.restconf_baseurl))
865 response = requests.request(
866 "GET", url1, auth=('admin', 'admin'))
867 self.assertEqual(response.status_code, requests.codes.ok)
868 res = response.json()
869 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
871 if ele['tp-id'] == 'XPDR1-NETWORK1':
872 self.assertEqual({u'frequency': 196.1, u'width': 40},
873 ele['org-openroadm-network-topology:'
874 'xpdr-network-attributes'][
876 if ele['tp-id'] == 'XPDR1-NETWORK2':
877 self.assertEqual({u'frequency': 196.05, u'width': 40},
878 ele['org-openroadm-network-topology:'
879 'xpdr-network-attributes'][
881 if ele['tp-id'] == 'XPDR1-CLIENT1' or \
882 ele['tp-id'] == 'XPDR1-CLIENT3':
884 'org-openroadm-network-topology:xpdr-client-attributes',
888 def test_26_check_topo_ROADMA_SRG1(self):
890 "{}/config/ietf-network:"
891 "networks/network/openroadm-topology/node/ROADMA01-SRG1"
892 .format(self.restconf_baseurl))
893 response = requests.request(
894 "GET", url1, auth=('admin', 'admin'))
895 self.assertEqual(response.status_code, requests.codes.ok)
896 res = response.json()
897 self.assertNotIn({u'index': 1}, res['node'][0][
898 u'org-openroadm-network-topology:srg-attributes'][
899 'available-wavelengths'])
900 self.assertNotIn({u'index': 2}, res['node'][0][
901 u'org-openroadm-network-topology:srg-attributes'][
902 'available-wavelengths'])
903 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
905 if ele['tp-id'] == 'SRG1-PP1-TXRX':
906 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
907 ele['org-openroadm-network-topology:'
908 'pp-attributes']['used-wavelength'])
909 self.assertNotIn({u'index': 2, u'frequency': 196.05,
911 ele['org-openroadm-network-topology:'
912 'pp-attributes']['used-wavelength'])
913 if ele['tp-id'] == 'SRG1-PP2-TXRX':
914 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
915 ele['org-openroadm-network-topology:'
916 'pp-attributes']['used-wavelength'])
917 self.assertNotIn({u'index': 1, u'frequency': 196.1,
919 ele['org-openroadm-network-topology:'
920 'pp-attributes']['used-wavelength'])
921 if ele['tp-id'] == 'SRG1-PP3-TXRX':
922 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
926 def test_27_check_topo_ROADMA_DEG1(self):
928 "{}/config/ietf-network:"
929 "networks/network/openroadm-topology/node/ROADMA01-DEG1"
930 .format(self.restconf_baseurl))
931 response = requests.request(
932 "GET", url1, auth=('admin', 'admin'))
933 self.assertEqual(response.status_code, requests.codes.ok)
934 res = response.json()
935 self.assertNotIn({u'index': 1}, res['node'][0][
936 u'org-openroadm-network-topology:degree-attributes'][
937 'available-wavelengths'])
938 self.assertNotIn({u'index': 2}, res['node'][0][
939 u'org-openroadm-network-topology:degree-attributes'][
940 'available-wavelengths'])
941 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
943 if ele['tp-id'] == 'DEG1-CTP-TXRX':
944 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
945 ele['org-openroadm-network-topology:'
946 'ctp-attributes']['used-wavelengths'])
947 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
948 ele['org-openroadm-network-topology:'
949 'ctp-attributes']['used-wavelengths'])
950 if ele['tp-id'] == 'DEG1-TTP-TXRX':
951 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
952 ele['org-openroadm-network-topology:'
953 'tx-ttp-attributes']['used-wavelengths'])
954 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
955 ele['org-openroadm-network-topology:'
956 'tx-ttp-attributes']['used-wavelengths'])
959 # creation service test on a non-available resource
960 def test_28_create_eth_service3(self):
961 url = ("{}/operations/org-openroadm-service:service-create"
962 .format(self.restconf_baseurl))
965 "sdnc-request-header": {
966 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
967 "rpc-action": "service-create",
968 "request-system-id": "appname",
970 "http://localhost:8585/NotificationServer/notify"
972 "service-name": "service3",
973 "common-id": "ASATT1234567",
974 "connection-type": "service",
976 "service-rate": "100",
977 "node-id": "XPDRA01",
978 "service-format": "Ethernet",
979 "clli": "SNJSCAMCJP8",
983 "ROUTER_SNJSCAMCJP8_000000.00_00",
984 "port-type": "router",
985 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
986 "port-rack": "000000.00",
991 "LGX Panel_SNJSCAMCJP8_000000.00_00",
992 "lgx-port-name": "LGX Back.3",
993 "lgx-port-rack": "000000.00",
994 "lgx-port-shelf": "00"
1000 "ROUTER_SNJSCAMCJP8_000000.00_00",
1001 "port-type": "router",
1002 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1003 "port-rack": "000000.00",
1008 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1009 "lgx-port-name": "LGX Back.4",
1010 "lgx-port-rack": "000000.00",
1011 "lgx-port-shelf": "00"
1014 "optic-type": "gray"
1017 "service-rate": "100",
1018 "node-id": "XPDRC01",
1019 "service-format": "Ethernet",
1020 "clli": "SNJSCAMCJT4",
1024 "ROUTER_SNJSCAMCJT4_000000.00_00",
1025 "port-type": "router",
1026 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1027 "port-rack": "000000.00",
1032 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1033 "lgx-port-name": "LGX Back.29",
1034 "lgx-port-rack": "000000.00",
1035 "lgx-port-shelf": "00"
1041 "ROUTER_SNJSCAMCJT4_000000.00_00",
1042 "port-type": "router",
1043 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1044 "port-rack": "000000.00",
1049 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1050 "lgx-port-name": "LGX Back.30",
1051 "lgx-port-rack": "000000.00",
1052 "lgx-port-shelf": "00"
1055 "optic-type": "gray"
1057 "due-date": "2016-11-28T00:00:01Z",
1058 "operator-contact": "pw1234"
1061 headers = {'content-type': 'application/json',
1062 "Accept": "application/json"}
1063 response = requests.request(
1064 "POST", url, data=json.dumps(data), headers=headers,
1065 auth=('admin', 'admin'))
1066 self.assertEqual(response.status_code, requests.codes.ok)
1067 res = response.json()
1068 self.assertIn('PCE calculation in progress',
1069 res['output']['configuration-response-common'][
1070 'response-message'])
1071 self.assertIn('200', res['output']['configuration-response-common'][
1073 time.sleep(self.WAITING)
1075 # add a test that check the openroadm-service-list still only
1076 # contains 2 elements
1078 def test_29_delete_eth_service3(self):
1079 url = ("{}/operations/org-openroadm-service:service-delete"
1080 .format(self.restconf_baseurl))
1082 "sdnc-request-header": {
1083 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1084 "rpc-action": "service-delete",
1085 "request-system-id": "appname",
1087 "http://localhost:8585/NotificationServer/notify"
1089 "service-delete-req-info": {
1090 "service-name": "service3",
1091 "tail-retention": "no"
1095 headers = {'content-type': 'application/json'}
1096 response = requests.request(
1097 "POST", url, data=json.dumps(data), headers=headers,
1098 auth=('admin', 'admin'))
1099 self.assertEqual(response.status_code, requests.codes.ok)
1100 res = response.json()
1101 self.assertIn('Service \'service3\' does not exist in datastore',
1102 res['output']['configuration-response-common'][
1103 'response-message'])
1104 self.assertIn('500', res['output']['configuration-response-common'][
1108 def test_30_delete_eth_service1(self):
1109 url = ("{}/operations/org-openroadm-service:service-delete"
1110 .format(self.restconf_baseurl))
1112 "sdnc-request-header": {
1113 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1114 "rpc-action": "service-delete",
1115 "request-system-id": "appname",
1117 "http://localhost:8585/NotificationServer/notify"
1119 "service-delete-req-info": {
1120 "service-name": "service1",
1121 "tail-retention": "no"
1125 headers = {'content-type': 'application/json'}
1126 response = requests.request(
1127 "POST", url, data=json.dumps(data), headers=headers,
1128 auth=('admin', 'admin'))
1129 self.assertEqual(response.status_code, requests.codes.ok)
1130 res = response.json()
1131 self.assertIn('Renderer service delete in progress',
1132 res['output']['configuration-response-common'][
1133 'response-message'])
1136 def test_31_delete_eth_service2(self):
1137 url = ("{}/operations/org-openroadm-service:service-delete"
1138 .format(self.restconf_baseurl))
1140 "sdnc-request-header": {
1141 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1142 "rpc-action": "service-delete",
1143 "request-system-id": "appname",
1145 "http://localhost:8585/NotificationServer/notify"
1147 "service-delete-req-info": {
1148 "service-name": "service2",
1149 "tail-retention": "no"
1153 headers = {'content-type': 'application/json'}
1154 response = requests.request(
1155 "POST", url, data=json.dumps(data), headers=headers,
1156 auth=('admin', 'admin'))
1157 self.assertEqual(response.status_code, requests.codes.ok)
1158 res = response.json()
1159 self.assertIn('Renderer service delete in progress',
1160 res['output']['configuration-response-common'][
1161 'response-message'])
1164 def test_32_check_no_xc_ROADMA(self):
1166 "{}/config/network-topology:"
1167 "network-topology/topology/topology-netconf/"
1168 "node/ROADMA01/yang-ext:"
1169 "mount/org-openroadm-device:org-openroadm-device/"
1170 .format(self.restconf_baseurl))
1171 response = requests.request(
1172 "GET", url, auth=('admin', 'admin'))
1173 res = response.json()
1174 self.assertEqual(response.status_code, requests.codes.ok)
1175 self.assertNotIn('roadm-connections',
1176 dict.keys(res['org-openroadm-device']))
1179 def test_33_check_topo_XPDRA(self):
1181 "{}/config/ietf-network:"
1182 "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1183 .format(self.restconf_baseurl))
1184 response = requests.request(
1185 "GET", url1, auth=('admin', 'admin'))
1186 self.assertEqual(response.status_code, requests.codes.ok)
1187 res = response.json()
1188 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1189 for ele in liste_tp:
1190 if ((ele[u'org-openroadm-common-network:tp-type'] ==
1192 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele[
1193 'tp-id'] == 'XPDR1-CLIENT3')):
1195 'org-openroadm-network-topology:xpdr-client-attributes',
1197 elif (ele[u'org-openroadm-common-network:tp-type'] ==
1199 self.assertIn(u'tail-equipment-id', dict.keys(
1200 ele[u'org-openroadm-network-topology:'
1201 u'xpdr-network-attributes']))
1202 self.assertNotIn('wavelength', dict.keys(
1203 ele[u'org-openroadm-network-topology:'
1204 u'xpdr-network-attributes']))
1207 def test_34_check_topo_ROADMA_SRG1(self):
1209 "{}/config/ietf-network:"
1210 "networks/network/openroadm-topology/node/ROADMA01-SRG1"
1211 .format(self.restconf_baseurl))
1212 response = requests.request(
1213 "GET", url1, auth=('admin', 'admin'))
1214 self.assertEqual(response.status_code, requests.codes.ok)
1215 res = response.json()
1216 self.assertIn({u'index': 1}, res['node'][0][
1217 u'org-openroadm-network-topology:srg-attributes'][
1218 'available-wavelengths'])
1219 self.assertIn({u'index': 2}, res['node'][0][
1220 u'org-openroadm-network-topology:srg-attributes'][
1221 'available-wavelengths'])
1222 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1223 for ele in liste_tp:
1224 if ele['tp-id'] == 'SRG1-PP1-TXRX' or \
1225 ele['tp-id'] == 'SRG1-PP1-TXRX':
1226 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
1229 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
1233 def test_35_check_topo_ROADMA_DEG1(self):
1235 "{}/config/ietf-network:"
1236 "networks/network/openroadm-topology/node/ROADMA01-DEG1"
1237 .format(self.restconf_baseurl))
1238 response = requests.request(
1239 "GET", url1, auth=('admin', 'admin'))
1240 self.assertEqual(response.status_code, requests.codes.ok)
1241 res = response.json()
1242 self.assertIn({u'index': 1}, res['node'][0][
1243 u'org-openroadm-network-topology:degree-attributes'][
1244 'available-wavelengths'])
1245 self.assertIn({u'index': 2}, res['node'][0][
1246 u'org-openroadm-network-topology:degree-attributes'][
1247 'available-wavelengths'])
1248 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1249 for ele in liste_tp:
1250 if ele['tp-id'] == 'DEG1-CTP-TXRX':
1251 self.assertNotIn('org-openroadm-network-topology:'
1252 'ctp-attributes', dict.keys(ele))
1253 if ele['tp-id'] == 'DEG1-TTP-TXRX':
1254 self.assertNotIn('org-openroadm-network-topology:'
1255 'tx-ttp-attributes', dict.keys(ele))
1258 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1259 def test_36_create_oc_service1(self):
1260 url = ("{}/operations/org-openroadm-service:service-create"
1261 .format(self.restconf_baseurl))
1264 "sdnc-request-header": {
1265 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1266 "rpc-action": "service-create",
1267 "request-system-id": "appname",
1269 "http://localhost:8585/NotificationServer/notify"
1271 "service-name": "service1",
1272 "common-id": "ASATT1234567",
1273 "connection-type": "roadm-line",
1275 "service-rate": "100",
1276 "node-id": "ROADMA01",
1277 "service-format": "OC",
1278 "clli": "SNJSCAMCJP8",
1282 "ROUTER_SNJSCAMCJP8_000000.00_00",
1283 "port-type": "router",
1284 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1285 "port-rack": "000000.00",
1290 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1291 "lgx-port-name": "LGX Back.3",
1292 "lgx-port-rack": "000000.00",
1293 "lgx-port-shelf": "00"
1299 "ROUTER_SNJSCAMCJP8_000000.00_00",
1300 "port-type": "router",
1301 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1302 "port-rack": "000000.00",
1307 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1308 "lgx-port-name": "LGX Back.4",
1309 "lgx-port-rack": "000000.00",
1310 "lgx-port-shelf": "00"
1313 "optic-type": "gray"
1316 "service-rate": "100",
1317 "node-id": "ROADMC01",
1318 "service-format": "OC",
1319 "clli": "SNJSCAMCJT4",
1323 "ROUTER_SNJSCAMCJT4_000000.00_00",
1324 "port-type": "router",
1325 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1326 "port-rack": "000000.00",
1331 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1332 "lgx-port-name": "LGX Back.29",
1333 "lgx-port-rack": "000000.00",
1334 "lgx-port-shelf": "00"
1340 "ROUTER_SNJSCAMCJT4_000000.00_00",
1341 "port-type": "router",
1342 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1343 "port-rack": "000000.00",
1348 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1349 "lgx-port-name": "LGX Back.30",
1350 "lgx-port-rack": "000000.00",
1351 "lgx-port-shelf": "00"
1354 "optic-type": "gray"
1356 "due-date": "2016-11-28T00:00:01Z",
1357 "operator-contact": "pw1234"
1360 headers = {'content-type': 'application/json',
1361 "Accept": "application/json"}
1362 response = requests.request(
1363 "POST", url, data=json.dumps(data), headers=headers,
1364 auth=('admin', 'admin'))
1365 self.assertEqual(response.status_code, requests.codes.ok)
1366 res = response.json()
1367 self.assertIn('PCE calculation in progress',
1368 res['output']['configuration-response-common'][
1369 'response-message'])
1370 time.sleep(self.WAITING)
1372 def test_37_get_oc_service1(self):
1373 url = ("{}/operational/org-openroadm-service:"
1374 "service-list/services/service1"
1375 .format(self.restconf_baseurl))
1376 headers = {'content-type': 'application/json',
1377 "Accept": "application/json"}
1378 response = requests.request(
1379 "GET", url, headers=headers, auth=('admin', 'admin'))
1380 self.assertEqual(response.status_code, requests.codes.ok)
1381 res = response.json()
1383 res['services'][0]['administrative-state'],
1386 res['services'][0]['service-name'], 'service1')
1388 res['services'][0]['connection-type'], 'roadm-line')
1390 res['services'][0]['lifecycle-state'], 'planned')
1393 def test_38_check_xc1_ROADMA(self):
1395 "{}/config/network-topology:"
1396 "network-topology/topology/topology-netconf/"
1397 "node/ROADMA01/yang-ext:"
1398 "mount/org-openroadm-device:org-openroadm-device/"
1399 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1400 .format(self.restconf_baseurl))
1401 headers = {'content-type': 'application/json'}
1402 response = requests.request(
1403 "GET", url, headers=headers, auth=('admin', 'admin'))
1404 self.assertEqual(response.status_code, requests.codes.ok)
1405 res = response.json()
1406 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1407 self.assertDictEqual(
1409 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1410 'wavelength-number': 1,
1411 'opticalControlMode': 'gainLoss',
1412 'target-output-power': -3.0
1413 }, **res['roadm-connections'][0]),
1414 res['roadm-connections'][0]
1416 self.assertDictEqual(
1417 {'src-if': 'SRG1-PP1-TXRX-1'},
1418 res['roadm-connections'][0]['source'])
1419 self.assertDictEqual(
1420 {'dst-if': 'DEG1-TTP-TXRX-1'},
1421 res['roadm-connections'][0]['destination'])
1424 def test_39_check_xc1_ROADMC(self):
1426 "{}/config/network-topology:"
1427 "network-topology/topology/topology-netconf/"
1428 "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
1429 "org-openroadm-device/"
1430 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1431 .format(self.restconf_baseurl))
1432 headers = {'content-type': 'application/json'}
1433 response = requests.request(
1434 "GET", url, headers=headers, auth=('admin', 'admin'))
1435 self.assertEqual(response.status_code, requests.codes.ok)
1436 res = response.json()
1437 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1438 self.assertDictEqual(
1440 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1441 'wavelength-number': 1,
1442 'opticalControlMode': 'gainLoss',
1443 'target-output-power': 2.0
1444 }, **res['roadm-connections'][0]),
1445 res['roadm-connections'][0]
1447 self.assertDictEqual(
1448 {'src-if': 'SRG1-PP1-TXRX-1'},
1449 res['roadm-connections'][0]['source'])
1450 self.assertDictEqual(
1451 {'dst-if': 'DEG2-TTP-TXRX-1'},
1452 res['roadm-connections'][0]['destination'])
1455 def test_40_create_oc_service2(self):
1456 url = ("{}/operations/org-openroadm-service:service-create"
1457 .format(self.restconf_baseurl))
1460 "sdnc-request-header": {
1461 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1462 "rpc-action": "service-create",
1463 "request-system-id": "appname",
1465 "http://localhost:8585/NotificationServer/notify"
1467 "service-name": "service2",
1468 "common-id": "ASATT1234567",
1469 "connection-type": "roadm-line",
1471 "service-rate": "100",
1472 "node-id": "ROADMA01",
1473 "service-format": "OC",
1474 "clli": "SNJSCAMCJP8",
1478 "ROUTER_SNJSCAMCJP8_000000.00_00",
1479 "port-type": "router",
1480 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1481 "port-rack": "000000.00",
1486 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1487 "lgx-port-name": "LGX Back.3",
1488 "lgx-port-rack": "000000.00",
1489 "lgx-port-shelf": "00"
1495 "ROUTER_SNJSCAMCJP8_000000.00_00",
1496 "port-type": "router",
1497 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1498 "port-rack": "000000.00",
1503 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1504 "lgx-port-name": "LGX Back.4",
1505 "lgx-port-rack": "000000.00",
1506 "lgx-port-shelf": "00"
1509 "optic-type": "gray"
1512 "service-rate": "100",
1513 "node-id": "ROADMC01",
1514 "service-format": "OC",
1515 "clli": "SNJSCAMCJT4",
1519 "ROUTER_SNJSCAMCJT4_000000.00_00",
1520 "port-type": "router",
1521 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1522 "port-rack": "000000.00",
1527 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1528 "lgx-port-name": "LGX Back.29",
1529 "lgx-port-rack": "000000.00",
1530 "lgx-port-shelf": "00"
1536 "ROUTER_SNJSCAMCJT4_000000.00_00",
1537 "port-type": "router",
1538 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1539 "port-rack": "000000.00",
1544 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1545 "lgx-port-name": "LGX Back.30",
1546 "lgx-port-rack": "000000.00",
1547 "lgx-port-shelf": "00"
1550 "optic-type": "gray"
1552 "due-date": "2016-11-28T00:00:01Z",
1553 "operator-contact": "pw1234"
1556 headers = {'content-type': 'application/json',
1557 "Accept": "application/json"}
1558 response = requests.request(
1559 "POST", url, data=json.dumps(data), headers=headers,
1560 auth=('admin', 'admin'))
1561 self.assertEqual(response.status_code, requests.codes.ok)
1562 res = response.json()
1563 self.assertIn('PCE calculation in progress',
1564 res['output']['configuration-response-common'][
1565 'response-message'])
1566 time.sleep(self.WAITING)
1568 def test_41_get_oc_service2(self):
1569 url = ("{}/operational/org-openroadm-service:"
1570 "service-list/services/service2"
1571 .format(self.restconf_baseurl))
1572 headers = {'content-type': 'application/json',
1573 "Accept": "application/json"}
1574 response = requests.request(
1575 "GET", url, headers=headers, auth=('admin', 'admin'))
1576 self.assertEqual(response.status_code, requests.codes.ok)
1577 res = response.json()
1579 res['services'][0]['administrative-state'],
1582 res['services'][0]['service-name'], 'service2')
1584 res['services'][0]['connection-type'], 'roadm-line')
1586 res['services'][0]['lifecycle-state'], 'planned')
1589 def test_42_check_xc2_ROADMA(self):
1591 "{}/config/network-topology:"
1592 "network-topology/topology/topology-netconf/"
1593 "node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1594 "org-openroadm-device/"
1595 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1596 .format(self.restconf_baseurl))
1597 headers = {'content-type': 'application/json'}
1598 response = requests.request(
1599 "GET", url, headers=headers, auth=('admin', 'admin'))
1600 self.assertEqual(response.status_code, requests.codes.ok)
1601 res = response.json()
1602 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
1603 self.assertDictEqual(
1605 'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1606 'wavelength-number': 2,
1607 'opticalControlMode': 'gainLoss',
1608 'target-output-power': -3.0
1609 }, **res['roadm-connections'][0]),
1610 res['roadm-connections'][0]
1612 self.assertDictEqual(
1613 {'src-if': 'SRG1-PP2-TXRX-2'},
1614 res['roadm-connections'][0]['source'])
1615 self.assertDictEqual(
1616 {'dst-if': 'DEG1-TTP-TXRX-2'},
1617 res['roadm-connections'][0]['destination'])
1620 def test_43_check_topo_ROADMA(self):
1621 self.test_26_check_topo_ROADMA_SRG1()
1622 self.test_27_check_topo_ROADMA_DEG1()
1625 def test_44_delete_oc_service1(self):
1626 url = ("{}/operations/org-openroadm-service:service-delete"
1627 .format(self.restconf_baseurl))
1629 "sdnc-request-header": {
1630 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1631 "rpc-action": "service-delete",
1632 "request-system-id": "appname",
1634 "http://localhost:8585/NotificationServer/notify"
1636 "service-delete-req-info": {
1637 "service-name": "service1",
1638 "tail-retention": "no"
1642 headers = {'content-type': 'application/json'}
1643 response = requests.request(
1644 "POST", url, data=json.dumps(data), headers=headers,
1645 auth=('admin', 'admin'))
1646 self.assertEqual(response.status_code, requests.codes.ok)
1647 res = response.json()
1648 self.assertIn('Renderer service delete in progress',
1649 res['output']['configuration-response-common'][
1650 'response-message'])
1653 def test_45_delete_oc_service2(self):
1654 url = ("{}/operations/org-openroadm-service:service-delete"
1655 .format(self.restconf_baseurl))
1657 "sdnc-request-header": {
1658 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1659 "rpc-action": "service-delete",
1660 "request-system-id": "appname",
1662 "http://localhost:8585/NotificationServer/notify"
1664 "service-delete-req-info": {
1665 "service-name": "service2",
1666 "tail-retention": "no"
1670 headers = {'content-type': 'application/json'}
1671 response = requests.request(
1672 "POST", url, data=json.dumps(data), headers=headers,
1673 auth=('admin', 'admin'))
1674 self.assertEqual(response.status_code, requests.codes.ok)
1675 res = response.json()
1676 self.assertIn('Renderer service delete in progress',
1677 res['output']['configuration-response-common'][
1678 'response-message'])
1681 def test_46_get_no_oc_services(self):
1683 url = ("{}/operational/org-openroadm-service:service-list"
1684 .format(self.restconf_baseurl))
1685 headers = {'content-type': 'application/json',
1686 "Accept": "application/json"}
1687 response = requests.request(
1688 "GET", url, headers=headers, auth=('admin', 'admin'))
1689 self.assertEqual(response.status_code, requests.codes.not_found)
1690 res = response.json()
1693 "error-type": "application",
1694 "error-tag": "data-missing",
1696 "Request could not be completed because the relevant data "
1697 "model content does not exist"
1699 res['errors']['error'])
1702 def test_47_get_no_xc_ROADMA(self):
1704 "{}/config/network-topology:"
1705 "network-topology/topology/topology-netconf"
1706 "/node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1707 "org-openroadm-device/"
1708 .format(self.restconf_baseurl))
1709 headers = {'content-type': 'application/json',
1710 "Accept": "application/json"}
1711 response = requests.request(
1712 "GET", url, headers=headers, auth=('admin', 'admin'))
1713 self.assertEqual(response.status_code, requests.codes.ok)
1714 res = response.json()
1715 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1718 def test_48_check_topo_ROADMA(self):
1719 self.test_34_check_topo_ROADMA_SRG1()
1720 self.test_35_check_topo_ROADMA_DEG1()
1722 def test_49_loop_create_eth_service(self):
1723 for i in range(1, 6):
1724 print("trial number {}".format(i))
1725 print("eth service creation")
1726 self.test_11_create_eth_service1()
1727 print("check xc in ROADMA01")
1728 self.test_13_check_xc1_ROADMA()
1729 print("check xc in ROADMC01")
1730 self.test_14_check_xc1_ROADMC()
1731 print("eth service deletion\n")
1732 self.test_30_delete_eth_service1()
1734 def test_50_loop_create_oc_service(self):
1735 url = ("{}/operational/org-openroadm-service:"
1736 "service-list/services/service1"
1737 .format(self.restconf_baseurl))
1738 response = requests.request("GET", url, auth=('admin', 'admin'))
1739 if response.status_code != 404:
1740 url = ("{}/operations/org-openroadm-service:service-delete"
1741 .format(self.restconf_baseurl))
1743 "sdnc-request-header": {
1744 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1745 "rpc-action": "service-delete",
1746 "request-system-id": "appname",
1748 "http://localhost:8585/NotificationServer/notify"
1750 "service-delete-req-info": {
1751 "service-name": "service1",
1752 "tail-retention": "no"
1756 headers = {'content-type': 'application/json'}
1757 requests.request("POST", url, data=json.dumps(data),
1759 auth=('admin', 'admin')
1763 for i in range(1, 6):
1764 print("trial number {}".format(i))
1765 print("oc service creation")
1766 self.test_36_create_oc_service1()
1767 print("check xc in ROADMA01")
1768 self.test_38_check_xc1_ROADMA()
1769 print("check xc in ROADMC01")
1770 self.test_39_check_xc1_ROADMC()
1771 print("oc service deletion\n")
1772 self.test_44_delete_oc_service1()
1774 def test_51_disconnect_XPDRA(self):
1775 url = ("{}/config/network-topology:"
1776 "network-topology/topology/topology-netconf/node/XPDRA01"
1777 .format(self.restconf_baseurl))
1778 headers = {'content-type': 'application/json'}
1779 response = requests.request(
1780 "DELETE", url, headers=headers,
1781 auth=('admin', 'admin'))
1782 self.assertEqual(response.status_code, requests.codes.ok)
1785 def test_52_disconnect_XPDRC(self):
1786 url = ("{}/config/network-topology:"
1787 "network-topology/topology/topology-netconf/node/XPDRC01"
1788 .format(self.restconf_baseurl))
1789 headers = {'content-type': 'application/json'}
1790 response = requests.request(
1791 "DELETE", url, headers=headers,
1792 auth=('admin', 'admin'))
1793 self.assertEqual(response.status_code, requests.codes.ok)
1796 def test_53_disconnect_ROADMA(self):
1797 url = ("{}/config/network-topology:"
1798 "network-topology/topology/topology-netconf/node/ROADMA01"
1799 .format(self.restconf_baseurl))
1800 headers = {'content-type': 'application/json'}
1801 response = requests.request(
1802 "DELETE", url, headers=headers,
1803 auth=('admin', 'admin'))
1804 self.assertEqual(response.status_code, requests.codes.ok)
1807 def test_54_disconnect_ROADMC(self):
1808 url = ("{}/config/network-topology:"
1809 "network-topology/topology/topology-netconf/node/ROADMC01"
1810 .format(self.restconf_baseurl))
1811 headers = {'content-type': 'application/json'}
1812 response = requests.request(
1813 "DELETE", url, headers=headers,
1814 auth=('admin', 'admin'))
1815 self.assertEqual(response.status_code, requests.codes.ok)
1819 if __name__ == "__main__":
1820 unittest.main(verbosity=2)