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.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, "17830", "sample_configs/openroadm/2.1/oper-XPDRA.xml"],
46 def __start_honeynode2(cls):
47 executable = ("./honeynode/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, "17831", "sample_configs/openroadm/2.1/oper-ROADMA-full.xml"],
56 def __start_honeynode3(cls):
57 executable = ("./honeynode/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, "17833", "sample_configs/openroadm/2.1/oper-ROADMC-full.xml"],
66 def __start_honeynode4(cls):
67 executable = ("./honeynode/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, "17834", "sample_configs/openroadm/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/XPDRA"
139 .format(self.restconf_baseurl))
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": "17830",
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/XPDRC"
158 .format(self.restconf_baseurl))
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": "17834",
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/ROADMA"
177 .format(self.restconf_baseurl))
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": "17831",
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/ROADMC"
196 .format(self.restconf_baseurl))
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": "17833",
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": "XPDRA",
218 "networkutils:xpdr-num": "1",
219 "networkutils:network-num": "1",
220 "networkutils:rdm-node": "ROADMA",
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": "XPDRA",
241 "networkutils:xpdr-num": "1",
242 "networkutils:network-num": "1",
243 "networkutils:rdm-node": "ROADMA",
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"])
258 def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
259 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
261 "networkutils:input": {
262 "networkutils:links-input": {
263 "networkutils:xpdr-node": "XPDRC",
264 "networkutils:xpdr-num": "1",
265 "networkutils:network-num": "1",
266 "networkutils:rdm-node": "ROADMC",
267 "networkutils:srg-num": "1",
268 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
272 headers = {'content-type': 'application/json'}
273 response = requests.request(
274 "POST", url, data=json.dumps(data),
275 headers=headers, auth=('admin', 'admin'))
276 self.assertEqual(response.status_code, requests.codes.ok)
277 res = response.json()
278 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
281 def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
282 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
284 "networkutils:input": {
285 "networkutils:links-input": {
286 "networkutils:xpdr-node": "XPDRC",
287 "networkutils:xpdr-num": "1",
288 "networkutils:network-num": "1",
289 "networkutils:rdm-node": "ROADMC",
290 "networkutils:srg-num": "1",
291 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
295 headers = {'content-type': 'application/json'}
296 response = requests.request(
297 "POST", url, data=json.dumps(data),
298 headers=headers, auth=('admin', 'admin'))
299 self.assertEqual(response.status_code, requests.codes.ok)
300 res = response.json()
301 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
304 def test_09_add_omsAttributes_ROADMA_ROADMC(self):
305 # Config ROADMA-ROADMC oms-attributes
306 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
307 "link/ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
308 "OMS-attributes/span"
309 .format(self.restconf_baseurl))
312 "auto-spanloss": "true",
313 "spanloss-base": 11.4,
314 "spanloss-current": 12,
315 "engineered-spanloss": 12.2,
316 "link-concatenation": [{
319 "SRLG-length": 100000,
321 headers = {'content-type': 'application/json'}
322 response = requests.request(
323 "PUT", url, data=json.dumps(data), headers=headers,
324 auth=('admin', 'admin'))
325 self.assertEqual(response.status_code, requests.codes.created)
327 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
328 # Config ROADMC-ROADMA oms-attributes
329 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
330 "link/ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
331 "OMS-attributes/span"
332 .format(self.restconf_baseurl))
335 "auto-spanloss": "true",
336 "spanloss-base": 11.4,
337 "spanloss-current": 12,
338 "engineered-spanloss": 12.2,
339 "link-concatenation": [{
342 "SRLG-length": 100000,
344 headers = {'content-type': 'application/json'}
345 response = requests.request(
346 "PUT", url, data=json.dumps(data), headers=headers,
347 auth=('admin', 'admin'))
348 self.assertEqual(response.status_code, requests.codes.created)
350 #test service-create for Eth service from xpdr to xpdr
351 def test_11_create_eth_service1(self):
352 url = ("{}/operations/org-openroadm-service:service-create"
353 .format(self.restconf_baseurl))
355 "sdnc-request-header": {
356 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
357 "rpc-action": "service-create",
358 "request-system-id": "appname",
359 "notification-url": "http://localhost:8585/NotificationServer/notify"
361 "service-name": "service1",
362 "common-id": "ASATT1234567",
363 "connection-type": "service",
365 "service-rate": "100",
367 "service-format": "Ethernet",
368 "clli": "SNJSCAMCJP8",
371 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
372 "port-type": "router",
373 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
374 "port-rack": "000000.00",
378 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
379 "lgx-port-name": "LGX Back.3",
380 "lgx-port-rack": "000000.00",
381 "lgx-port-shelf": "00"
386 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
387 "port-type": "router",
388 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
389 "port-rack": "000000.00",
393 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
394 "lgx-port-name": "LGX Back.4",
395 "lgx-port-rack": "000000.00",
396 "lgx-port-shelf": "00"
402 "service-rate": "100",
404 "service-format": "Ethernet",
405 "clli": "SNJSCAMCJT4",
408 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
409 "port-type": "router",
410 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
411 "port-rack": "000000.00",
415 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
416 "lgx-port-name": "LGX Back.29",
417 "lgx-port-rack": "000000.00",
418 "lgx-port-shelf": "00"
423 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
424 "port-type": "router",
425 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
426 "port-rack": "000000.00",
430 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
431 "lgx-port-name": "LGX Back.30",
432 "lgx-port-rack": "000000.00",
433 "lgx-port-shelf": "00"
438 "due-date": "2016-11-28T00:00:01Z",
439 "operator-contact": "pw1234"
442 headers = {'content-type': 'application/json',
443 "Accept": "application/json"}
444 response = requests.request(
445 "POST", url, data=json.dumps(data), headers=headers,
446 auth=('admin', 'admin'))
447 self.assertEqual(response.status_code, requests.codes.ok)
448 res = response.json()
449 self.assertIn('PCE calculation in progress',
450 res['output']['configuration-response-common']['response-message'])
451 time.sleep(self.WAITING)
453 def test_12_get_eth_service1(self):
454 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
455 .format(self.restconf_baseurl))
456 headers = {'content-type': 'application/json',
457 "Accept": "application/json"}
458 response = requests.request(
459 "GET", url, headers=headers, auth=('admin', 'admin'))
460 self.assertEqual(response.status_code, requests.codes.ok)
461 res = response.json()
463 res['services'][0]['administrative-state'],
466 res['services'][0]['service-name'], 'service1')
468 res['services'][0]['connection-type'], 'service')
470 res['services'][0]['lifecycle-state'], 'planned')
473 def test_13_check_xc1_ROADMA(self):
474 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
475 "node/ROADMA/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
476 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
477 .format(self.restconf_baseurl))
478 headers = {'content-type': 'application/json'}
479 response = requests.request(
480 "GET", url, headers=headers, auth=('admin', 'admin'))
481 self.assertEqual(response.status_code, requests.codes.ok)
482 res = response.json()
483 self.assertDictContainsSubset(
484 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
485 'wavelength-number': 1,
486 'opticalControlMode': 'gainLoss',
487 'target-output-power': -3.0},
488 res['roadm-connections'][0])
489 self.assertDictEqual(
490 {'src-if': 'SRG1-PP1-TXRX-1'},
491 res['roadm-connections'][0]['source'])
492 self.assertDictEqual(
493 {'dst-if': 'DEG1-TTP-TXRX-1'},
494 res['roadm-connections'][0]['destination'])
497 def test_14_check_xc1_ROADMC(self):
498 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
499 "node/ROADMC/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
500 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
501 .format(self.restconf_baseurl))
502 headers = {'content-type': 'application/json'}
503 response = requests.request(
504 "GET", url, headers=headers, auth=('admin', 'admin'))
505 self.assertEqual(response.status_code, requests.codes.ok)
506 res = response.json()
507 self.assertDictContainsSubset(
508 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
509 'wavelength-number': 1,
510 'opticalControlMode': 'gainLoss',
511 'target-output-power': 2.0},
512 res['roadm-connections'][0])
513 self.assertDictEqual(
514 {'src-if': 'SRG1-PP1-TXRX-1'},
515 res['roadm-connections'][0]['source'])
516 self.assertDictEqual(
517 {'dst-if': 'DEG2-TTP-TXRX-1'},
518 res['roadm-connections'][0]['destination'])
521 def test_15_check_topo_XPDRA(self):
522 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA-XPDR1"
523 .format(self.restconf_baseurl))
524 response = requests.request(
525 "GET", url1, auth=('admin', 'admin'))
526 self.assertEqual(response.status_code, requests.codes.ok)
527 res = response.json()
528 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
530 if ele['tp-id'] == 'XPDR1-NETWORK1':
531 self.assertEqual({u'frequency': 196.1, u'width': 40},
532 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
533 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
534 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
535 if ele['tp-id'] == 'XPDR1-NETWORK2':
536 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes']))
539 def test_16_check_topo_ROADMA_SRG1(self):
540 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA-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},
547 res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
548 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
550 if ele['tp-id'] == 'SRG1-PP1-TXRX':
551 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
552 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
553 if ele['tp-id'] == 'SRG1-PP2-TXRX':
554 self.assertNotIn('used-wavelength', dict.keys(ele))
557 def test_17_check_topo_ROADMA_DEG1(self):
558 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA-DEG1"
559 .format(self.restconf_baseurl))
560 response = requests.request(
561 "GET", url1, auth=('admin', 'admin'))
562 self.assertEqual(response.status_code, requests.codes.ok)
563 res = response.json()
564 self.assertNotIn({u'index': 1},
565 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
566 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
568 if ele['tp-id'] == 'DEG1-CTP-TXRX':
569 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
570 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
571 if ele['tp-id'] == 'DEG1-TTP-TXRX':
572 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
573 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
576 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
577 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
579 "networkutils:input": {
580 "networkutils:links-input": {
581 "networkutils:xpdr-node": "XPDRA",
582 "networkutils:xpdr-num": "1",
583 "networkutils:network-num": "2",
584 "networkutils:rdm-node": "ROADMA",
585 "networkutils:srg-num": "1",
586 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
590 headers = {'content-type': 'application/json'}
591 response = requests.request(
592 "POST", url, data=json.dumps(data),
593 headers=headers, auth=('admin', 'admin'))
594 self.assertEqual(response.status_code, requests.codes.ok)
595 res = response.json()
596 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
600 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
601 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
603 "networkutils:input": {
604 "networkutils:links-input": {
605 "networkutils:xpdr-node": "XPDRA",
606 "networkutils:xpdr-num": "1",
607 "networkutils:network-num": "2",
608 "networkutils:rdm-node": "ROADMA",
609 "networkutils:srg-num": "1",
610 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
614 headers = {'content-type': 'application/json'}
615 response = requests.request(
616 "POST", url, data=json.dumps(data),
617 headers=headers, auth=('admin', 'admin'))
618 self.assertEqual(response.status_code, requests.codes.ok)
619 res = response.json()
620 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
624 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
625 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
627 "networkutils:input": {
628 "networkutils:links-input": {
629 "networkutils:xpdr-node": "XPDRC",
630 "networkutils:xpdr-num": "1",
631 "networkutils:network-num": "2",
632 "networkutils:rdm-node": "ROADMC",
633 "networkutils:srg-num": "1",
634 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
638 headers = {'content-type': 'application/json'}
639 response = requests.request(
640 "POST", url, data=json.dumps(data),
641 headers=headers, auth=('admin', 'admin'))
642 self.assertEqual(response.status_code, requests.codes.ok)
643 res = response.json()
644 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
648 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
649 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
651 "networkutils:input": {
652 "networkutils:links-input": {
653 "networkutils:xpdr-node": "XPDRC",
654 "networkutils:xpdr-num": "1",
655 "networkutils:network-num": "2",
656 "networkutils:rdm-node": "ROADMC",
657 "networkutils:srg-num": "1",
658 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
662 headers = {'content-type': 'application/json'}
663 response = requests.request(
664 "POST", url, data=json.dumps(data),
665 headers=headers, auth=('admin', 'admin'))
666 self.assertEqual(response.status_code, requests.codes.ok)
667 res = response.json()
668 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
671 def test_22_create_eth_service2(self):
672 url = ("{}/operations/org-openroadm-service:service-create"
673 .format(self.restconf_baseurl))
675 "sdnc-request-header": {
676 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
677 "rpc-action": "service-create",
678 "request-system-id": "appname",
679 "notification-url": "http://localhost:8585/NotificationServer/notify"
681 "service-name": "service2",
682 "common-id": "ASATT1234567",
683 "connection-type": "service",
685 "service-rate": "100",
687 "service-format": "Ethernet",
688 "clli": "SNJSCAMCJP8",
691 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
692 "port-type": "router",
693 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
694 "port-rack": "000000.00",
698 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
699 "lgx-port-name": "LGX Back.3",
700 "lgx-port-rack": "000000.00",
701 "lgx-port-shelf": "00"
706 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
707 "port-type": "router",
708 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
709 "port-rack": "000000.00",
713 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
714 "lgx-port-name": "LGX Back.4",
715 "lgx-port-rack": "000000.00",
716 "lgx-port-shelf": "00"
722 "service-rate": "100",
724 "service-format": "Ethernet",
725 "clli": "SNJSCAMCJT4",
728 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
729 "port-type": "router",
730 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
731 "port-rack": "000000.00",
735 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
736 "lgx-port-name": "LGX Back.29",
737 "lgx-port-rack": "000000.00",
738 "lgx-port-shelf": "00"
743 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
744 "port-type": "router",
745 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
746 "port-rack": "000000.00",
750 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
751 "lgx-port-name": "LGX Back.30",
752 "lgx-port-rack": "000000.00",
753 "lgx-port-shelf": "00"
758 "due-date": "2016-11-28T00:00:01Z",
759 "operator-contact": "pw1234"
762 headers = {'content-type': 'application/json',
763 "Accept": "application/json"}
764 response = requests.request(
765 "POST", url, data=json.dumps(data), headers=headers,
766 auth=('admin', 'admin'))
767 self.assertEqual(response.status_code, requests.codes.ok)
768 res = response.json()
769 self.assertIn('PCE calculation in progress',
770 res['output']['configuration-response-common']['response-message'])
771 time.sleep(self.WAITING)
773 def test_23_get_eth_service2(self):
774 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
775 .format(self.restconf_baseurl))
776 headers = {'content-type': 'application/json',
777 "Accept": "application/json"}
778 response = requests.request(
779 "GET", url, headers=headers, auth=('admin', 'admin'))
780 self.assertEqual(response.status_code, requests.codes.ok)
781 res = response.json()
783 res['services'][0]['administrative-state'],
786 res['services'][0]['service-name'], 'service2')
788 res['services'][0]['connection-type'], 'service')
790 res['services'][0]['lifecycle-state'], 'planned')
793 def test_24_check_xc2_ROADMA(self):
794 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
795 "node/ROADMA/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
796 "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
797 .format(self.restconf_baseurl))
798 headers = {'content-type': 'application/json'}
799 response = requests.request(
800 "GET", url, headers=headers, auth=('admin', 'admin'))
801 self.assertEqual(response.status_code, requests.codes.ok)
802 res = response.json()
803 self.assertDictContainsSubset(
804 {'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
805 'wavelength-number': 2,
806 'opticalControlMode': 'power'},
807 res['roadm-connections'][0])
808 self.assertDictEqual(
809 {'src-if': 'DEG1-TTP-TXRX-2'},
810 res['roadm-connections'][0]['source'])
811 self.assertDictEqual(
812 {'dst-if': 'SRG1-PP2-TXRX-2'},
813 res['roadm-connections'][0]['destination'])
815 def test_25_check_topo_XPDRA(self):
816 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA-XPDR1"
817 .format(self.restconf_baseurl))
818 response = requests.request(
819 "GET", url1, auth=('admin', 'admin'))
820 self.assertEqual(response.status_code, requests.codes.ok)
821 res = response.json()
822 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
824 if ele['tp-id'] == 'XPDR1-NETWORK1':
825 self.assertEqual({u'frequency': 196.1, u'width': 40},
826 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
827 if ele['tp-id'] == 'XPDR1-NETWORK2':
828 self.assertEqual({u'frequency': 196.05, u'width': 40},
829 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
830 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
831 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
834 def test_26_check_topo_ROADMA_SRG1(self):
835 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA-SRG1"
836 .format(self.restconf_baseurl))
837 response = requests.request(
838 "GET", url1, auth=('admin', 'admin'))
839 self.assertEqual(response.status_code, requests.codes.ok)
840 res = response.json()
841 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
842 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
843 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
845 if ele['tp-id'] == 'SRG1-PP1-TXRX':
846 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
847 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
848 self.assertNotIn({u'index': 2, u'frequency': 196.05, u'width': 40},
849 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
850 if ele['tp-id'] == 'SRG1-PP2-TXRX':
851 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
852 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
853 self.assertNotIn({u'index': 1, u'frequency': 196.1, u'width': 40},
854 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
855 if ele['tp-id'] == 'SRG1-PP3-TXRX':
856 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
860 def test_27_check_topo_ROADMA_DEG1(self):
861 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA-DEG1"
862 .format(self.restconf_baseurl))
863 response = requests.request(
864 "GET", url1, auth=('admin', 'admin'))
865 self.assertEqual(response.status_code, requests.codes.ok)
866 res = response.json()
867 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
868 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
869 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
871 if ele['tp-id'] == 'DEG1-CTP-TXRX':
872 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
873 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
874 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
875 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
876 if ele['tp-id'] == 'DEG1-TTP-TXRX':
877 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
878 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
879 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
880 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
883 # creation service test on a non-available resource
884 def test_28_create_eth_service3(self):
885 url = ("{}/operations/org-openroadm-service:service-create"
886 .format(self.restconf_baseurl))
888 "sdnc-request-header": {
889 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
890 "rpc-action": "service-create",
891 "request-system-id": "appname",
892 "notification-url": "http://localhost:8585/NotificationServer/notify"
894 "service-name": "service3",
895 "common-id": "ASATT1234567",
896 "connection-type": "service",
898 "service-rate": "100",
900 "service-format": "Ethernet",
901 "clli": "SNJSCAMCJP8",
904 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
905 "port-type": "router",
906 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
907 "port-rack": "000000.00",
911 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
912 "lgx-port-name": "LGX Back.3",
913 "lgx-port-rack": "000000.00",
914 "lgx-port-shelf": "00"
919 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
920 "port-type": "router",
921 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
922 "port-rack": "000000.00",
926 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
927 "lgx-port-name": "LGX Back.4",
928 "lgx-port-rack": "000000.00",
929 "lgx-port-shelf": "00"
935 "service-rate": "100",
937 "service-format": "Ethernet",
938 "clli": "SNJSCAMCJT4",
941 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
942 "port-type": "router",
943 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
944 "port-rack": "000000.00",
948 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
949 "lgx-port-name": "LGX Back.29",
950 "lgx-port-rack": "000000.00",
951 "lgx-port-shelf": "00"
956 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
957 "port-type": "router",
958 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
959 "port-rack": "000000.00",
963 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
964 "lgx-port-name": "LGX Back.30",
965 "lgx-port-rack": "000000.00",
966 "lgx-port-shelf": "00"
971 "due-date": "2016-11-28T00:00:01Z",
972 "operator-contact": "pw1234"
975 headers = {'content-type': 'application/json',
976 "Accept": "application/json"}
977 response = requests.request(
978 "POST", url, data=json.dumps(data), headers=headers,
979 auth=('admin', 'admin'))
980 self.assertEqual(response.status_code, requests.codes.ok)
981 res = response.json()
982 self.assertIn('PCE calculation in progress',
983 res['output']['configuration-response-common']['response-message'])
984 self.assertIn('200', res['output']['configuration-response-common']['response-code'])
985 time.sleep(self.WAITING)
987 # add a test that check the openroadm-service-list still only contains 2 elements
989 def test_29_delete_eth_service3(self):
990 url = ("{}/operations/org-openroadm-service:service-delete"
991 .format(self.restconf_baseurl))
993 "sdnc-request-header": {
994 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
995 "rpc-action": "service-delete",
996 "request-system-id": "appname",
997 "notification-url": "http://localhost:8585/NotificationServer/notify"
999 "service-delete-req-info": {
1000 "service-name": "service3",
1001 "tail-retention": "no"
1005 headers = {'content-type': 'application/json'}
1006 response = requests.request(
1007 "POST", url, data=json.dumps(data), headers=headers,
1008 auth=('admin', 'admin'))
1009 self.assertEqual(response.status_code, requests.codes.ok)
1010 res = response.json()
1011 self.assertIn('Service \'service3\' does not exist in datastore',
1012 res['output']['configuration-response-common']['response-message'])
1013 self.assertIn('500', res['output']['configuration-response-common']['response-code'])
1016 def test_30_delete_eth_service1(self):
1017 url = ("{}/operations/org-openroadm-service:service-delete"
1018 .format(self.restconf_baseurl))
1020 "sdnc-request-header": {
1021 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1022 "rpc-action": "service-delete",
1023 "request-system-id": "appname",
1024 "notification-url": "http://localhost:8585/NotificationServer/notify"
1026 "service-delete-req-info": {
1027 "service-name": "service1",
1028 "tail-retention": "no"
1032 headers = {'content-type': 'application/json'}
1033 response = requests.request(
1034 "POST", url, data=json.dumps(data), headers=headers,
1035 auth=('admin', 'admin'))
1036 self.assertEqual(response.status_code, requests.codes.ok)
1037 res = response.json()
1038 self.assertIn('Renderer service delete in progress',
1039 res['output']['configuration-response-common']['response-message'])
1042 def test_31_delete_eth_service2(self):
1043 url = ("{}/operations/org-openroadm-service:service-delete"
1044 .format(self.restconf_baseurl))
1046 "sdnc-request-header": {
1047 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1048 "rpc-action": "service-delete",
1049 "request-system-id": "appname",
1050 "notification-url": "http://localhost:8585/NotificationServer/notify"
1052 "service-delete-req-info": {
1053 "service-name": "service2",
1054 "tail-retention": "no"
1058 headers = {'content-type': 'application/json'}
1059 response = requests.request(
1060 "POST", url, data=json.dumps(data), headers=headers,
1061 auth=('admin', 'admin'))
1062 self.assertEqual(response.status_code, requests.codes.ok)
1063 res = response.json()
1064 self.assertIn('Renderer service delete in progress',
1065 res['output']['configuration-response-common']['response-message'])
1068 def test_32_check_no_xc_ROADMA(self):
1069 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1070 "node/ROADMA/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1071 .format(self.restconf_baseurl))
1072 response = requests.request(
1073 "GET", url, auth=('admin', 'admin'))
1074 res = response.json()
1075 self.assertEqual(response.status_code, requests.codes.ok)
1076 self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1079 def test_33_check_topo_XPDRA(self):
1080 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA-XPDR1"
1081 .format(self.restconf_baseurl))
1082 response = requests.request(
1083 "GET", url1, auth=('admin', 'admin'))
1084 self.assertEqual(response.status_code, requests.codes.ok)
1085 res = response.json()
1086 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1087 for ele in liste_tp:
1088 if ((ele[u'org-openroadm-network-topology:tp-type'] == 'XPONDER-CLIENT')
1089 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1090 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
1091 elif ((ele[u'org-openroadm-network-topology:tp-type'] == 'XPONDER-NETWORK')
1092 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1093 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes']))
1096 def test_34_check_topo_ROADMA_SRG1(self):
1097 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA-SRG1"
1098 .format(self.restconf_baseurl))
1099 response = requests.request(
1100 "GET", url1, auth=('admin', 'admin'))
1101 self.assertEqual(response.status_code, requests.codes.ok)
1102 res = response.json()
1103 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1104 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1105 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1106 for ele in liste_tp:
1107 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1108 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1110 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1113 def test_35_check_topo_ROADMA_DEG1(self):
1114 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA-DEG1"
1115 .format(self.restconf_baseurl))
1116 response = requests.request(
1117 "GET", url1, auth=('admin', 'admin'))
1118 self.assertEqual(response.status_code, requests.codes.ok)
1119 res = response.json()
1120 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1121 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1122 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1123 for ele in liste_tp:
1124 if ele['tp-id'] == 'DEG1-CTP-TXRX':
1125 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1126 if ele['tp-id'] == 'DEG1-TTP-TXRX':
1127 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1131 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1132 def test_36_create_oc_service1(self):
1133 url = ("{}/operations/org-openroadm-service:service-create"
1134 .format(self.restconf_baseurl))
1136 "sdnc-request-header": {
1137 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1138 "rpc-action": "service-create",
1139 "request-system-id": "appname",
1140 "notification-url": "http://localhost:8585/NotificationServer/notify"
1142 "service-name": "service1",
1143 "common-id": "ASATT1234567",
1144 "connection-type": "roadm-line",
1146 "service-rate": "100",
1147 "node-id": "ROADMA",
1148 "service-format": "OC",
1149 "clli": "SNJSCAMCJP8",
1152 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1153 "port-type": "router",
1154 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1155 "port-rack": "000000.00",
1159 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1160 "lgx-port-name": "LGX Back.3",
1161 "lgx-port-rack": "000000.00",
1162 "lgx-port-shelf": "00"
1167 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1168 "port-type": "router",
1169 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1170 "port-rack": "000000.00",
1174 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1175 "lgx-port-name": "LGX Back.4",
1176 "lgx-port-rack": "000000.00",
1177 "lgx-port-shelf": "00"
1180 "optic-type": "gray"
1183 "service-rate": "100",
1184 "node-id": "ROADMC",
1185 "service-format": "OC",
1186 "clli": "SNJSCAMCJT4",
1189 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1190 "port-type": "router",
1191 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1192 "port-rack": "000000.00",
1196 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1197 "lgx-port-name": "LGX Back.29",
1198 "lgx-port-rack": "000000.00",
1199 "lgx-port-shelf": "00"
1204 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1205 "port-type": "router",
1206 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1207 "port-rack": "000000.00",
1211 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1212 "lgx-port-name": "LGX Back.30",
1213 "lgx-port-rack": "000000.00",
1214 "lgx-port-shelf": "00"
1217 "optic-type": "gray"
1219 "due-date": "2016-11-28T00:00:01Z",
1220 "operator-contact": "pw1234"
1223 headers = {'content-type': 'application/json',
1224 "Accept": "application/json"}
1225 response = requests.request(
1226 "POST", url, data=json.dumps(data), headers=headers,
1227 auth=('admin', 'admin'))
1228 self.assertEqual(response.status_code, requests.codes.ok)
1229 res = response.json()
1230 self.assertIn('PCE calculation in progress',
1231 res['output']['configuration-response-common']['response-message'])
1232 time.sleep(self.WAITING)
1234 def test_37_get_oc_service1(self):
1235 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1236 .format(self.restconf_baseurl))
1237 headers = {'content-type': 'application/json',
1238 "Accept": "application/json"}
1239 response = requests.request(
1240 "GET", url, headers=headers, auth=('admin', 'admin'))
1241 self.assertEqual(response.status_code, requests.codes.ok)
1242 res = response.json()
1244 res['services'][0]['administrative-state'],
1247 res['services'][0]['service-name'], 'service1')
1249 res['services'][0]['connection-type'], 'roadm-line')
1251 res['services'][0]['lifecycle-state'], 'planned')
1254 def test_38_check_xc1_ROADMA(self):
1255 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1256 "node/ROADMA/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1257 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1258 .format(self.restconf_baseurl))
1259 headers = {'content-type': 'application/json'}
1260 response = requests.request(
1261 "GET", url, headers=headers, auth=('admin', 'admin'))
1262 self.assertEqual(response.status_code, requests.codes.ok)
1263 res = response.json()
1264 self.assertDictContainsSubset(
1265 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1266 'wavelength-number': 1,
1267 'opticalControlMode': 'gainLoss',
1268 'target-output-power': -3.0},
1269 res['roadm-connections'][0])
1270 self.assertDictEqual(
1271 {'src-if': 'SRG1-PP1-TXRX-1'},
1272 res['roadm-connections'][0]['source'])
1273 self.assertDictEqual(
1274 {'dst-if': 'DEG1-TTP-TXRX-1'},
1275 res['roadm-connections'][0]['destination'])
1278 def test_39_check_xc1_ROADMC(self):
1279 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1280 "node/ROADMC/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1281 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1282 .format(self.restconf_baseurl))
1283 headers = {'content-type': 'application/json'}
1284 response = requests.request(
1285 "GET", url, headers=headers, auth=('admin', 'admin'))
1286 self.assertEqual(response.status_code, requests.codes.ok)
1287 res = response.json()
1288 self.assertDictContainsSubset(
1289 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1290 'wavelength-number': 1,
1291 'opticalControlMode': 'gainLoss',
1292 'target-output-power': 2.0},
1293 res['roadm-connections'][0])
1294 self.assertDictEqual(
1295 {'src-if': 'SRG1-PP1-TXRX-1'},
1296 res['roadm-connections'][0]['source'])
1297 self.assertDictEqual(
1298 {'dst-if': 'DEG2-TTP-TXRX-1'},
1299 res['roadm-connections'][0]['destination'])
1302 def test_40_create_oc_service2(self):
1303 url = ("{}/operations/org-openroadm-service:service-create"
1304 .format(self.restconf_baseurl))
1306 "sdnc-request-header": {
1307 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1308 "rpc-action": "service-create",
1309 "request-system-id": "appname",
1310 "notification-url": "http://localhost:8585/NotificationServer/notify"
1312 "service-name": "service2",
1313 "common-id": "ASATT1234567",
1314 "connection-type": "roadm-line",
1316 "service-rate": "100",
1317 "node-id": "ROADMA",
1318 "service-format": "OC",
1319 "clli": "SNJSCAMCJP8",
1322 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1323 "port-type": "router",
1324 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1325 "port-rack": "000000.00",
1329 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1330 "lgx-port-name": "LGX Back.3",
1331 "lgx-port-rack": "000000.00",
1332 "lgx-port-shelf": "00"
1337 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1338 "port-type": "router",
1339 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1340 "port-rack": "000000.00",
1344 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1345 "lgx-port-name": "LGX Back.4",
1346 "lgx-port-rack": "000000.00",
1347 "lgx-port-shelf": "00"
1350 "optic-type": "gray"
1353 "service-rate": "100",
1354 "node-id": "ROADMC",
1355 "service-format": "OC",
1356 "clli": "SNJSCAMCJT4",
1359 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1360 "port-type": "router",
1361 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1362 "port-rack": "000000.00",
1366 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1367 "lgx-port-name": "LGX Back.29",
1368 "lgx-port-rack": "000000.00",
1369 "lgx-port-shelf": "00"
1374 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1375 "port-type": "router",
1376 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1377 "port-rack": "000000.00",
1381 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1382 "lgx-port-name": "LGX Back.30",
1383 "lgx-port-rack": "000000.00",
1384 "lgx-port-shelf": "00"
1387 "optic-type": "gray"
1389 "due-date": "2016-11-28T00:00:01Z",
1390 "operator-contact": "pw1234"
1393 headers = {'content-type': 'application/json',
1394 "Accept": "application/json"}
1395 response = requests.request(
1396 "POST", url, data=json.dumps(data), headers=headers,
1397 auth=('admin', 'admin'))
1398 self.assertEqual(response.status_code, requests.codes.ok)
1399 res = response.json()
1400 self.assertIn('PCE calculation in progress',
1401 res['output']['configuration-response-common']['response-message'])
1402 time.sleep(self.WAITING)
1404 def test_41_get_oc_service2(self):
1405 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1406 .format(self.restconf_baseurl))
1407 headers = {'content-type': 'application/json',
1408 "Accept": "application/json"}
1409 response = requests.request(
1410 "GET", url, headers=headers, auth=('admin', 'admin'))
1411 self.assertEqual(response.status_code, requests.codes.ok)
1412 res = response.json()
1414 res['services'][0]['administrative-state'],
1417 res['services'][0]['service-name'], 'service2')
1419 res['services'][0]['connection-type'], 'roadm-line')
1421 res['services'][0]['lifecycle-state'], 'planned')
1424 def test_42_check_xc2_ROADMA(self):
1425 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1426 "node/ROADMA/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1427 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1428 .format(self.restconf_baseurl))
1429 headers = {'content-type': 'application/json'}
1430 response = requests.request(
1431 "GET", url, headers=headers, auth=('admin', 'admin'))
1432 self.assertEqual(response.status_code, requests.codes.ok)
1433 res = response.json()
1434 self.assertDictContainsSubset(
1435 {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1436 'wavelength-number': 2,
1437 'opticalControlMode': 'gainLoss',
1438 'target-output-power': -3.0},
1439 res['roadm-connections'][0])
1440 self.assertDictEqual(
1441 {'src-if': 'SRG1-PP2-TXRX-2'},
1442 res['roadm-connections'][0]['source'])
1443 self.assertDictEqual(
1444 {'dst-if': 'DEG1-TTP-TXRX-2'},
1445 res['roadm-connections'][0]['destination'])
1448 def test_43_check_topo_ROADMA(self):
1449 self.test_26_check_topo_ROADMA_SRG1()
1450 self.test_27_check_topo_ROADMA_DEG1()
1454 def test_44_delete_oc_service1(self):
1455 url = ("{}/operations/org-openroadm-service:service-delete"
1456 .format(self.restconf_baseurl))
1458 "sdnc-request-header": {
1459 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1460 "rpc-action": "service-delete",
1461 "request-system-id": "appname",
1462 "notification-url": "http://localhost:8585/NotificationServer/notify"
1464 "service-delete-req-info": {
1465 "service-name": "service1",
1466 "tail-retention": "no"
1470 headers = {'content-type': 'application/json'}
1471 response = requests.request(
1472 "POST", url, data=json.dumps(data), headers=headers,
1473 auth=('admin', 'admin'))
1474 self.assertEqual(response.status_code, requests.codes.ok)
1475 res = response.json()
1476 self.assertIn('Renderer service delete in progress',
1477 res['output']['configuration-response-common']['response-message'])
1480 def test_45_delete_oc_service2(self):
1481 url = ("{}/operations/org-openroadm-service:service-delete"
1482 .format(self.restconf_baseurl))
1484 "sdnc-request-header": {
1485 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1486 "rpc-action": "service-delete",
1487 "request-system-id": "appname",
1488 "notification-url": "http://localhost:8585/NotificationServer/notify"
1490 "service-delete-req-info": {
1491 "service-name": "service2",
1492 "tail-retention": "no"
1496 headers = {'content-type': 'application/json'}
1497 response = requests.request(
1498 "POST", url, data=json.dumps(data), headers=headers,
1499 auth=('admin', 'admin'))
1500 self.assertEqual(response.status_code, requests.codes.ok)
1501 res = response.json()
1502 self.assertIn('Renderer service delete in progress',
1503 res['output']['configuration-response-common']['response-message'])
1506 def test_46_get_no_oc_services(self):
1507 print ("start test")
1508 url = ("{}/operational/org-openroadm-service:service-list"
1509 .format(self.restconf_baseurl))
1510 headers = {'content-type': 'application/json',
1511 "Accept": "application/json"}
1512 response = requests.request(
1513 "GET", url, headers=headers, auth=('admin', 'admin'))
1514 self.assertEqual(response.status_code, requests.codes.not_found)
1515 res = response.json()
1517 {"error-type":"application", "error-tag":"data-missing",
1518 "error-message":"Request could not be completed because the relevant data model content does not exist"},
1519 res['errors']['error'])
1522 def test_47_get_no_xc_ROADMA(self):
1523 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1524 "/node/ROADMA/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1525 .format(self.restconf_baseurl))
1526 headers = {'content-type': 'application/json',
1527 "Accept": "application/json"}
1528 response = requests.request(
1529 "GET", url, headers=headers, auth=('admin', 'admin'))
1530 self.assertEqual(response.status_code, requests.codes.ok)
1531 res = response.json()
1532 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1535 def test_48_check_topo_ROADMA(self):
1536 self.test_34_check_topo_ROADMA_SRG1()
1537 self.test_35_check_topo_ROADMA_DEG1()
1539 def test_49_loop_create_eth_service(self):
1540 for i in range(1,6):
1541 print ("trial number {}".format(i))
1542 print("eth service creation")
1543 self.test_11_create_eth_service1()
1544 print ("check xc in ROADMA")
1545 self.test_13_check_xc1_ROADMA()
1546 print ("check xc in ROADMC")
1547 self.test_14_check_xc1_ROADMC()
1548 print ("eth service deletion\n")
1549 self.test_30_delete_eth_service1()
1551 def test_50_loop_create_oc_service(self):
1552 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1553 .format(self.restconf_baseurl))
1554 response = requests.request("GET", url, auth=('admin', 'admin'))
1555 if response.status_code != 404:
1556 url = ("{}/operations/org-openroadm-service:service-delete"
1557 .format(self.restconf_baseurl))
1559 "sdnc-request-header": {
1560 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1561 "rpc-action": "service-delete",
1562 "request-system-id": "appname",
1563 "notification-url": "http://localhost:8585/NotificationServer/notify"
1565 "service-delete-req-info": {
1566 "service-name": "service1",
1567 "tail-retention": "no"
1571 headers = {'content-type': 'application/json'}
1572 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1575 for i in range(1,6):
1576 print ("trial number {}".format(i))
1577 print("oc service creation")
1578 self.test_36_create_oc_service1()
1579 print ("check xc in ROADMA")
1580 self.test_38_check_xc1_ROADMA()
1581 print ("check xc in ROADMC")
1582 self.test_39_check_xc1_ROADMC()
1583 print ("oc service deletion\n")
1584 self.test_44_delete_oc_service1()
1587 def test_51_disconnect_XPDRA(self):
1588 url = ("{}/config/network-topology:"
1589 "network-topology/topology/topology-netconf/node/XPDRA"
1590 .format(self.restconf_baseurl))
1591 headers = {'content-type': 'application/json'}
1592 response = requests.request(
1593 "DELETE", url, headers=headers,
1594 auth=('admin', 'admin'))
1595 self.assertEqual(response.status_code, requests.codes.ok)
1598 def test_52_disconnect_XPDRC(self):
1599 url = ("{}/config/network-topology:"
1600 "network-topology/topology/topology-netconf/node/XPDRC"
1601 .format(self.restconf_baseurl))
1602 headers = {'content-type': 'application/json'}
1603 response = requests.request(
1604 "DELETE", url, headers=headers,
1605 auth=('admin', 'admin'))
1606 self.assertEqual(response.status_code, requests.codes.ok)
1609 def test_53_disconnect_ROADMA(self):
1610 url = ("{}/config/network-topology:"
1611 "network-topology/topology/topology-netconf/node/ROADMA"
1612 .format(self.restconf_baseurl))
1613 headers = {'content-type': 'application/json'}
1614 response = requests.request(
1615 "DELETE", url, headers=headers,
1616 auth=('admin', 'admin'))
1617 self.assertEqual(response.status_code, requests.codes.ok)
1620 def test_54_disconnect_ROADMC(self):
1621 url = ("{}/config/network-topology:"
1622 "network-topology/topology/topology-netconf/node/ROADMC"
1623 .format(self.restconf_baseurl))
1624 headers = {'content-type': 'application/json'}
1625 response = requests.request(
1626 "DELETE", url, headers=headers,
1627 auth=('admin', 'admin'))
1628 self.assertEqual(response.status_code, requests.codes.ok)
1632 if __name__ == "__main__":
1633 unittest.main(verbosity=2)