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 self.assertDictContainsSubset(
469 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
470 'wavelength-number': 1,
471 'opticalControlMode': 'gainLoss',
472 'target-output-power': -3.0},
473 res['roadm-connections'][0])
474 self.assertDictEqual(
475 {'src-if': 'SRG1-PP1-TXRX-1'},
476 res['roadm-connections'][0]['source'])
477 self.assertDictEqual(
478 {'dst-if': 'DEG1-TTP-TXRX-1'},
479 res['roadm-connections'][0]['destination'])
482 def test_14_check_xc1_ROADMC(self):
484 "{}/config/network-topology:"
485 "network-topology/topology/topology-netconf/"
486 "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
487 "org-openroadm-device/"
488 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
489 .format(self.restconf_baseurl))
490 headers = {'content-type': 'application/json'}
491 response = requests.request(
492 "GET", url, headers=headers, auth=('admin', 'admin'))
493 self.assertEqual(response.status_code, requests.codes.ok)
494 res = response.json()
495 self.assertDictContainsSubset(
496 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
497 'wavelength-number': 1,
498 'opticalControlMode': 'gainLoss',
499 'target-output-power': 2.0},
500 res['roadm-connections'][0])
501 self.assertDictEqual(
502 {'src-if': 'SRG1-PP1-TXRX-1'},
503 res['roadm-connections'][0]['source'])
504 self.assertDictEqual(
505 {'dst-if': 'DEG2-TTP-TXRX-1'},
506 res['roadm-connections'][0]['destination'])
509 def test_15_check_topo_XPDRA(self):
511 "{}/config/ietf-network:"
512 "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
513 .format(self.restconf_baseurl))
514 response = requests.request(
515 "GET", url1, auth=('admin', 'admin'))
516 self.assertEqual(response.status_code, requests.codes.ok)
517 res = response.json()
518 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
520 if ele['tp-id'] == 'XPDR1-NETWORK1':
521 self.assertEqual({u'frequency': 196.1, u'width': 40},
523 'org-openroadm-network-topology:'
524 'xpdr-network-attributes'][
526 if ele['tp-id'] == 'XPDR1-CLIENT1' or \
527 ele['tp-id'] == 'XPDR1-CLIENT3':
529 'org-openroadm-network-topology:xpdr-client-attributes',
531 if ele['tp-id'] == 'XPDR1-NETWORK2':
533 'org-openroadm-network-topology:xpdr-network-attributes',
537 def test_16_check_topo_ROADMA_SRG1(self):
539 "{}/config/ietf-network:"
540 "networks/network/openroadm-topology/node/ROADMA01-SRG1"
541 .format(self.restconf_baseurl))
542 response = requests.request(
543 "GET", url1, auth=('admin', 'admin'))
544 self.assertEqual(response.status_code, requests.codes.ok)
545 res = response.json()
546 self.assertNotIn({u'index': 1},
548 u'org-openroadm-network-topology:srg-attributes'][
549 'available-wavelengths'])
550 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
552 if ele['tp-id'] == 'SRG1-PP1-TXRX':
553 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
554 ele['org-openroadm-network-topology:'
555 'pp-attributes']['used-wavelength']
557 if ele['tp-id'] == 'SRG1-PP2-TXRX':
558 self.assertNotIn('used-wavelength', dict.keys(ele))
561 def test_17_check_topo_ROADMA_DEG1(self):
563 "{}/config/ietf-network:"
564 "networks/network/openroadm-topology/node/ROADMA01-DEG1"
565 .format(self.restconf_baseurl))
566 response = requests.request(
567 "GET", url1, auth=('admin', 'admin'))
568 self.assertEqual(response.status_code, requests.codes.ok)
569 res = response.json()
570 self.assertNotIn({u'index': 1},
572 u'org-openroadm-network-topology:'
573 u'degree-attributes'][
574 'available-wavelengths'])
575 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
577 if ele['tp-id'] == 'DEG1-CTP-TXRX':
578 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
579 ele['org-openroadm-network-topology:'
582 if ele['tp-id'] == 'DEG1-TTP-TXRX':
583 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
584 ele['org-openroadm-network-topology:'
585 'tx-ttp-attributes'][
589 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
590 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
591 format(self.restconf_baseurl)
593 "networkutils:input": {
594 "networkutils:links-input": {
595 "networkutils:xpdr-node": "XPDRA01",
596 "networkutils:xpdr-num": "1",
597 "networkutils:network-num": "2",
598 "networkutils:rdm-node": "ROADMA01",
599 "networkutils:srg-num": "1",
600 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
604 headers = {'content-type': 'application/json'}
605 response = requests.request(
606 "POST", url, data=json.dumps(data),
607 headers=headers, auth=('admin', 'admin'))
608 self.assertEqual(response.status_code, requests.codes.ok)
609 res = response.json()
610 self.assertIn('Xponder Roadm Link created successfully',
611 res["output"]["result"])
614 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
615 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
616 format(self.restconf_baseurl)
618 "networkutils:input": {
619 "networkutils:links-input": {
620 "networkutils:xpdr-node": "XPDRA01",
621 "networkutils:xpdr-num": "1",
622 "networkutils:network-num": "2",
623 "networkutils:rdm-node": "ROADMA01",
624 "networkutils:srg-num": "1",
625 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
629 headers = {'content-type': 'application/json'}
630 response = requests.request(
631 "POST", url, data=json.dumps(data),
632 headers=headers, auth=('admin', 'admin'))
633 self.assertEqual(response.status_code, requests.codes.ok)
634 res = response.json()
635 self.assertIn('Roadm Xponder links created successfully',
636 res["output"]["result"])
639 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
640 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".\
641 format(self.restconf_baseurl)
643 "networkutils:input": {
644 "networkutils:links-input": {
645 "networkutils:xpdr-node": "XPDRC01",
646 "networkutils:xpdr-num": "1",
647 "networkutils:network-num": "2",
648 "networkutils:rdm-node": "ROADMC01",
649 "networkutils:srg-num": "1",
650 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
654 headers = {'content-type': 'application/json'}
655 response = requests.request(
656 "POST", url, data=json.dumps(data),
657 headers=headers, auth=('admin', 'admin'))
658 self.assertEqual(response.status_code, requests.codes.ok)
659 res = response.json()
660 self.assertIn('Xponder Roadm Link created successfully',
661 res["output"]["result"])
664 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
665 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".\
666 format(self.restconf_baseurl)
668 "networkutils:input": {
669 "networkutils:links-input": {
670 "networkutils:xpdr-node": "XPDRC01",
671 "networkutils:xpdr-num": "1",
672 "networkutils:network-num": "2",
673 "networkutils:rdm-node": "ROADMC01",
674 "networkutils:srg-num": "1",
675 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
679 headers = {'content-type': 'application/json'}
680 response = requests.request(
681 "POST", url, data=json.dumps(data),
682 headers=headers, auth=('admin', 'admin'))
683 self.assertEqual(response.status_code, requests.codes.ok)
684 res = response.json()
685 self.assertIn('Roadm Xponder links created successfully',
686 res["output"]["result"])
689 def test_22_create_eth_service2(self):
690 url = ("{}/operations/org-openroadm-service:service-create"
691 .format(self.restconf_baseurl))
694 "sdnc-request-header": {
695 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
696 "rpc-action": "service-create",
697 "request-system-id": "appname",
699 "http://localhost:8585/NotificationServer/notify"
701 "service-name": "service2",
702 "common-id": "ASATT1234567",
703 "connection-type": "service",
705 "service-rate": "100",
706 "node-id": "XPDRA01",
707 "service-format": "Ethernet",
708 "clli": "SNJSCAMCJP8",
712 "ROUTER_SNJSCAMCJP8_000000.00_00",
713 "port-type": "router",
714 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
715 "port-rack": "000000.00",
720 "LGX Panel_SNJSCAMCJP8_000000.00_00",
721 "lgx-port-name": "LGX Back.3",
722 "lgx-port-rack": "000000.00",
723 "lgx-port-shelf": "00"
729 "ROUTER_SNJSCAMCJP8_000000.00_00",
730 "port-type": "router",
731 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
732 "port-rack": "000000.00",
737 "LGX Panel_SNJSCAMCJP8_000000.00_00",
738 "lgx-port-name": "LGX Back.4",
739 "lgx-port-rack": "000000.00",
740 "lgx-port-shelf": "00"
746 "service-rate": "100",
747 "node-id": "XPDRC01",
748 "service-format": "Ethernet",
749 "clli": "SNJSCAMCJT4",
753 "ROUTER_SNJSCAMCJT4_000000.00_00",
754 "port-type": "router",
755 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
756 "port-rack": "000000.00",
761 "LGX Panel_SNJSCAMCJT4_000000.00_00",
762 "lgx-port-name": "LGX Back.29",
763 "lgx-port-rack": "000000.00",
764 "lgx-port-shelf": "00"
770 "ROUTER_SNJSCAMCJT4_000000.00_00",
771 "port-type": "router",
772 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
773 "port-rack": "000000.00",
778 "LGX Panel_SNJSCAMCJT4_000000.00_00",
779 "lgx-port-name": "LGX Back.30",
780 "lgx-port-rack": "000000.00",
781 "lgx-port-shelf": "00"
786 "due-date": "2016-11-28T00:00:01Z",
787 "operator-contact": "pw1234"
790 headers = {'content-type': 'application/json',
791 "Accept": "application/json"}
792 response = requests.request(
793 "POST", url, data=json.dumps(data), headers=headers,
794 auth=('admin', 'admin'))
795 self.assertEqual(response.status_code, requests.codes.ok)
796 res = response.json()
797 self.assertIn('PCE calculation in progress',
798 res['output']['configuration-response-common'][
800 time.sleep(self.WAITING)
802 def test_23_get_eth_service2(self):
803 url = ("{}/operational/org-openroadm-service:"
804 "service-list/services/service2"
805 .format(self.restconf_baseurl))
806 headers = {'content-type': 'application/json',
807 "Accept": "application/json"}
808 response = requests.request(
809 "GET", url, headers=headers, auth=('admin', 'admin'))
810 self.assertEqual(response.status_code, requests.codes.ok)
811 res = response.json()
813 res['services'][0]['administrative-state'],
816 res['services'][0]['service-name'], 'service2')
818 res['services'][0]['connection-type'], 'service')
820 res['services'][0]['lifecycle-state'], 'planned')
823 def test_24_check_xc2_ROADMA(self):
825 "{}/config/network-topology:"
826 "network-topology/topology/topology-netconf/"
827 "node/ROADMA01/yang-ext:"
828 "mount/org-openroadm-device:org-openroadm-device/"
829 "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
830 .format(self.restconf_baseurl))
831 headers = {'content-type': 'application/json'}
832 response = requests.request(
833 "GET", url, headers=headers, auth=('admin', 'admin'))
834 self.assertEqual(response.status_code, requests.codes.ok)
835 res = response.json()
836 self.assertDictContainsSubset(
837 {'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
838 'wavelength-number': 2,
839 'opticalControlMode': 'power'},
840 res['roadm-connections'][0])
841 self.assertDictEqual(
842 {'src-if': 'DEG1-TTP-TXRX-2'},
843 res['roadm-connections'][0]['source'])
844 self.assertDictEqual(
845 {'dst-if': 'SRG1-PP2-TXRX-2'},
846 res['roadm-connections'][0]['destination'])
848 def test_25_check_topo_XPDRA(self):
850 "{}/config/ietf-network:"
851 "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
852 .format(self.restconf_baseurl))
853 response = requests.request(
854 "GET", url1, auth=('admin', 'admin'))
855 self.assertEqual(response.status_code, requests.codes.ok)
856 res = response.json()
857 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
859 if ele['tp-id'] == 'XPDR1-NETWORK1':
860 self.assertEqual({u'frequency': 196.1, u'width': 40},
861 ele['org-openroadm-network-topology:'
862 'xpdr-network-attributes'][
864 if ele['tp-id'] == 'XPDR1-NETWORK2':
865 self.assertEqual({u'frequency': 196.05, u'width': 40},
866 ele['org-openroadm-network-topology:'
867 'xpdr-network-attributes'][
869 if ele['tp-id'] == 'XPDR1-CLIENT1' or \
870 ele['tp-id'] == 'XPDR1-CLIENT3':
872 'org-openroadm-network-topology:xpdr-client-attributes',
876 def test_26_check_topo_ROADMA_SRG1(self):
878 "{}/config/ietf-network:"
879 "networks/network/openroadm-topology/node/ROADMA01-SRG1"
880 .format(self.restconf_baseurl))
881 response = requests.request(
882 "GET", url1, auth=('admin', 'admin'))
883 self.assertEqual(response.status_code, requests.codes.ok)
884 res = response.json()
885 self.assertNotIn({u'index': 1}, res['node'][0][
886 u'org-openroadm-network-topology:srg-attributes'][
887 'available-wavelengths'])
888 self.assertNotIn({u'index': 2}, res['node'][0][
889 u'org-openroadm-network-topology:srg-attributes'][
890 'available-wavelengths'])
891 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
893 if ele['tp-id'] == 'SRG1-PP1-TXRX':
894 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
895 ele['org-openroadm-network-topology:'
896 'pp-attributes']['used-wavelength'])
897 self.assertNotIn({u'index': 2, u'frequency': 196.05,
899 ele['org-openroadm-network-topology:'
900 'pp-attributes']['used-wavelength'])
901 if ele['tp-id'] == 'SRG1-PP2-TXRX':
902 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
903 ele['org-openroadm-network-topology:'
904 'pp-attributes']['used-wavelength'])
905 self.assertNotIn({u'index': 1, u'frequency': 196.1,
907 ele['org-openroadm-network-topology:'
908 'pp-attributes']['used-wavelength'])
909 if ele['tp-id'] == 'SRG1-PP3-TXRX':
910 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
914 def test_27_check_topo_ROADMA_DEG1(self):
916 "{}/config/ietf-network:"
917 "networks/network/openroadm-topology/node/ROADMA01-DEG1"
918 .format(self.restconf_baseurl))
919 response = requests.request(
920 "GET", url1, auth=('admin', 'admin'))
921 self.assertEqual(response.status_code, requests.codes.ok)
922 res = response.json()
923 self.assertNotIn({u'index': 1}, res['node'][0][
924 u'org-openroadm-network-topology:degree-attributes'][
925 'available-wavelengths'])
926 self.assertNotIn({u'index': 2}, res['node'][0][
927 u'org-openroadm-network-topology:degree-attributes'][
928 'available-wavelengths'])
929 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
931 if ele['tp-id'] == 'DEG1-CTP-TXRX':
932 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
933 ele['org-openroadm-network-topology:'
934 'ctp-attributes']['used-wavelengths'])
935 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
936 ele['org-openroadm-network-topology:'
937 'ctp-attributes']['used-wavelengths'])
938 if ele['tp-id'] == 'DEG1-TTP-TXRX':
939 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
940 ele['org-openroadm-network-topology:'
941 'tx-ttp-attributes']['used-wavelengths'])
942 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
943 ele['org-openroadm-network-topology:'
944 'tx-ttp-attributes']['used-wavelengths'])
947 # creation service test on a non-available resource
948 def test_28_create_eth_service3(self):
949 url = ("{}/operations/org-openroadm-service:service-create"
950 .format(self.restconf_baseurl))
953 "sdnc-request-header": {
954 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
955 "rpc-action": "service-create",
956 "request-system-id": "appname",
958 "http://localhost:8585/NotificationServer/notify"
960 "service-name": "service3",
961 "common-id": "ASATT1234567",
962 "connection-type": "service",
964 "service-rate": "100",
965 "node-id": "XPDRA01",
966 "service-format": "Ethernet",
967 "clli": "SNJSCAMCJP8",
971 "ROUTER_SNJSCAMCJP8_000000.00_00",
972 "port-type": "router",
973 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
974 "port-rack": "000000.00",
979 "LGX Panel_SNJSCAMCJP8_000000.00_00",
980 "lgx-port-name": "LGX Back.3",
981 "lgx-port-rack": "000000.00",
982 "lgx-port-shelf": "00"
988 "ROUTER_SNJSCAMCJP8_000000.00_00",
989 "port-type": "router",
990 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
991 "port-rack": "000000.00",
996 "LGX Panel_SNJSCAMCJP8_000000.00_00",
997 "lgx-port-name": "LGX Back.4",
998 "lgx-port-rack": "000000.00",
999 "lgx-port-shelf": "00"
1002 "optic-type": "gray"
1005 "service-rate": "100",
1006 "node-id": "XPDRC01",
1007 "service-format": "Ethernet",
1008 "clli": "SNJSCAMCJT4",
1012 "ROUTER_SNJSCAMCJT4_000000.00_00",
1013 "port-type": "router",
1014 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1015 "port-rack": "000000.00",
1020 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1021 "lgx-port-name": "LGX Back.29",
1022 "lgx-port-rack": "000000.00",
1023 "lgx-port-shelf": "00"
1029 "ROUTER_SNJSCAMCJT4_000000.00_00",
1030 "port-type": "router",
1031 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1032 "port-rack": "000000.00",
1037 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1038 "lgx-port-name": "LGX Back.30",
1039 "lgx-port-rack": "000000.00",
1040 "lgx-port-shelf": "00"
1043 "optic-type": "gray"
1045 "due-date": "2016-11-28T00:00:01Z",
1046 "operator-contact": "pw1234"
1049 headers = {'content-type': 'application/json',
1050 "Accept": "application/json"}
1051 response = requests.request(
1052 "POST", url, data=json.dumps(data), headers=headers,
1053 auth=('admin', 'admin'))
1054 self.assertEqual(response.status_code, requests.codes.ok)
1055 res = response.json()
1056 self.assertIn('PCE calculation in progress',
1057 res['output']['configuration-response-common'][
1058 'response-message'])
1059 self.assertIn('200', res['output']['configuration-response-common'][
1061 time.sleep(self.WAITING)
1063 # add a test that check the openroadm-service-list still only
1064 # contains 2 elements
1066 def test_29_delete_eth_service3(self):
1067 url = ("{}/operations/org-openroadm-service:service-delete"
1068 .format(self.restconf_baseurl))
1070 "sdnc-request-header": {
1071 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1072 "rpc-action": "service-delete",
1073 "request-system-id": "appname",
1075 "http://localhost:8585/NotificationServer/notify"
1077 "service-delete-req-info": {
1078 "service-name": "service3",
1079 "tail-retention": "no"
1083 headers = {'content-type': 'application/json'}
1084 response = requests.request(
1085 "POST", url, data=json.dumps(data), headers=headers,
1086 auth=('admin', 'admin'))
1087 self.assertEqual(response.status_code, requests.codes.ok)
1088 res = response.json()
1089 self.assertIn('Service \'service3\' does not exist in datastore',
1090 res['output']['configuration-response-common'][
1091 'response-message'])
1092 self.assertIn('500', res['output']['configuration-response-common'][
1096 def test_30_delete_eth_service1(self):
1097 url = ("{}/operations/org-openroadm-service:service-delete"
1098 .format(self.restconf_baseurl))
1100 "sdnc-request-header": {
1101 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1102 "rpc-action": "service-delete",
1103 "request-system-id": "appname",
1105 "http://localhost:8585/NotificationServer/notify"
1107 "service-delete-req-info": {
1108 "service-name": "service1",
1109 "tail-retention": "no"
1113 headers = {'content-type': 'application/json'}
1114 response = requests.request(
1115 "POST", url, data=json.dumps(data), headers=headers,
1116 auth=('admin', 'admin'))
1117 self.assertEqual(response.status_code, requests.codes.ok)
1118 res = response.json()
1119 self.assertIn('Renderer service delete in progress',
1120 res['output']['configuration-response-common'][
1121 'response-message'])
1124 def test_31_delete_eth_service2(self):
1125 url = ("{}/operations/org-openroadm-service:service-delete"
1126 .format(self.restconf_baseurl))
1128 "sdnc-request-header": {
1129 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1130 "rpc-action": "service-delete",
1131 "request-system-id": "appname",
1133 "http://localhost:8585/NotificationServer/notify"
1135 "service-delete-req-info": {
1136 "service-name": "service2",
1137 "tail-retention": "no"
1141 headers = {'content-type': 'application/json'}
1142 response = requests.request(
1143 "POST", url, data=json.dumps(data), headers=headers,
1144 auth=('admin', 'admin'))
1145 self.assertEqual(response.status_code, requests.codes.ok)
1146 res = response.json()
1147 self.assertIn('Renderer service delete in progress',
1148 res['output']['configuration-response-common'][
1149 'response-message'])
1152 def test_32_check_no_xc_ROADMA(self):
1154 "{}/config/network-topology:"
1155 "network-topology/topology/topology-netconf/"
1156 "node/ROADMA01/yang-ext:"
1157 "mount/org-openroadm-device:org-openroadm-device/"
1158 .format(self.restconf_baseurl))
1159 response = requests.request(
1160 "GET", url, auth=('admin', 'admin'))
1161 res = response.json()
1162 self.assertEqual(response.status_code, requests.codes.ok)
1163 self.assertNotIn('roadm-connections',
1164 dict.keys(res['org-openroadm-device']))
1167 def test_33_check_topo_XPDRA(self):
1169 "{}/config/ietf-network:"
1170 "networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1171 .format(self.restconf_baseurl))
1172 response = requests.request(
1173 "GET", url1, auth=('admin', 'admin'))
1174 self.assertEqual(response.status_code, requests.codes.ok)
1175 res = response.json()
1176 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1177 for ele in liste_tp:
1178 if ((ele[u'org-openroadm-common-network:tp-type'] ==
1180 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele[
1181 'tp-id'] == 'XPDR1-CLIENT3')):
1183 'org-openroadm-network-topology:xpdr-client-attributes',
1185 elif (ele[u'org-openroadm-common-network:tp-type'] ==
1187 self.assertIn(u'tail-equipment-id', dict.keys(
1188 ele[u'org-openroadm-network-topology:'
1189 u'xpdr-network-attributes']))
1190 self.assertNotIn('wavelength', dict.keys(
1191 ele[u'org-openroadm-network-topology:'
1192 u'xpdr-network-attributes']))
1195 def test_34_check_topo_ROADMA_SRG1(self):
1197 "{}/config/ietf-network:"
1198 "networks/network/openroadm-topology/node/ROADMA01-SRG1"
1199 .format(self.restconf_baseurl))
1200 response = requests.request(
1201 "GET", url1, auth=('admin', 'admin'))
1202 self.assertEqual(response.status_code, requests.codes.ok)
1203 res = response.json()
1204 self.assertIn({u'index': 1}, res['node'][0][
1205 u'org-openroadm-network-topology:srg-attributes'][
1206 'available-wavelengths'])
1207 self.assertIn({u'index': 2}, res['node'][0][
1208 u'org-openroadm-network-topology:srg-attributes'][
1209 'available-wavelengths'])
1210 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1211 for ele in liste_tp:
1212 if ele['tp-id'] == 'SRG1-PP1-TXRX' or \
1213 ele['tp-id'] == 'SRG1-PP1-TXRX':
1214 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
1217 self.assertNotIn('org-openroadm-network-topology:pp-attributes',
1221 def test_35_check_topo_ROADMA_DEG1(self):
1223 "{}/config/ietf-network:"
1224 "networks/network/openroadm-topology/node/ROADMA01-DEG1"
1225 .format(self.restconf_baseurl))
1226 response = requests.request(
1227 "GET", url1, auth=('admin', 'admin'))
1228 self.assertEqual(response.status_code, requests.codes.ok)
1229 res = response.json()
1230 self.assertIn({u'index': 1}, res['node'][0][
1231 u'org-openroadm-network-topology:degree-attributes'][
1232 'available-wavelengths'])
1233 self.assertIn({u'index': 2}, res['node'][0][
1234 u'org-openroadm-network-topology:degree-attributes'][
1235 'available-wavelengths'])
1236 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1237 for ele in liste_tp:
1238 if ele['tp-id'] == 'DEG1-CTP-TXRX':
1239 self.assertNotIn('org-openroadm-network-topology:'
1240 'ctp-attributes', dict.keys(ele))
1241 if ele['tp-id'] == 'DEG1-TTP-TXRX':
1242 self.assertNotIn('org-openroadm-network-topology:'
1243 'tx-ttp-attributes', dict.keys(ele))
1246 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1247 def test_36_create_oc_service1(self):
1248 url = ("{}/operations/org-openroadm-service:service-create"
1249 .format(self.restconf_baseurl))
1252 "sdnc-request-header": {
1253 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1254 "rpc-action": "service-create",
1255 "request-system-id": "appname",
1257 "http://localhost:8585/NotificationServer/notify"
1259 "service-name": "service1",
1260 "common-id": "ASATT1234567",
1261 "connection-type": "roadm-line",
1263 "service-rate": "100",
1264 "node-id": "ROADMA01",
1265 "service-format": "OC",
1266 "clli": "SNJSCAMCJP8",
1270 "ROUTER_SNJSCAMCJP8_000000.00_00",
1271 "port-type": "router",
1272 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1273 "port-rack": "000000.00",
1278 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1279 "lgx-port-name": "LGX Back.3",
1280 "lgx-port-rack": "000000.00",
1281 "lgx-port-shelf": "00"
1287 "ROUTER_SNJSCAMCJP8_000000.00_00",
1288 "port-type": "router",
1289 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1290 "port-rack": "000000.00",
1295 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1296 "lgx-port-name": "LGX Back.4",
1297 "lgx-port-rack": "000000.00",
1298 "lgx-port-shelf": "00"
1301 "optic-type": "gray"
1304 "service-rate": "100",
1305 "node-id": "ROADMC01",
1306 "service-format": "OC",
1307 "clli": "SNJSCAMCJT4",
1311 "ROUTER_SNJSCAMCJT4_000000.00_00",
1312 "port-type": "router",
1313 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1314 "port-rack": "000000.00",
1319 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1320 "lgx-port-name": "LGX Back.29",
1321 "lgx-port-rack": "000000.00",
1322 "lgx-port-shelf": "00"
1328 "ROUTER_SNJSCAMCJT4_000000.00_00",
1329 "port-type": "router",
1330 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1331 "port-rack": "000000.00",
1336 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1337 "lgx-port-name": "LGX Back.30",
1338 "lgx-port-rack": "000000.00",
1339 "lgx-port-shelf": "00"
1342 "optic-type": "gray"
1344 "due-date": "2016-11-28T00:00:01Z",
1345 "operator-contact": "pw1234"
1348 headers = {'content-type': 'application/json',
1349 "Accept": "application/json"}
1350 response = requests.request(
1351 "POST", url, data=json.dumps(data), headers=headers,
1352 auth=('admin', 'admin'))
1353 self.assertEqual(response.status_code, requests.codes.ok)
1354 res = response.json()
1355 self.assertIn('PCE calculation in progress',
1356 res['output']['configuration-response-common'][
1357 'response-message'])
1358 time.sleep(self.WAITING)
1360 def test_37_get_oc_service1(self):
1361 url = ("{}/operational/org-openroadm-service:"
1362 "service-list/services/service1"
1363 .format(self.restconf_baseurl))
1364 headers = {'content-type': 'application/json',
1365 "Accept": "application/json"}
1366 response = requests.request(
1367 "GET", url, headers=headers, auth=('admin', 'admin'))
1368 self.assertEqual(response.status_code, requests.codes.ok)
1369 res = response.json()
1371 res['services'][0]['administrative-state'],
1374 res['services'][0]['service-name'], 'service1')
1376 res['services'][0]['connection-type'], 'roadm-line')
1378 res['services'][0]['lifecycle-state'], 'planned')
1381 def test_38_check_xc1_ROADMA(self):
1383 "{}/config/network-topology:"
1384 "network-topology/topology/topology-netconf/"
1385 "node/ROADMA01/yang-ext:"
1386 "mount/org-openroadm-device:org-openroadm-device/"
1387 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1388 .format(self.restconf_baseurl))
1389 headers = {'content-type': 'application/json'}
1390 response = requests.request(
1391 "GET", url, headers=headers, auth=('admin', 'admin'))
1392 self.assertEqual(response.status_code, requests.codes.ok)
1393 res = response.json()
1394 self.assertDictContainsSubset(
1395 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1396 'wavelength-number': 1,
1397 'opticalControlMode': 'gainLoss',
1398 'target-output-power': -3.0},
1399 res['roadm-connections'][0])
1400 self.assertDictEqual(
1401 {'src-if': 'SRG1-PP1-TXRX-1'},
1402 res['roadm-connections'][0]['source'])
1403 self.assertDictEqual(
1404 {'dst-if': 'DEG1-TTP-TXRX-1'},
1405 res['roadm-connections'][0]['destination'])
1408 def test_39_check_xc1_ROADMC(self):
1410 "{}/config/network-topology:"
1411 "network-topology/topology/topology-netconf/"
1412 "node/ROADMC01/yang-ext:mount/org-openroadm-device:"
1413 "org-openroadm-device/"
1414 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1415 .format(self.restconf_baseurl))
1416 headers = {'content-type': 'application/json'}
1417 response = requests.request(
1418 "GET", url, headers=headers, auth=('admin', 'admin'))
1419 self.assertEqual(response.status_code, requests.codes.ok)
1420 res = response.json()
1421 self.assertDictContainsSubset(
1422 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1423 'wavelength-number': 1,
1424 'opticalControlMode': 'gainLoss',
1425 'target-output-power': 2.0},
1426 res['roadm-connections'][0])
1427 self.assertDictEqual(
1428 {'src-if': 'SRG1-PP1-TXRX-1'},
1429 res['roadm-connections'][0]['source'])
1430 self.assertDictEqual(
1431 {'dst-if': 'DEG2-TTP-TXRX-1'},
1432 res['roadm-connections'][0]['destination'])
1435 def test_40_create_oc_service2(self):
1436 url = ("{}/operations/org-openroadm-service:service-create"
1437 .format(self.restconf_baseurl))
1440 "sdnc-request-header": {
1441 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1442 "rpc-action": "service-create",
1443 "request-system-id": "appname",
1445 "http://localhost:8585/NotificationServer/notify"
1447 "service-name": "service2",
1448 "common-id": "ASATT1234567",
1449 "connection-type": "roadm-line",
1451 "service-rate": "100",
1452 "node-id": "ROADMA01",
1453 "service-format": "OC",
1454 "clli": "SNJSCAMCJP8",
1458 "ROUTER_SNJSCAMCJP8_000000.00_00",
1459 "port-type": "router",
1460 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1461 "port-rack": "000000.00",
1466 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1467 "lgx-port-name": "LGX Back.3",
1468 "lgx-port-rack": "000000.00",
1469 "lgx-port-shelf": "00"
1475 "ROUTER_SNJSCAMCJP8_000000.00_00",
1476 "port-type": "router",
1477 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1478 "port-rack": "000000.00",
1483 "LGX Panel_SNJSCAMCJP8_000000.00_00",
1484 "lgx-port-name": "LGX Back.4",
1485 "lgx-port-rack": "000000.00",
1486 "lgx-port-shelf": "00"
1489 "optic-type": "gray"
1492 "service-rate": "100",
1493 "node-id": "ROADMC01",
1494 "service-format": "OC",
1495 "clli": "SNJSCAMCJT4",
1499 "ROUTER_SNJSCAMCJT4_000000.00_00",
1500 "port-type": "router",
1501 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1502 "port-rack": "000000.00",
1507 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1508 "lgx-port-name": "LGX Back.29",
1509 "lgx-port-rack": "000000.00",
1510 "lgx-port-shelf": "00"
1516 "ROUTER_SNJSCAMCJT4_000000.00_00",
1517 "port-type": "router",
1518 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1519 "port-rack": "000000.00",
1524 "LGX Panel_SNJSCAMCJT4_000000.00_00",
1525 "lgx-port-name": "LGX Back.30",
1526 "lgx-port-rack": "000000.00",
1527 "lgx-port-shelf": "00"
1530 "optic-type": "gray"
1532 "due-date": "2016-11-28T00:00:01Z",
1533 "operator-contact": "pw1234"
1536 headers = {'content-type': 'application/json',
1537 "Accept": "application/json"}
1538 response = requests.request(
1539 "POST", url, data=json.dumps(data), headers=headers,
1540 auth=('admin', 'admin'))
1541 self.assertEqual(response.status_code, requests.codes.ok)
1542 res = response.json()
1543 self.assertIn('PCE calculation in progress',
1544 res['output']['configuration-response-common'][
1545 'response-message'])
1546 time.sleep(self.WAITING)
1548 def test_41_get_oc_service2(self):
1549 url = ("{}/operational/org-openroadm-service:"
1550 "service-list/services/service2"
1551 .format(self.restconf_baseurl))
1552 headers = {'content-type': 'application/json',
1553 "Accept": "application/json"}
1554 response = requests.request(
1555 "GET", url, headers=headers, auth=('admin', 'admin'))
1556 self.assertEqual(response.status_code, requests.codes.ok)
1557 res = response.json()
1559 res['services'][0]['administrative-state'],
1562 res['services'][0]['service-name'], 'service2')
1564 res['services'][0]['connection-type'], 'roadm-line')
1566 res['services'][0]['lifecycle-state'], 'planned')
1569 def test_42_check_xc2_ROADMA(self):
1571 "{}/config/network-topology:"
1572 "network-topology/topology/topology-netconf/"
1573 "node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1574 "org-openroadm-device/"
1575 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1576 .format(self.restconf_baseurl))
1577 headers = {'content-type': 'application/json'}
1578 response = requests.request(
1579 "GET", url, headers=headers, auth=('admin', 'admin'))
1580 self.assertEqual(response.status_code, requests.codes.ok)
1581 res = response.json()
1582 self.assertDictContainsSubset(
1583 {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1584 'wavelength-number': 2,
1585 'opticalControlMode': 'gainLoss',
1586 'target-output-power': -3.0},
1587 res['roadm-connections'][0])
1588 self.assertDictEqual(
1589 {'src-if': 'SRG1-PP2-TXRX-2'},
1590 res['roadm-connections'][0]['source'])
1591 self.assertDictEqual(
1592 {'dst-if': 'DEG1-TTP-TXRX-2'},
1593 res['roadm-connections'][0]['destination'])
1596 def test_43_check_topo_ROADMA(self):
1597 self.test_26_check_topo_ROADMA_SRG1()
1598 self.test_27_check_topo_ROADMA_DEG1()
1601 def test_44_delete_oc_service1(self):
1602 url = ("{}/operations/org-openroadm-service:service-delete"
1603 .format(self.restconf_baseurl))
1605 "sdnc-request-header": {
1606 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1607 "rpc-action": "service-delete",
1608 "request-system-id": "appname",
1610 "http://localhost:8585/NotificationServer/notify"
1612 "service-delete-req-info": {
1613 "service-name": "service1",
1614 "tail-retention": "no"
1618 headers = {'content-type': 'application/json'}
1619 response = requests.request(
1620 "POST", url, data=json.dumps(data), headers=headers,
1621 auth=('admin', 'admin'))
1622 self.assertEqual(response.status_code, requests.codes.ok)
1623 res = response.json()
1624 self.assertIn('Renderer service delete in progress',
1625 res['output']['configuration-response-common'][
1626 'response-message'])
1629 def test_45_delete_oc_service2(self):
1630 url = ("{}/operations/org-openroadm-service:service-delete"
1631 .format(self.restconf_baseurl))
1633 "sdnc-request-header": {
1634 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1635 "rpc-action": "service-delete",
1636 "request-system-id": "appname",
1638 "http://localhost:8585/NotificationServer/notify"
1640 "service-delete-req-info": {
1641 "service-name": "service2",
1642 "tail-retention": "no"
1646 headers = {'content-type': 'application/json'}
1647 response = requests.request(
1648 "POST", url, data=json.dumps(data), headers=headers,
1649 auth=('admin', 'admin'))
1650 self.assertEqual(response.status_code, requests.codes.ok)
1651 res = response.json()
1652 self.assertIn('Renderer service delete in progress',
1653 res['output']['configuration-response-common'][
1654 'response-message'])
1657 def test_46_get_no_oc_services(self):
1659 url = ("{}/operational/org-openroadm-service:service-list"
1660 .format(self.restconf_baseurl))
1661 headers = {'content-type': 'application/json',
1662 "Accept": "application/json"}
1663 response = requests.request(
1664 "GET", url, headers=headers, auth=('admin', 'admin'))
1665 self.assertEqual(response.status_code, requests.codes.not_found)
1666 res = response.json()
1669 "error-type": "application",
1670 "error-tag": "data-missing",
1672 "Request could not be completed because the relevant data "
1673 "model content does not exist"
1675 res['errors']['error'])
1678 def test_47_get_no_xc_ROADMA(self):
1680 "{}/config/network-topology:"
1681 "network-topology/topology/topology-netconf"
1682 "/node/ROADMA01/yang-ext:mount/org-openroadm-device:"
1683 "org-openroadm-device/"
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.ok)
1690 res = response.json()
1691 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1694 def test_48_check_topo_ROADMA(self):
1695 self.test_34_check_topo_ROADMA_SRG1()
1696 self.test_35_check_topo_ROADMA_DEG1()
1698 def test_49_loop_create_eth_service(self):
1699 for i in range(1, 6):
1700 print("trial number {}".format(i))
1701 print("eth service creation")
1702 self.test_11_create_eth_service1()
1703 print("check xc in ROADMA01")
1704 self.test_13_check_xc1_ROADMA()
1705 print("check xc in ROADMC01")
1706 self.test_14_check_xc1_ROADMC()
1707 print("eth service deletion\n")
1708 self.test_30_delete_eth_service1()
1710 def test_50_loop_create_oc_service(self):
1711 url = ("{}/operational/org-openroadm-service:"
1712 "service-list/services/service1"
1713 .format(self.restconf_baseurl))
1714 response = requests.request("GET", url, auth=('admin', 'admin'))
1715 if response.status_code != 404:
1716 url = ("{}/operations/org-openroadm-service:service-delete"
1717 .format(self.restconf_baseurl))
1719 "sdnc-request-header": {
1720 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1721 "rpc-action": "service-delete",
1722 "request-system-id": "appname",
1724 "http://localhost:8585/NotificationServer/notify"
1726 "service-delete-req-info": {
1727 "service-name": "service1",
1728 "tail-retention": "no"
1732 headers = {'content-type': 'application/json'}
1733 requests.request("POST", url, data=json.dumps(data),
1735 auth=('admin', 'admin')
1739 for i in range(1, 6):
1740 print("trial number {}".format(i))
1741 print("oc service creation")
1742 self.test_36_create_oc_service1()
1743 print("check xc in ROADMA01")
1744 self.test_38_check_xc1_ROADMA()
1745 print("check xc in ROADMC01")
1746 self.test_39_check_xc1_ROADMC()
1747 print("oc service deletion\n")
1748 self.test_44_delete_oc_service1()
1750 def test_51_disconnect_XPDRA(self):
1751 url = ("{}/config/network-topology:"
1752 "network-topology/topology/topology-netconf/node/XPDRA01"
1753 .format(self.restconf_baseurl))
1754 headers = {'content-type': 'application/json'}
1755 response = requests.request(
1756 "DELETE", url, headers=headers,
1757 auth=('admin', 'admin'))
1758 self.assertEqual(response.status_code, requests.codes.ok)
1761 def test_52_disconnect_XPDRC(self):
1762 url = ("{}/config/network-topology:"
1763 "network-topology/topology/topology-netconf/node/XPDRC01"
1764 .format(self.restconf_baseurl))
1765 headers = {'content-type': 'application/json'}
1766 response = requests.request(
1767 "DELETE", url, headers=headers,
1768 auth=('admin', 'admin'))
1769 self.assertEqual(response.status_code, requests.codes.ok)
1772 def test_53_disconnect_ROADMA(self):
1773 url = ("{}/config/network-topology:"
1774 "network-topology/topology/topology-netconf/node/ROADMA01"
1775 .format(self.restconf_baseurl))
1776 headers = {'content-type': 'application/json'}
1777 response = requests.request(
1778 "DELETE", url, headers=headers,
1779 auth=('admin', 'admin'))
1780 self.assertEqual(response.status_code, requests.codes.ok)
1783 def test_54_disconnect_ROADMC(self):
1784 url = ("{}/config/network-topology:"
1785 "network-topology/topology/topology-netconf/node/ROADMC01"
1786 .format(self.restconf_baseurl))
1787 headers = {'content-type': 'application/json'}
1788 response = requests.request(
1789 "DELETE", url, headers=headers,
1790 auth=('admin', 'admin'))
1791 self.assertEqual(response.status_code, requests.codes.ok)
1795 if __name__ == "__main__":
1796 unittest.main(verbosity=2)