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 ##############################################################################
23 class TransportPCEFulltesting(unittest.TestCase):
26 honeynode_process1 = None
27 honeynode_process2 = None
28 honeynode_process3 = None
29 honeynode_process4 = None
30 restconf_baseurl = "http://localhost:8181/restconf"
31 WAITING = 20 #nominal value is 300
33 #START_IGNORE_XTESTING
36 def __start_honeynode1(cls):
37 executable = ("./honeynode/2.2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
38 "/honeynode-distribution-1.18.01/honeycomb-tpce")
39 if os.path.isfile(executable):
40 with open('honeynode1.log', 'w') as outfile:
41 cls.honeynode_process1 = subprocess.Popen(
42 [executable, "17840", "sample_configs/openroadm/2.2.1/oper-XPDRA.xml"],
46 def __start_honeynode2(cls):
47 executable = ("./honeynode/2.2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
48 "/honeynode-distribution-1.18.01/honeycomb-tpce")
49 if os.path.isfile(executable):
50 with open('honeynode2.log', 'w') as outfile:
51 cls.honeynode_process2 = subprocess.Popen(
52 [executable, "17841", "sample_configs/openroadm/2.2.1/oper-ROADMA.xml"],
56 def __start_honeynode3(cls):
57 executable = ("./honeynode/2.2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
58 "/honeynode-distribution-1.18.01/honeycomb-tpce")
59 if os.path.isfile(executable):
60 with open('honeynode3.log', 'w') as outfile:
61 cls.honeynode_process3 = subprocess.Popen(
62 [executable, "17843", "sample_configs/openroadm/2.2.1/oper-ROADMC.xml"],
66 def __start_honeynode4(cls):
67 executable = ("./honeynode/2.2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
68 "/honeynode-distribution-1.18.01/honeycomb-tpce")
69 if os.path.isfile(executable):
70 with open('honeynode4.log', 'w') as outfile:
71 cls.honeynode_process4 = subprocess.Popen(
72 [executable, "17844", "sample_configs/openroadm/2.2.1/oper-XPDRC.xml"],
77 executable = "../karaf/target/assembly/bin/karaf"
78 with open('odl.log', 'w') as outfile:
79 cls.odl_process = subprocess.Popen(
80 ["bash", executable, "server"], stdout=outfile,
81 stdin=open(os.devnull))
85 print ("starting honeynode1")
86 cls.__start_honeynode1()
88 print ("starting honeynode2")
89 cls.__start_honeynode2()
91 print ("starting honeynode3")
92 cls.__start_honeynode3()
94 print ("starting honeynode4")
95 cls.__start_honeynode4()
97 print ("starting opendaylight")
102 def tearDownClass(cls):
103 for child in psutil.Process(cls.odl_process.pid).children():
104 child.send_signal(signal.SIGINT)
106 cls.odl_process.send_signal(signal.SIGINT)
107 cls.odl_process.wait()
108 for child in psutil.Process(cls.honeynode_process1.pid).children():
109 child.send_signal(signal.SIGINT)
111 cls.honeynode_process1.send_signal(signal.SIGINT)
112 cls.honeynode_process1.wait()
113 for child in psutil.Process(cls.honeynode_process2.pid).children():
114 child.send_signal(signal.SIGINT)
116 cls.honeynode_process2.send_signal(signal.SIGINT)
117 cls.honeynode_process2.wait()
118 for child in psutil.Process(cls.honeynode_process3.pid).children():
119 child.send_signal(signal.SIGINT)
121 cls.honeynode_process3.send_signal(signal.SIGINT)
122 cls.honeynode_process3.wait()
123 for child in psutil.Process(cls.honeynode_process4.pid).children():
124 child.send_signal(signal.SIGINT)
126 cls.honeynode_process4.send_signal(signal.SIGINT)
127 cls.honeynode_process4.wait()
128 print ("all processes killed")
130 def setUp(self): # instruction executed before each test method
131 print ("execution of {}".format(self.id().split(".")[-1]))
135 # connect netconf devices
136 def test_01_connect_xpdrA(self):
137 url = ("{}/config/network-topology:"
138 "network-topology/topology/topology-netconf/node/XPDR-A1"
139 .format(self.restconf_baseurl))
141 "node-id": "XPDR-A1",
142 "netconf-node-topology:username": "admin",
143 "netconf-node-topology:password": "admin",
144 "netconf-node-topology:host": "127.0.0.1",
145 "netconf-node-topology:port": "17840",
146 "netconf-node-topology:tcp-only": "false",
147 "netconf-node-topology:pass-through": {}}]}
148 headers = {'content-type': 'application/json'}
149 response = requests.request(
150 "PUT", url, data=json.dumps(data), headers=headers,
151 auth=('admin', 'admin'))
152 self.assertEqual(response.status_code, requests.codes.created)
155 def test_02_connect_xpdrC(self):
156 url = ("{}/config/network-topology:"
157 "network-topology/topology/topology-netconf/node/XPDR-C1"
158 .format(self.restconf_baseurl))
160 "node-id": "XPDR-C1",
161 "netconf-node-topology:username": "admin",
162 "netconf-node-topology:password": "admin",
163 "netconf-node-topology:host": "127.0.0.1",
164 "netconf-node-topology:port": "17844",
165 "netconf-node-topology:tcp-only": "false",
166 "netconf-node-topology:pass-through": {}}]}
167 headers = {'content-type': 'application/json'}
168 response = requests.request(
169 "PUT", url, data=json.dumps(data), headers=headers,
170 auth=('admin', 'admin'))
171 self.assertEqual(response.status_code, requests.codes.created)
174 def test_03_connect_rdmA(self):
175 url = ("{}/config/network-topology:"
176 "network-topology/topology/topology-netconf/node/ROADM-A1"
177 .format(self.restconf_baseurl))
179 "node-id": "ROADM-A1",
180 "netconf-node-topology:username": "admin",
181 "netconf-node-topology:password": "admin",
182 "netconf-node-topology:host": "127.0.0.1",
183 "netconf-node-topology:port": "17841",
184 "netconf-node-topology:tcp-only": "false",
185 "netconf-node-topology:pass-through": {}}]}
186 headers = {'content-type': 'application/json'}
187 response = requests.request(
188 "PUT", url, data=json.dumps(data), headers=headers,
189 auth=('admin', 'admin'))
190 self.assertEqual(response.status_code, requests.codes.created)
193 def test_04_connect_rdmC(self):
194 url = ("{}/config/network-topology:"
195 "network-topology/topology/topology-netconf/node/ROADM-C1"
196 .format(self.restconf_baseurl))
198 "node-id": "ROADM-C1",
199 "netconf-node-topology:username": "admin",
200 "netconf-node-topology:password": "admin",
201 "netconf-node-topology:host": "127.0.0.1",
202 "netconf-node-topology:port": "17843",
203 "netconf-node-topology:tcp-only": "false",
204 "netconf-node-topology:pass-through": {}}]}
205 headers = {'content-type': 'application/json'}
206 response = requests.request(
207 "PUT", url, data=json.dumps(data), headers=headers,
208 auth=('admin', 'admin'))
209 self.assertEqual(response.status_code, requests.codes.created)
212 def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
213 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
215 "networkutils:input": {
216 "networkutils:links-input": {
217 "networkutils:xpdr-node": "XPDR-A1",
218 "networkutils:xpdr-num": "1",
219 "networkutils:network-num": "1",
220 "networkutils:rdm-node": "ROADM-A1",
221 "networkutils:srg-num": "1",
222 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
226 headers = {'content-type': 'application/json'}
227 response = requests.request(
228 "POST", url, data=json.dumps(data),
229 headers=headers, auth=('admin', 'admin'))
230 self.assertEqual(response.status_code, requests.codes.ok)
231 res = response.json()
232 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
235 def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
236 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
238 "networkutils:input": {
239 "networkutils:links-input": {
240 "networkutils:xpdr-node": "XPDR-A1",
241 "networkutils:xpdr-num": "1",
242 "networkutils:network-num": "1",
243 "networkutils:rdm-node": "ROADM-A1",
244 "networkutils:srg-num": "1",
245 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
249 headers = {'content-type': 'application/json'}
250 response = requests.request(
251 "POST", url, data=json.dumps(data),
252 headers=headers, auth=('admin', 'admin'))
253 self.assertEqual(response.status_code, requests.codes.ok)
254 res = response.json()
255 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
259 def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
260 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
262 "networkutils:input": {
263 "networkutils:links-input": {
264 "networkutils:xpdr-node": "XPDR-C1",
265 "networkutils:xpdr-num": "1",
266 "networkutils:network-num": "1",
267 "networkutils:rdm-node": "ROADM-C1",
268 "networkutils:srg-num": "1",
269 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
273 headers = {'content-type': 'application/json'}
274 response = requests.request(
275 "POST", url, data=json.dumps(data),
276 headers=headers, auth=('admin', 'admin'))
277 self.assertEqual(response.status_code, requests.codes.ok)
278 res = response.json()
279 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
283 def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
284 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
286 "networkutils:input": {
287 "networkutils:links-input": {
288 "networkutils:xpdr-node": "XPDR-C1",
289 "networkutils:xpdr-num": "1",
290 "networkutils:network-num": "1",
291 "networkutils:rdm-node": "ROADM-C1",
292 "networkutils:srg-num": "1",
293 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
297 headers = {'content-type': 'application/json'}
298 response = requests.request(
299 "POST", url, data=json.dumps(data),
300 headers=headers, auth=('admin', 'admin'))
301 self.assertEqual(response.status_code, requests.codes.ok)
302 res = response.json()
303 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
307 #test service-create for Eth service from xpdr to xpdr
308 def test_09_create_eth_service1(self):
309 url = ("{}/operations/org-openroadm-service:service-create"
310 .format(self.restconf_baseurl))
312 "sdnc-request-header": {
313 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
314 "rpc-action": "service-create",
315 "request-system-id": "appname",
316 "notification-url": "http://localhost:8585/NotificationServer/notify"
318 "service-name": "service1",
319 "common-id": "ASATT1234567",
320 "connection-type": "service",
322 "service-rate": "100",
323 "node-id": "XPDR-A1",
324 "service-format": "Ethernet",
325 "clli": "SNJSCAMCJP8",
328 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
329 "port-type": "router",
330 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
331 "port-rack": "000000.00",
335 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
336 "lgx-port-name": "LGX Back.3",
337 "lgx-port-rack": "000000.00",
338 "lgx-port-shelf": "00"
343 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
344 "port-type": "router",
345 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
346 "port-rack": "000000.00",
350 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
351 "lgx-port-name": "LGX Back.4",
352 "lgx-port-rack": "000000.00",
353 "lgx-port-shelf": "00"
359 "service-rate": "100",
360 "node-id": "XPDR-C1",
361 "service-format": "Ethernet",
362 "clli": "SNJSCAMCJT4",
365 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
366 "port-type": "router",
367 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
368 "port-rack": "000000.00",
372 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
373 "lgx-port-name": "LGX Back.29",
374 "lgx-port-rack": "000000.00",
375 "lgx-port-shelf": "00"
380 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
381 "port-type": "router",
382 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
383 "port-rack": "000000.00",
387 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
388 "lgx-port-name": "LGX Back.30",
389 "lgx-port-rack": "000000.00",
390 "lgx-port-shelf": "00"
395 "due-date": "2016-11-28T00:00:01Z",
396 "operator-contact": "pw1234"
399 headers = {'content-type': 'application/json',
400 "Accept": "application/json"}
401 response = requests.request(
402 "POST", url, data=json.dumps(data), headers=headers,
403 auth=('admin', 'admin'))
404 self.assertEqual(response.status_code, requests.codes.ok)
405 res = response.json()
406 self.assertIn('PCE calculation in progress',
407 res['output']['configuration-response-common']['response-message'])
408 time.sleep(self.WAITING)
410 def test_10_get_eth_service1(self):
411 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
412 .format(self.restconf_baseurl))
413 headers = {'content-type': 'application/json',
414 "Accept": "application/json"}
415 response = requests.request(
416 "GET", url, headers=headers, auth=('admin', 'admin'))
417 self.assertEqual(response.status_code, requests.codes.ok)
418 res = response.json()
420 res['services'][0]['administrative-state'],
423 res['services'][0]['service-name'], 'service1')
425 res['services'][0]['connection-type'], 'service')
427 res['services'][0]['lifecycle-state'], 'planned')
430 def test_11_check_xc1_ROADMA(self):
431 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
432 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
433 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
434 .format(self.restconf_baseurl))
435 headers = {'content-type': 'application/json'}
436 response = requests.request(
437 "GET", url, headers=headers, auth=('admin', 'admin'))
438 self.assertEqual(response.status_code, requests.codes.ok)
439 res = response.json()
440 self.assertDictContainsSubset(
441 {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
442 'opticalControlMode': 'gainLoss',
443 'target-output-power': -3.0},
444 res['roadm-connections'][0])
445 self.assertDictEqual(
446 {'src-if': 'SRG1-PP1-TXRX-nmc'},
447 res['roadm-connections'][0]['source'])
448 self.assertDictEqual(
449 {'dst-if': 'DEG2-TTP-TXRX-nmc'},
450 res['roadm-connections'][0]['destination'])
453 def test_12_check_xc1_ROADMC(self):
454 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
455 "node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
456 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
457 .format(self.restconf_baseurl))
458 headers = {'content-type': 'application/json'}
459 response = requests.request(
460 "GET", url, headers=headers, auth=('admin', 'admin'))
461 self.assertEqual(response.status_code, requests.codes.ok)
462 res = response.json()
463 self.assertDictContainsSubset(
464 {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
465 'opticalControlMode': 'gainLoss',
466 'target-output-power': -3.0},
467 res['roadm-connections'][0])
468 self.assertDictEqual(
469 {'src-if': 'SRG1-PP1-TXRX-nmc'},
470 res['roadm-connections'][0]['source'])
471 self.assertDictEqual(
472 {'dst-if': 'DEG1-TTP-TXRX-nmc'},
473 res['roadm-connections'][0]['destination'])
476 def test_13_check_topo_XPDRA(self):
477 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
478 .format(self.restconf_baseurl))
479 response = requests.request(
480 "GET", url1, auth=('admin', 'admin'))
481 self.assertEqual(response.status_code, requests.codes.ok)
482 res = response.json()
483 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
485 if ele['tp-id'] == 'XPDR1-NETWORK1':
486 self.assertEqual({u'frequency': 196.099999999999994315658113919198513031005859375,
487 u'width': 1528.76999999999998181010596454143524169921875},
488 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
489 if ele['tp-id'] == 'XPDR1-CLIENT2' or ele['tp-id'] == 'XPDR1-CLIENT1':
490 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
491 if ele['tp-id'] == 'XPDR1-NETWORK2':
492 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes']))
495 def test_14_check_topo_ROADMA_SRG1(self):
496 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
497 .format(self.restconf_baseurl))
498 response = requests.request(
499 "GET", url1, auth=('admin', 'admin'))
500 self.assertEqual(response.status_code, requests.codes.ok)
501 res = response.json()
502 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
503 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
505 if ele['tp-id'] == 'SRG1-PP1-TXRX':
506 self.assertIn({u'index': 1}, ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
507 if ele['tp-id'] == 'SRG1-PP2-TXRX':
508 self.assertNotIn('used-wavelength', dict.keys(ele))
511 def test_15_check_topo_ROADMA_DEG1(self):
512 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
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 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
519 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
521 if ele['tp-id'] == 'DEG2-CTP-TXRX':
522 self.assertIn({u'index': 1}, ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
523 if ele['tp-id'] == 'DEG2-TTP-TXRX':
524 self.assertIn({u'index': 1}, ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
527 def test_16_connect_xprdA_N2_to_roadmA_PP2(self):
528 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
530 "networkutils:input": {
531 "networkutils:links-input": {
532 "networkutils:xpdr-node": "XPDR-A1",
533 "networkutils:xpdr-num": "1",
534 "networkutils:network-num": "2",
535 "networkutils:rdm-node": "ROADM-A1",
536 "networkutils:srg-num": "1",
537 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
541 headers = {'content-type': 'application/json'}
542 response = requests.request(
543 "POST", url, data=json.dumps(data),
544 headers=headers, auth=('admin', 'admin'))
545 self.assertEqual(response.status_code, requests.codes.ok)
546 res = response.json()
547 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
550 def test_17_connect_roadmA_PP2_to_xpdrA_N2(self):
551 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
553 "networkutils:input": {
554 "networkutils:links-input": {
555 "networkutils:xpdr-node": "XPDR-A1",
556 "networkutils:xpdr-num": "1",
557 "networkutils:network-num": "2",
558 "networkutils:rdm-node": "ROADM-A1",
559 "networkutils:srg-num": "1",
560 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
564 headers = {'content-type': 'application/json'}
565 response = requests.request(
566 "POST", url, data=json.dumps(data),
567 headers=headers, auth=('admin', 'admin'))
568 self.assertEqual(response.status_code, requests.codes.ok)
569 res = response.json()
570 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
573 def test_18_connect_xprdC_N2_to_roadmC_PP2(self):
574 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
576 "networkutils:input": {
577 "networkutils:links-input": {
578 "networkutils:xpdr-node": "XPDR-C1",
579 "networkutils:xpdr-num": "1",
580 "networkutils:network-num": "2",
581 "networkutils:rdm-node": "ROADM-C1",
582 "networkutils:srg-num": "1",
583 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
587 headers = {'content-type': 'application/json'}
588 response = requests.request(
589 "POST", url, data=json.dumps(data),
590 headers=headers, auth=('admin', 'admin'))
591 self.assertEqual(response.status_code, requests.codes.ok)
592 res = response.json()
593 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
596 def test_19_connect_roadmC_PP2_to_xpdrC_N2(self):
597 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
599 "networkutils:input": {
600 "networkutils:links-input": {
601 "networkutils:xpdr-node": "XPDR-C1",
602 "networkutils:xpdr-num": "1",
603 "networkutils:network-num": "2",
604 "networkutils:rdm-node": "ROADM-C1",
605 "networkutils:srg-num": "1",
606 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
610 headers = {'content-type': 'application/json'}
611 response = requests.request(
612 "POST", url, data=json.dumps(data),
613 headers=headers, auth=('admin', 'admin'))
614 self.assertEqual(response.status_code, requests.codes.ok)
615 res = response.json()
616 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
619 def test_20_create_eth_service2(self):
620 url = ("{}/operations/org-openroadm-service:service-create"
621 .format(self.restconf_baseurl))
623 "sdnc-request-header": {
624 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
625 "rpc-action": "service-create",
626 "request-system-id": "appname",
627 "notification-url": "http://localhost:8585/NotificationServer/notify"
629 "service-name": "service2",
630 "common-id": "ASATT1234567",
631 "connection-type": "service",
633 "service-rate": "100",
634 "node-id": "XPDR-A1",
635 "service-format": "Ethernet",
636 "clli": "SNJSCAMCJP8",
639 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
640 "port-type": "router",
641 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
642 "port-rack": "000000.00",
646 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
647 "lgx-port-name": "LGX Back.3",
648 "lgx-port-rack": "000000.00",
649 "lgx-port-shelf": "00"
654 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
655 "port-type": "router",
656 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
657 "port-rack": "000000.00",
661 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
662 "lgx-port-name": "LGX Back.4",
663 "lgx-port-rack": "000000.00",
664 "lgx-port-shelf": "00"
670 "service-rate": "100",
671 "node-id": "XPDR-C1",
672 "service-format": "Ethernet",
673 "clli": "SNJSCAMCJT4",
676 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
677 "port-type": "router",
678 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
679 "port-rack": "000000.00",
683 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
684 "lgx-port-name": "LGX Back.29",
685 "lgx-port-rack": "000000.00",
686 "lgx-port-shelf": "00"
691 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
692 "port-type": "router",
693 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
694 "port-rack": "000000.00",
698 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
699 "lgx-port-name": "LGX Back.30",
700 "lgx-port-rack": "000000.00",
701 "lgx-port-shelf": "00"
706 "due-date": "2016-11-28T00:00:01Z",
707 "operator-contact": "pw1234"
710 headers = {'content-type': 'application/json',
711 "Accept": "application/json"}
712 response = requests.request(
713 "POST", url, data=json.dumps(data), headers=headers,
714 auth=('admin', 'admin'))
715 self.assertEqual(response.status_code, requests.codes.ok)
716 res = response.json()
717 self.assertIn('PCE calculation in progress',
718 res['output']['configuration-response-common']['response-message'])
719 time.sleep(self.WAITING)
721 def test_21_get_eth_service2(self):
722 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
723 .format(self.restconf_baseurl))
724 headers = {'content-type': 'application/json',
725 "Accept": "application/json"}
726 response = requests.request(
727 "GET", url, headers=headers, auth=('admin', 'admin'))
728 self.assertEqual(response.status_code, requests.codes.ok)
729 res = response.json()
731 res['services'][0]['administrative-state'],
734 res['services'][0]['service-name'], 'service2')
736 res['services'][0]['connection-type'], 'service')
738 res['services'][0]['lifecycle-state'], 'planned')
741 def test_22_check_xc2_ROADMA(self):
742 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
743 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
744 "roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-2"
745 .format(self.restconf_baseurl))
746 headers = {'content-type': 'application/json'}
747 response = requests.request(
748 "GET", url, headers=headers, auth=('admin', 'admin'))
749 self.assertEqual(response.status_code, requests.codes.ok)
750 res = response.json()
751 self.assertDictContainsSubset(
752 {'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-2',
753 'opticalControlMode': 'power'},
754 res['roadm-connections'][0])
755 self.assertDictEqual(
756 {'src-if': 'DEG2-TTP-TXRX-nmc'},
757 res['roadm-connections'][0]['source'])
758 self.assertDictEqual(
759 {'dst-if': 'SRG1-PP2-TXRX-nmc'},
760 res['roadm-connections'][0]['destination'])
762 def test_23_check_topo_XPDRA(self):
763 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
764 .format(self.restconf_baseurl))
765 response = requests.request(
766 "GET", url1, auth=('admin', 'admin'))
767 self.assertEqual(response.status_code, requests.codes.ok)
768 res = response.json()
769 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
771 if ele['tp-id'] == 'XPDR1-NETWORK1':
772 self.assertEqual({u'frequency': 196.099999999999994315658113919198513031005859375,
773 u'width': 1528.76999999999998181010596454143524169921875},
774 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
775 if ele['tp-id'] == 'XPDR1-NETWORK2':
776 self.assertEqual({u'frequency': 196.04999999999998,
778 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
779 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT2':
780 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
783 def test_24_check_topo_ROADMA_SRG1(self):
784 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
785 .format(self.restconf_baseurl))
786 response = requests.request(
787 "GET", url1, auth=('admin', 'admin'))
788 self.assertEqual(response.status_code, requests.codes.ok)
789 res = response.json()
790 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
791 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
792 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
794 if ele['tp-id'] == 'SRG1-PP1-TXRX':
795 self.assertIn({u'index': 1}, ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
796 self.assertNotIn({u'index': 2}, ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
797 if ele['tp-id'] == 'SRG1-PP2-TXRX':
798 self.assertIn({u'index': 2}, ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
799 self.assertNotIn({u'index': 1}, ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
800 if ele['tp-id'] == 'SRG1-PP3-TXRX':
801 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
805 def test_25_check_topo_ROADMA_DEG2(self):
806 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
807 .format(self.restconf_baseurl))
808 response = requests.request(
809 "GET", url1, auth=('admin', 'admin'))
810 self.assertEqual(response.status_code, requests.codes.ok)
811 res = response.json()
812 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
813 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
814 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
816 if ele['tp-id'] == 'DEG2-CTP-TXRX':
817 self.assertIn({u'index': 1}, ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
818 self.assertIn({u'index': 2}, ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
819 if ele['tp-id'] == 'DEG2-TTP-TXRX':
820 self.assertIn({u'index': 1}, ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
821 self.assertIn({u'index': 2}, ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
824 # creation service test on a non-available resource
825 def test_26_create_eth_service3(self):
826 url = ("{}/operations/org-openroadm-service:service-create"
827 .format(self.restconf_baseurl))
829 "sdnc-request-header": {
830 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
831 "rpc-action": "service-create",
832 "request-system-id": "appname",
833 "notification-url": "http://localhost:8585/NotificationServer/notify"
835 "service-name": "service3",
836 "common-id": "ASATT1234567",
837 "connection-type": "service",
839 "service-rate": "100",
840 "node-id": "XPDR-A1",
841 "service-format": "Ethernet",
842 "clli": "SNJSCAMCJP8",
845 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
846 "port-type": "router",
847 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
848 "port-rack": "000000.00",
852 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
853 "lgx-port-name": "LGX Back.3",
854 "lgx-port-rack": "000000.00",
855 "lgx-port-shelf": "00"
860 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
861 "port-type": "router",
862 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
863 "port-rack": "000000.00",
867 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
868 "lgx-port-name": "LGX Back.4",
869 "lgx-port-rack": "000000.00",
870 "lgx-port-shelf": "00"
876 "service-rate": "100",
877 "node-id": "XPDR-C1",
878 "service-format": "Ethernet",
879 "clli": "SNJSCAMCJT4",
882 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
883 "port-type": "router",
884 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
885 "port-rack": "000000.00",
889 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
890 "lgx-port-name": "LGX Back.29",
891 "lgx-port-rack": "000000.00",
892 "lgx-port-shelf": "00"
897 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
898 "port-type": "router",
899 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
900 "port-rack": "000000.00",
904 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
905 "lgx-port-name": "LGX Back.30",
906 "lgx-port-rack": "000000.00",
907 "lgx-port-shelf": "00"
912 "due-date": "2016-11-28T00:00:01Z",
913 "operator-contact": "pw1234"
916 headers = {'content-type': 'application/json',
917 "Accept": "application/json"}
918 response = requests.request(
919 "POST", url, data=json.dumps(data), headers=headers,
920 auth=('admin', 'admin'))
921 self.assertEqual(response.status_code, requests.codes.ok)
922 res = response.json()
923 self.assertIn('PCE calculation in progress',
924 res['output']['configuration-response-common']['response-message'])
925 self.assertIn('200', res['output']['configuration-response-common']['response-code'])
926 time.sleep(self.WAITING)
928 # add a test that check the openroadm-service-list still only contains 2 elements
930 def test_27_delete_eth_service3(self):
931 url = ("{}/operations/org-openroadm-service:service-delete"
932 .format(self.restconf_baseurl))
934 "sdnc-request-header": {
935 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
936 "rpc-action": "service-delete",
937 "request-system-id": "appname",
938 "notification-url": "http://localhost:8585/NotificationServer/notify"
940 "service-delete-req-info": {
941 "service-name": "service3",
942 "tail-retention": "no"
946 headers = {'content-type': 'application/json'}
947 response = requests.request(
948 "POST", url, data=json.dumps(data), headers=headers,
949 auth=('admin', 'admin'))
950 self.assertEqual(response.status_code, requests.codes.ok)
951 res = response.json()
952 self.assertIn('Service \'service3\' does not exist in datastore',
953 res['output']['configuration-response-common']['response-message'])
954 self.assertIn('500', res['output']['configuration-response-common']['response-code'])
957 def test_28_delete_eth_service1(self):
958 url = ("{}/operations/org-openroadm-service:service-delete"
959 .format(self.restconf_baseurl))
961 "sdnc-request-header": {
962 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
963 "rpc-action": "service-delete",
964 "request-system-id": "appname",
965 "notification-url": "http://localhost:8585/NotificationServer/notify"
967 "service-delete-req-info": {
968 "service-name": "service1",
969 "tail-retention": "no"
973 headers = {'content-type': 'application/json'}
974 response = requests.request(
975 "POST", url, data=json.dumps(data), headers=headers,
976 auth=('admin', 'admin'))
977 self.assertEqual(response.status_code, requests.codes.ok)
978 res = response.json()
979 self.assertIn('Renderer service delete in progress',
980 res['output']['configuration-response-common']['response-message'])
983 def test_29_delete_eth_service2(self):
984 url = ("{}/operations/org-openroadm-service:service-delete"
985 .format(self.restconf_baseurl))
987 "sdnc-request-header": {
988 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
989 "rpc-action": "service-delete",
990 "request-system-id": "appname",
991 "notification-url": "http://localhost:8585/NotificationServer/notify"
993 "service-delete-req-info": {
994 "service-name": "service2",
995 "tail-retention": "no"
999 headers = {'content-type': 'application/json'}
1000 response = requests.request(
1001 "POST", url, data=json.dumps(data), headers=headers,
1002 auth=('admin', 'admin'))
1003 self.assertEqual(response.status_code, requests.codes.ok)
1004 res = response.json()
1005 self.assertIn('Renderer service delete in progress',
1006 res['output']['configuration-response-common']['response-message'])
1009 def test_30_check_no_xc_ROADMA(self):
1010 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1011 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1012 .format(self.restconf_baseurl))
1013 response = requests.request(
1014 "GET", url, auth=('admin', 'admin'))
1015 res = response.json()
1016 self.assertEqual(response.status_code, requests.codes.ok)
1017 self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1020 def test_31_check_topo_XPDRA(self):
1021 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
1022 .format(self.restconf_baseurl))
1023 response = requests.request(
1024 "GET", url1, auth=('admin', 'admin'))
1025 self.assertEqual(response.status_code, requests.codes.ok)
1026 res = response.json()
1027 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1028 for ele in liste_tp:
1029 if ele[u'org-openroadm-network-topology:tp-type'] == 'XPONDER-CLIENT':
1030 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
1031 elif ele[u'org-openroadm-network-topology:tp-type'] == 'XPONDER-NETWORK':
1032 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes']))
1035 def test_32_check_topo_ROADMA_SRG1(self):
1036 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
1037 .format(self.restconf_baseurl))
1038 response = requests.request(
1039 "GET", url1, auth=('admin', 'admin'))
1040 self.assertEqual(response.status_code, requests.codes.ok)
1041 res = response.json()
1042 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1043 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1044 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1045 for ele in liste_tp:
1046 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1047 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1049 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1052 def test_33_check_topo_ROADMA_DEG2(self):
1053 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
1054 .format(self.restconf_baseurl))
1055 response = requests.request(
1056 "GET", url1, auth=('admin', 'admin'))
1057 self.assertEqual(response.status_code, requests.codes.ok)
1058 res = response.json()
1059 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1060 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1061 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1062 for ele in liste_tp:
1063 if ele['tp-id'] == 'DEG2-CTP-TXRX':
1064 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1065 if ele['tp-id'] == 'DEG2-TTP-TXRX':
1066 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1070 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1071 def test_34_create_oc_service1(self):
1072 url = ("{}/operations/org-openroadm-service:service-create"
1073 .format(self.restconf_baseurl))
1075 "sdnc-request-header": {
1076 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1077 "rpc-action": "service-create",
1078 "request-system-id": "appname",
1079 "notification-url": "http://localhost:8585/NotificationServer/notify"
1081 "service-name": "service1",
1082 "common-id": "ASATT1234567",
1083 "connection-type": "roadm-line",
1085 "service-rate": "100",
1086 "node-id": "ROADM-A1",
1087 "service-format": "OC",
1088 "clli": "SNJSCAMCJP8",
1091 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1092 "port-type": "router",
1093 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1094 "port-rack": "000000.00",
1098 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1099 "lgx-port-name": "LGX Back.3",
1100 "lgx-port-rack": "000000.00",
1101 "lgx-port-shelf": "00"
1106 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1107 "port-type": "router",
1108 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1109 "port-rack": "000000.00",
1113 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1114 "lgx-port-name": "LGX Back.4",
1115 "lgx-port-rack": "000000.00",
1116 "lgx-port-shelf": "00"
1119 "optic-type": "gray"
1122 "service-rate": "100",
1123 "node-id": "ROADM-C1",
1124 "service-format": "OC",
1125 "clli": "SNJSCAMCJT4",
1128 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1129 "port-type": "router",
1130 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1131 "port-rack": "000000.00",
1135 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1136 "lgx-port-name": "LGX Back.29",
1137 "lgx-port-rack": "000000.00",
1138 "lgx-port-shelf": "00"
1143 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1144 "port-type": "router",
1145 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1146 "port-rack": "000000.00",
1150 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1151 "lgx-port-name": "LGX Back.30",
1152 "lgx-port-rack": "000000.00",
1153 "lgx-port-shelf": "00"
1156 "optic-type": "gray"
1158 "due-date": "2016-11-28T00:00:01Z",
1159 "operator-contact": "pw1234"
1162 headers = {'content-type': 'application/json',
1163 "Accept": "application/json"}
1164 response = requests.request(
1165 "POST", url, data=json.dumps(data), headers=headers,
1166 auth=('admin', 'admin'))
1167 self.assertEqual(response.status_code, requests.codes.ok)
1168 res = response.json()
1169 self.assertIn('PCE calculation in progress',
1170 res['output']['configuration-response-common']['response-message'])
1171 time.sleep(self.WAITING)
1173 def test_35_get_oc_service1(self):
1174 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1175 .format(self.restconf_baseurl))
1176 headers = {'content-type': 'application/json',
1177 "Accept": "application/json"}
1178 response = requests.request(
1179 "GET", url, headers=headers, auth=('admin', 'admin'))
1180 self.assertEqual(response.status_code, requests.codes.ok)
1181 res = response.json()
1183 res['services'][0]['administrative-state'],
1186 res['services'][0]['service-name'], 'service1')
1188 res['services'][0]['connection-type'], 'roadm-line')
1190 res['services'][0]['lifecycle-state'], 'planned')
1193 def test_36_check_xc1_ROADMA(self):
1194 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1195 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1196 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1197 .format(self.restconf_baseurl))
1198 headers = {'content-type': 'application/json'}
1199 response = requests.request(
1200 "GET", url, headers=headers, auth=('admin', 'admin'))
1201 self.assertEqual(response.status_code, requests.codes.ok)
1202 res = response.json()
1203 self.assertDictContainsSubset(
1204 {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1205 'opticalControlMode': 'gainLoss',
1206 'target-output-power': -3.0},
1207 res['roadm-connections'][0])
1208 self.assertDictEqual(
1209 {'src-if': 'SRG1-PP1-TXRX-nmc'},
1210 res['roadm-connections'][0]['source'])
1211 self.assertDictEqual(
1212 {'dst-if': 'DEG2-TTP-TXRX-nmc'},
1213 res['roadm-connections'][0]['destination'])
1216 def test_37_check_xc1_ROADMC(self):
1217 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1218 "node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1219 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1220 .format(self.restconf_baseurl))
1221 headers = {'content-type': 'application/json'}
1222 response = requests.request(
1223 "GET", url, headers=headers, auth=('admin', 'admin'))
1224 self.assertEqual(response.status_code, requests.codes.ok)
1225 res = response.json()
1226 self.assertDictContainsSubset(
1227 {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1228 'opticalControlMode': 'gainLoss',
1229 'target-output-power': -3.0},
1230 res['roadm-connections'][0])
1231 self.assertDictEqual(
1232 {'src-if': 'SRG1-PP1-TXRX-nmc'},
1233 res['roadm-connections'][0]['source'])
1234 self.assertDictEqual(
1235 {'dst-if': 'DEG1-TTP-TXRX-nmc'},
1236 res['roadm-connections'][0]['destination'])
1239 def test_38_create_oc_service2(self):
1240 url = ("{}/operations/org-openroadm-service:service-create"
1241 .format(self.restconf_baseurl))
1243 "sdnc-request-header": {
1244 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1245 "rpc-action": "service-create",
1246 "request-system-id": "appname",
1247 "notification-url": "http://localhost:8585/NotificationServer/notify"
1249 "service-name": "service2",
1250 "common-id": "ASATT1234567",
1251 "connection-type": "roadm-line",
1253 "service-rate": "100",
1254 "node-id": "ROADM-A1",
1255 "service-format": "OC",
1256 "clli": "SNJSCAMCJP8",
1259 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1260 "port-type": "router",
1261 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1262 "port-rack": "000000.00",
1266 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1267 "lgx-port-name": "LGX Back.3",
1268 "lgx-port-rack": "000000.00",
1269 "lgx-port-shelf": "00"
1274 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1275 "port-type": "router",
1276 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1277 "port-rack": "000000.00",
1281 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1282 "lgx-port-name": "LGX Back.4",
1283 "lgx-port-rack": "000000.00",
1284 "lgx-port-shelf": "00"
1287 "optic-type": "gray"
1290 "service-rate": "100",
1291 "node-id": "ROADM-C1",
1292 "service-format": "OC",
1293 "clli": "SNJSCAMCJT4",
1296 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1297 "port-type": "router",
1298 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1299 "port-rack": "000000.00",
1303 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1304 "lgx-port-name": "LGX Back.29",
1305 "lgx-port-rack": "000000.00",
1306 "lgx-port-shelf": "00"
1311 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1312 "port-type": "router",
1313 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1314 "port-rack": "000000.00",
1318 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1319 "lgx-port-name": "LGX Back.30",
1320 "lgx-port-rack": "000000.00",
1321 "lgx-port-shelf": "00"
1324 "optic-type": "gray"
1326 "due-date": "2016-11-28T00:00:01Z",
1327 "operator-contact": "pw1234"
1330 headers = {'content-type': 'application/json',
1331 "Accept": "application/json"}
1332 response = requests.request(
1333 "POST", url, data=json.dumps(data), headers=headers,
1334 auth=('admin', 'admin'))
1335 self.assertEqual(response.status_code, requests.codes.ok)
1336 res = response.json()
1337 self.assertIn('PCE calculation in progress',
1338 res['output']['configuration-response-common']['response-message'])
1339 time.sleep(self.WAITING)
1341 def test_39_get_oc_service2(self):
1342 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1343 .format(self.restconf_baseurl))
1344 headers = {'content-type': 'application/json',
1345 "Accept": "application/json"}
1346 response = requests.request(
1347 "GET", url, headers=headers, auth=('admin', 'admin'))
1348 self.assertEqual(response.status_code, requests.codes.ok)
1349 res = response.json()
1351 res['services'][0]['administrative-state'],
1354 res['services'][0]['service-name'], 'service2')
1356 res['services'][0]['connection-type'], 'roadm-line')
1358 res['services'][0]['lifecycle-state'], 'planned')
1361 def test_40_check_xc2_ROADMA(self):
1362 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1363 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1364 "roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-2"
1365 .format(self.restconf_baseurl))
1366 headers = {'content-type': 'application/json'}
1367 response = requests.request(
1368 "GET", url, headers=headers, auth=('admin', 'admin'))
1369 self.assertEqual(response.status_code, requests.codes.ok)
1370 res = response.json()
1371 self.assertDictContainsSubset(
1372 {'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-2',
1373 'opticalControlMode': 'gainLoss',
1374 'target-output-power': -3.0},
1375 res['roadm-connections'][0])
1376 self.assertDictEqual(
1377 {'src-if': 'SRG1-PP2-TXRX-nmc'},
1378 res['roadm-connections'][0]['source'])
1379 self.assertDictEqual(
1380 {'dst-if': 'DEG2-TTP-TXRX-nmc'},
1381 res['roadm-connections'][0]['destination'])
1384 def test_41_check_topo_ROADMA(self):
1385 self.test_24_check_topo_ROADMA_SRG1()
1386 self.test_25_check_topo_ROADMA_DEG2()
1390 def test_42_delete_oc_service1(self):
1391 url = ("{}/operations/org-openroadm-service:service-delete"
1392 .format(self.restconf_baseurl))
1394 "sdnc-request-header": {
1395 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1396 "rpc-action": "service-delete",
1397 "request-system-id": "appname",
1398 "notification-url": "http://localhost:8585/NotificationServer/notify"
1400 "service-delete-req-info": {
1401 "service-name": "service1",
1402 "tail-retention": "no"
1406 headers = {'content-type': 'application/json'}
1407 response = requests.request(
1408 "POST", url, data=json.dumps(data), headers=headers,
1409 auth=('admin', 'admin'))
1410 self.assertEqual(response.status_code, requests.codes.ok)
1411 res = response.json()
1412 self.assertIn('Renderer service delete in progress',
1413 res['output']['configuration-response-common']['response-message'])
1416 def test_43_delete_oc_service2(self):
1417 url = ("{}/operations/org-openroadm-service:service-delete"
1418 .format(self.restconf_baseurl))
1420 "sdnc-request-header": {
1421 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1422 "rpc-action": "service-delete",
1423 "request-system-id": "appname",
1424 "notification-url": "http://localhost:8585/NotificationServer/notify"
1426 "service-delete-req-info": {
1427 "service-name": "service2",
1428 "tail-retention": "no"
1432 headers = {'content-type': 'application/json'}
1433 response = requests.request(
1434 "POST", url, data=json.dumps(data), headers=headers,
1435 auth=('admin', 'admin'))
1436 self.assertEqual(response.status_code, requests.codes.ok)
1437 res = response.json()
1438 self.assertIn('Renderer service delete in progress',
1439 res['output']['configuration-response-common']['response-message'])
1442 def test_44_get_no_oc_services(self):
1443 print ("start test")
1444 url = ("{}/operational/org-openroadm-service:service-list"
1445 .format(self.restconf_baseurl))
1446 headers = {'content-type': 'application/json',
1447 "Accept": "application/json"}
1448 response = requests.request(
1449 "GET", url, headers=headers, auth=('admin', 'admin'))
1450 self.assertEqual(response.status_code, requests.codes.not_found)
1451 res = response.json()
1453 {"error-type":"application", "error-tag":"data-missing",
1454 "error-message":"Request could not be completed because the relevant data model content does not exist"},
1455 res['errors']['error'])
1458 def test_45_get_no_xc_ROADMA(self):
1459 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1460 "/node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1461 .format(self.restconf_baseurl))
1462 headers = {'content-type': 'application/json',
1463 "Accept": "application/json"}
1464 response = requests.request(
1465 "GET", url, headers=headers, auth=('admin', 'admin'))
1466 self.assertEqual(response.status_code, requests.codes.ok)
1467 res = response.json()
1468 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1471 def test_46_check_topo_ROADMA(self):
1472 self.test_32_check_topo_ROADMA_SRG1()
1473 self.test_33_check_topo_ROADMA_DEG2()
1475 def test_47_loop_create_eth_service(self):
1476 for i in range(1,6):
1477 print ("trial number {}".format(i))
1478 print("eth service creation")
1479 self.test_09_create_eth_service1()
1480 print ("check xc in ROADM-A1")
1481 self.test_11_check_xc1_ROADMA()
1482 print ("check xc in ROADM-C1")
1483 self.test_12_check_xc1_ROADMC()
1484 print ("eth service deletion\n")
1485 self.test_28_delete_eth_service1()
1487 def test_48_loop_create_oc_service(self):
1488 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1489 .format(self.restconf_baseurl))
1490 response = requests.request("GET", url, auth=('admin', 'admin'))
1491 if response.status_code != 404:
1492 url = ("{}/operations/org-openroadm-service:service-delete"
1493 .format(self.restconf_baseurl))
1495 "sdnc-request-header": {
1496 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1497 "rpc-action": "service-delete",
1498 "request-system-id": "appname",
1499 "notification-url": "http://localhost:8585/NotificationServer/notify"
1501 "service-delete-req-info": {
1502 "service-name": "service1",
1503 "tail-retention": "no"
1507 headers = {'content-type': 'application/json'}
1508 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1511 for i in range(1,6):
1512 print ("trial number {}".format(i))
1513 print("oc service creation")
1514 self.test_34_create_oc_service1()
1515 print ("check xc in ROADM-A1")
1516 self.test_36_check_xc1_ROADMA()
1517 print ("check xc in ROADM-C1")
1518 self.test_37_check_xc1_ROADMC()
1519 print ("oc service deletion\n")
1520 self.test_42_delete_oc_service1()
1523 def test_49_disconnect_XPDRA(self):
1524 url = ("{}/config/network-topology:"
1525 "network-topology/topology/topology-netconf/node/XPDR-A1"
1526 .format(self.restconf_baseurl))
1527 headers = {'content-type': 'application/json'}
1528 response = requests.request(
1529 "DELETE", url, headers=headers,
1530 auth=('admin', 'admin'))
1531 self.assertEqual(response.status_code, requests.codes.ok)
1534 def test_50_disconnect_XPDRC(self):
1535 url = ("{}/config/network-topology:"
1536 "network-topology/topology/topology-netconf/node/XPDR-C1"
1537 .format(self.restconf_baseurl))
1538 headers = {'content-type': 'application/json'}
1539 response = requests.request(
1540 "DELETE", url, headers=headers,
1541 auth=('admin', 'admin'))
1542 self.assertEqual(response.status_code, requests.codes.ok)
1545 def test_51_disconnect_ROADMA(self):
1546 url = ("{}/config/network-topology:"
1547 "network-topology/topology/topology-netconf/node/ROADM-A1"
1548 .format(self.restconf_baseurl))
1549 headers = {'content-type': 'application/json'}
1550 response = requests.request(
1551 "DELETE", url, headers=headers,
1552 auth=('admin', 'admin'))
1553 self.assertEqual(response.status_code, requests.codes.ok)
1556 def test_52_disconnect_ROADMC(self):
1557 url = ("{}/config/network-topology:"
1558 "network-topology/topology/topology-netconf/node/ROADM-C1"
1559 .format(self.restconf_baseurl))
1560 headers = {'content-type': 'application/json'}
1561 response = requests.request(
1562 "DELETE", url, headers=headers,
1563 auth=('admin', 'admin'))
1564 self.assertEqual(response.status_code, requests.codes.ok)
1568 if __name__ == "__main__":
1569 unittest.main(verbosity=2)