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 ##############################################################################
24 class TransportPCEFulltesting(unittest.TestCase):
27 honeynode_process1 = None
28 honeynode_process2 = None
29 honeynode_process3 = None
30 honeynode_process4 = None
31 restconf_baseurl = "http://localhost:8181/restconf"
32 WAITING = 20 # nominal value is 300
34 # START_IGNORE_XTESTING
38 print("starting honeynode1...")
39 cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
42 print("starting honeynode2...")
43 cls.honeynode_process2 = test_utils.start_roadma_honeynode()
46 print("starting honeynode3...")
47 cls.honeynode_process3 = test_utils.start_roadmc_honeynode()
50 print("starting honeynode4...")
51 cls.honeynode_process4 = test_utils.start_xpdrc_honeynode()
53 print("all honeynodes started")
55 print("starting opendaylight...")
56 cls.odl_process = test_utils.start_tpce()
58 print("opendaylight started")
61 def tearDownClass(cls):
62 for child in psutil.Process(cls.odl_process.pid).children():
63 child.send_signal(signal.SIGINT)
65 cls.odl_process.send_signal(signal.SIGINT)
66 cls.odl_process.wait()
67 for child in psutil.Process(cls.honeynode_process1.pid).children():
68 child.send_signal(signal.SIGINT)
70 cls.honeynode_process1.send_signal(signal.SIGINT)
71 cls.honeynode_process1.wait()
72 for child in psutil.Process(cls.honeynode_process2.pid).children():
73 child.send_signal(signal.SIGINT)
75 cls.honeynode_process2.send_signal(signal.SIGINT)
76 cls.honeynode_process2.wait()
77 for child in psutil.Process(cls.honeynode_process3.pid).children():
78 child.send_signal(signal.SIGINT)
80 cls.honeynode_process3.send_signal(signal.SIGINT)
81 cls.honeynode_process3.wait()
82 for child in psutil.Process(cls.honeynode_process4.pid).children():
83 child.send_signal(signal.SIGINT)
85 cls.honeynode_process4.send_signal(signal.SIGINT)
86 cls.honeynode_process4.wait()
87 print("all processes killed")
89 def setUp(self): # instruction executed before each test method
90 print("execution of {}".format(self.id().split(".")[-1]))
94 # connect netconf devices
95 def test_01_connect_xpdrA(self):
96 url = ("{}/config/network-topology:"
97 "network-topology/topology/topology-netconf/node/XPDR-A1"
98 .format(self.restconf_baseurl))
100 "node-id": "XPDR-A1",
101 "netconf-node-topology:username": "admin",
102 "netconf-node-topology:password": "admin",
103 "netconf-node-topology:host": "127.0.0.1",
104 "netconf-node-topology:port": "17840",
105 "netconf-node-topology:tcp-only": "false",
106 "netconf-node-topology:pass-through": {}}]}
107 headers = {'content-type': 'application/json'}
108 response = requests.request(
109 "PUT", url, data=json.dumps(data), headers=headers,
110 auth=('admin', 'admin'))
111 self.assertEqual(response.status_code, requests.codes.created)
114 def test_02_connect_xpdrC(self):
115 url = ("{}/config/network-topology:"
116 "network-topology/topology/topology-netconf/node/XPDR-C1"
117 .format(self.restconf_baseurl))
119 "node-id": "XPDR-C1",
120 "netconf-node-topology:username": "admin",
121 "netconf-node-topology:password": "admin",
122 "netconf-node-topology:host": "127.0.0.1",
123 "netconf-node-topology:port": "17844",
124 "netconf-node-topology:tcp-only": "false",
125 "netconf-node-topology:pass-through": {}}]}
126 headers = {'content-type': 'application/json'}
127 response = requests.request(
128 "PUT", url, data=json.dumps(data), headers=headers,
129 auth=('admin', 'admin'))
130 self.assertEqual(response.status_code, requests.codes.created)
133 def test_03_connect_rdmA(self):
134 url = ("{}/config/network-topology:"
135 "network-topology/topology/topology-netconf/node/ROADM-A1"
136 .format(self.restconf_baseurl))
138 "node-id": "ROADM-A1",
139 "netconf-node-topology:username": "admin",
140 "netconf-node-topology:password": "admin",
141 "netconf-node-topology:host": "127.0.0.1",
142 "netconf-node-topology:port": "17841",
143 "netconf-node-topology:tcp-only": "false",
144 "netconf-node-topology:pass-through": {}}]}
145 headers = {'content-type': 'application/json'}
146 response = requests.request(
147 "PUT", url, data=json.dumps(data), headers=headers,
148 auth=('admin', 'admin'))
149 self.assertEqual(response.status_code, requests.codes.created)
152 def test_04_connect_rdmC(self):
153 url = ("{}/config/network-topology:"
154 "network-topology/topology/topology-netconf/node/ROADM-C1"
155 .format(self.restconf_baseurl))
157 "node-id": "ROADM-C1",
158 "netconf-node-topology:username": "admin",
159 "netconf-node-topology:password": "admin",
160 "netconf-node-topology:host": "127.0.0.1",
161 "netconf-node-topology:port": "17843",
162 "netconf-node-topology:tcp-only": "false",
163 "netconf-node-topology:pass-through": {}}]}
164 headers = {'content-type': 'application/json'}
165 response = requests.request(
166 "PUT", url, data=json.dumps(data), headers=headers,
167 auth=('admin', 'admin'))
168 self.assertEqual(response.status_code, requests.codes.created)
171 def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
172 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
174 "networkutils:input": {
175 "networkutils:links-input": {
176 "networkutils:xpdr-node": "XPDR-A1",
177 "networkutils:xpdr-num": "1",
178 "networkutils:network-num": "1",
179 "networkutils:rdm-node": "ROADM-A1",
180 "networkutils:srg-num": "1",
181 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
185 headers = {'content-type': 'application/json'}
186 response = requests.request(
187 "POST", url, data=json.dumps(data),
188 headers=headers, auth=('admin', 'admin'))
189 self.assertEqual(response.status_code, requests.codes.ok)
190 res = response.json()
191 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
194 def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
195 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
197 "networkutils:input": {
198 "networkutils:links-input": {
199 "networkutils:xpdr-node": "XPDR-A1",
200 "networkutils:xpdr-num": "1",
201 "networkutils:network-num": "1",
202 "networkutils:rdm-node": "ROADM-A1",
203 "networkutils:srg-num": "1",
204 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
208 headers = {'content-type': 'application/json'}
209 response = requests.request(
210 "POST", url, data=json.dumps(data),
211 headers=headers, auth=('admin', 'admin'))
212 self.assertEqual(response.status_code, requests.codes.ok)
213 res = response.json()
214 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
217 def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
218 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
220 "networkutils:input": {
221 "networkutils:links-input": {
222 "networkutils:xpdr-node": "XPDR-C1",
223 "networkutils:xpdr-num": "1",
224 "networkutils:network-num": "1",
225 "networkutils:rdm-node": "ROADM-C1",
226 "networkutils:srg-num": "1",
227 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
231 headers = {'content-type': 'application/json'}
232 response = requests.request(
233 "POST", url, data=json.dumps(data),
234 headers=headers, auth=('admin', 'admin'))
235 self.assertEqual(response.status_code, requests.codes.ok)
236 res = response.json()
237 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
240 def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
241 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
243 "networkutils:input": {
244 "networkutils:links-input": {
245 "networkutils:xpdr-node": "XPDR-C1",
246 "networkutils:xpdr-num": "1",
247 "networkutils:network-num": "1",
248 "networkutils:rdm-node": "ROADM-C1",
249 "networkutils:srg-num": "1",
250 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
254 headers = {'content-type': 'application/json'}
255 response = requests.request(
256 "POST", url, data=json.dumps(data),
257 headers=headers, auth=('admin', 'admin'))
258 self.assertEqual(response.status_code, requests.codes.ok)
259 res = response.json()
260 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
263 def test_09_add_omsAttributes_ROADMA_ROADMC(self):
264 # Config ROADMA-ROADMC oms-attributes
265 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
266 "link/ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
267 "OMS-attributes/span"
268 .format(self.restconf_baseurl))
270 "auto-spanloss": "true",
271 "spanloss-base": 11.4,
272 "spanloss-current": 12,
273 "engineered-spanloss": 12.2,
274 "link-concatenation": [{
277 "SRLG-length": 100000,
279 headers = {'content-type': 'application/json'}
280 response = requests.request(
281 "PUT", url, data=json.dumps(data), headers=headers,
282 auth=('admin', 'admin'))
283 self.assertEqual(response.status_code, requests.codes.created)
285 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
286 # Config ROADMC-ROADMA oms-attributes
287 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
288 "link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
289 "OMS-attributes/span"
290 .format(self.restconf_baseurl))
292 "auto-spanloss": "true",
293 "spanloss-base": 11.4,
294 "spanloss-current": 12,
295 "engineered-spanloss": 12.2,
296 "link-concatenation": [{
299 "SRLG-length": 100000,
301 headers = {'content-type': 'application/json'}
302 response = requests.request(
303 "PUT", url, data=json.dumps(data), headers=headers,
304 auth=('admin', 'admin'))
305 self.assertEqual(response.status_code, requests.codes.created)
307 # test service-create for Eth service from xpdr to xpdr
308 def test_11_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_12_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'], 'inService')
422 res['services'][0]['service-name'], 'service1')
424 res['services'][0]['connection-type'], 'service')
426 res['services'][0]['lifecycle-state'], 'planned')
429 def test_13_check_xc1_ROADMA(self):
430 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
431 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
432 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
433 .format(self.restconf_baseurl))
434 headers = {'content-type': 'application/json'}
435 response = requests.request(
436 "GET", url, headers=headers, auth=('admin', 'admin'))
437 self.assertEqual(response.status_code, requests.codes.ok)
438 res = response.json()
439 self.assertDictContainsSubset(
440 {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
441 'opticalControlMode': 'gainLoss',
442 'target-output-power': -3.0},
443 res['roadm-connections'][0])
444 self.assertDictEqual(
445 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
446 res['roadm-connections'][0]['source'])
447 self.assertDictEqual(
448 {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
449 res['roadm-connections'][0]['destination'])
452 def test_14_check_xc1_ROADMC(self):
453 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
454 "node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
455 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
456 .format(self.restconf_baseurl))
457 headers = {'content-type': '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()
462 self.assertDictContainsSubset(
463 {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
464 'opticalControlMode': 'gainLoss',
465 'target-output-power': -3.0},
466 res['roadm-connections'][0])
467 self.assertDictEqual(
468 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
469 res['roadm-connections'][0]['source'])
470 self.assertDictEqual(
471 {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
472 res['roadm-connections'][0]['destination'])
475 def test_15_check_topo_XPDRA(self):
476 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
477 .format(self.restconf_baseurl))
478 response = requests.request(
479 "GET", url1, auth=('admin', 'admin'))
480 self.assertEqual(response.status_code, requests.codes.ok)
481 res = response.json()
482 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
484 if ele['tp-id'] == 'XPDR1-NETWORK1':
485 self.assertEqual({u'frequency': 196.1,
487 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
488 if ele['tp-id'] == 'XPDR1-CLIENT2' or ele['tp-id'] == 'XPDR1-CLIENT1':
489 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
490 if ele['tp-id'] == 'XPDR1-NETWORK2':
491 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
494 def test_16_check_topo_ROADMA_SRG1(self):
495 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
496 .format(self.restconf_baseurl))
497 response = requests.request(
498 "GET", url1, auth=('admin', 'admin'))
499 self.assertEqual(response.status_code, requests.codes.ok)
500 res = response.json()
501 self.assertNotIn({u'index': 1},
502 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, u'frequency': 196.1,
508 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
509 if ele['tp-id'] == 'SRG1-PP2-TXRX':
510 self.assertNotIn('used-wavelength', dict.keys(ele))
513 def test_17_check_topo_ROADMA_DEG1(self):
514 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
515 .format(self.restconf_baseurl))
516 response = requests.request(
517 "GET", url1, auth=('admin', 'admin'))
518 self.assertEqual(response.status_code, requests.codes.ok)
519 res = response.json()
520 self.assertNotIn({u'index': 1},
521 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
522 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
524 if ele['tp-id'] == 'DEG2-CTP-TXRX':
525 self.assertIn({u'index': 1, u'frequency': 196.1,
527 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
528 if ele['tp-id'] == 'DEG2-TTP-TXRX':
529 self.assertIn({u'index': 1, u'frequency': 196.1,
531 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
534 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
535 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
537 "networkutils:input": {
538 "networkutils:links-input": {
539 "networkutils:xpdr-node": "XPDR-A1",
540 "networkutils:xpdr-num": "1",
541 "networkutils:network-num": "2",
542 "networkutils:rdm-node": "ROADM-A1",
543 "networkutils:srg-num": "1",
544 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
548 headers = {'content-type': 'application/json'}
549 response = requests.request(
550 "POST", url, data=json.dumps(data),
551 headers=headers, auth=('admin', 'admin'))
552 self.assertEqual(response.status_code, requests.codes.ok)
553 res = response.json()
554 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
557 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
558 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
560 "networkutils:input": {
561 "networkutils:links-input": {
562 "networkutils:xpdr-node": "XPDR-A1",
563 "networkutils:xpdr-num": "1",
564 "networkutils:network-num": "2",
565 "networkutils:rdm-node": "ROADM-A1",
566 "networkutils:srg-num": "1",
567 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
571 headers = {'content-type': 'application/json'}
572 response = requests.request(
573 "POST", url, data=json.dumps(data),
574 headers=headers, auth=('admin', 'admin'))
575 self.assertEqual(response.status_code, requests.codes.ok)
576 res = response.json()
577 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
580 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
581 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
583 "networkutils:input": {
584 "networkutils:links-input": {
585 "networkutils:xpdr-node": "XPDR-C1",
586 "networkutils:xpdr-num": "1",
587 "networkutils:network-num": "2",
588 "networkutils:rdm-node": "ROADM-C1",
589 "networkutils:srg-num": "1",
590 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
594 headers = {'content-type': 'application/json'}
595 response = requests.request(
596 "POST", url, data=json.dumps(data),
597 headers=headers, auth=('admin', 'admin'))
598 self.assertEqual(response.status_code, requests.codes.ok)
599 res = response.json()
600 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
603 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
604 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
606 "networkutils:input": {
607 "networkutils:links-input": {
608 "networkutils:xpdr-node": "XPDR-C1",
609 "networkutils:xpdr-num": "1",
610 "networkutils:network-num": "2",
611 "networkutils:rdm-node": "ROADM-C1",
612 "networkutils:srg-num": "1",
613 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
617 headers = {'content-type': 'application/json'}
618 response = requests.request(
619 "POST", url, data=json.dumps(data),
620 headers=headers, auth=('admin', 'admin'))
621 self.assertEqual(response.status_code, requests.codes.ok)
622 res = response.json()
623 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
626 def test_22_create_eth_service2(self):
627 url = ("{}/operations/org-openroadm-service:service-create"
628 .format(self.restconf_baseurl))
630 "sdnc-request-header": {
631 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
632 "rpc-action": "service-create",
633 "request-system-id": "appname",
634 "notification-url": "http://localhost:8585/NotificationServer/notify"
636 "service-name": "service2",
637 "common-id": "ASATT1234567",
638 "connection-type": "service",
640 "service-rate": "100",
641 "node-id": "XPDR-A1",
642 "service-format": "Ethernet",
643 "clli": "SNJSCAMCJP8",
646 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
647 "port-type": "router",
648 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
649 "port-rack": "000000.00",
653 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
654 "lgx-port-name": "LGX Back.3",
655 "lgx-port-rack": "000000.00",
656 "lgx-port-shelf": "00"
661 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
662 "port-type": "router",
663 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
664 "port-rack": "000000.00",
668 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
669 "lgx-port-name": "LGX Back.4",
670 "lgx-port-rack": "000000.00",
671 "lgx-port-shelf": "00"
677 "service-rate": "100",
678 "node-id": "XPDR-C1",
679 "service-format": "Ethernet",
680 "clli": "SNJSCAMCJT4",
683 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
684 "port-type": "router",
685 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
686 "port-rack": "000000.00",
690 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
691 "lgx-port-name": "LGX Back.29",
692 "lgx-port-rack": "000000.00",
693 "lgx-port-shelf": "00"
698 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
699 "port-type": "router",
700 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
701 "port-rack": "000000.00",
705 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
706 "lgx-port-name": "LGX Back.30",
707 "lgx-port-rack": "000000.00",
708 "lgx-port-shelf": "00"
713 "due-date": "2016-11-28T00:00:01Z",
714 "operator-contact": "pw1234"
717 headers = {'content-type': 'application/json',
718 "Accept": "application/json"}
719 response = requests.request(
720 "POST", url, data=json.dumps(data), headers=headers,
721 auth=('admin', 'admin'))
722 self.assertEqual(response.status_code, requests.codes.ok)
723 res = response.json()
724 self.assertIn('PCE calculation in progress',
725 res['output']['configuration-response-common']['response-message'])
726 time.sleep(self.WAITING)
728 def test_23_get_eth_service2(self):
729 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
730 .format(self.restconf_baseurl))
731 headers = {'content-type': 'application/json',
732 "Accept": "application/json"}
733 response = requests.request(
734 "GET", url, headers=headers, auth=('admin', 'admin'))
735 self.assertEqual(response.status_code, requests.codes.ok)
736 res = response.json()
738 res['services'][0]['administrative-state'],
741 res['services'][0]['service-name'], 'service2')
743 res['services'][0]['connection-type'], 'service')
745 res['services'][0]['lifecycle-state'], 'planned')
748 def test_24_check_xc2_ROADMA(self):
749 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
750 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
751 "roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-2"
752 .format(self.restconf_baseurl))
753 headers = {'content-type': 'application/json'}
754 response = requests.request(
755 "GET", url, headers=headers, auth=('admin', 'admin'))
756 self.assertEqual(response.status_code, requests.codes.ok)
757 res = response.json()
758 self.assertDictContainsSubset(
759 {'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-2',
760 'opticalControlMode': 'power'},
761 res['roadm-connections'][0])
762 self.assertDictEqual(
763 {'src-if': 'DEG2-TTP-TXRX-nmc-2'},
764 res['roadm-connections'][0]['source'])
765 self.assertDictEqual(
766 {'dst-if': 'SRG1-PP2-TXRX-nmc-2'},
767 res['roadm-connections'][0]['destination'])
769 def test_25_check_topo_XPDRA(self):
770 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
771 .format(self.restconf_baseurl))
772 response = requests.request(
773 "GET", url1, auth=('admin', 'admin'))
774 self.assertEqual(response.status_code, requests.codes.ok)
775 res = response.json()
776 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
778 if ele['tp-id'] == 'XPDR1-NETWORK1':
779 self.assertEqual({u'frequency': 196.1,
781 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
782 if ele['tp-id'] == 'XPDR1-NETWORK2':
783 self.assertEqual({u'frequency': 196.05,
785 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
786 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT2':
787 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
790 def test_26_check_topo_ROADMA_SRG1(self):
791 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
792 .format(self.restconf_baseurl))
793 response = requests.request(
794 "GET", url1, auth=('admin', 'admin'))
795 self.assertEqual(response.status_code, requests.codes.ok)
796 res = response.json()
797 self.assertNotIn({u'index': 1}, res['node'][0]
798 [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
799 self.assertNotIn({u'index': 2}, res['node'][0]
800 [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
801 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
803 if ele['tp-id'] == 'SRG1-PP1-TXRX':
804 self.assertIn({u'index': 1, u'frequency': 196.1,
806 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
807 self.assertNotIn({u'index': 2, u'frequency': 196.05,
809 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
810 if ele['tp-id'] == 'SRG1-PP2-TXRX':
811 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
812 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
813 self.assertNotIn({u'index': 1, u'frequency': 196.1,
815 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
816 if ele['tp-id'] == 'SRG1-PP3-TXRX':
817 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
820 def test_27_check_topo_ROADMA_DEG2(self):
821 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
822 .format(self.restconf_baseurl))
823 response = requests.request(
824 "GET", url1, auth=('admin', 'admin'))
825 self.assertEqual(response.status_code, requests.codes.ok)
826 res = response.json()
827 self.assertNotIn({u'index': 1}, res['node'][0]
828 [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
829 self.assertNotIn({u'index': 2}, res['node'][0]
830 [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
831 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
833 if ele['tp-id'] == 'DEG2-CTP-TXRX':
834 self.assertIn({u'index': 1, u'frequency': 196.1,
836 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
837 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
838 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
839 if ele['tp-id'] == 'DEG2-TTP-TXRX':
840 self.assertIn({u'index': 1, u'frequency': 196.1,
842 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
843 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
844 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
847 # creation service test on a non-available resource
848 def test_28_create_eth_service3(self):
849 url = ("{}/operations/org-openroadm-service:service-create"
850 .format(self.restconf_baseurl))
852 "sdnc-request-header": {
853 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
854 "rpc-action": "service-create",
855 "request-system-id": "appname",
856 "notification-url": "http://localhost:8585/NotificationServer/notify"
858 "service-name": "service3",
859 "common-id": "ASATT1234567",
860 "connection-type": "service",
862 "service-rate": "100",
863 "node-id": "XPDR-A1",
864 "service-format": "Ethernet",
865 "clli": "SNJSCAMCJP8",
868 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
869 "port-type": "router",
870 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
871 "port-rack": "000000.00",
875 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
876 "lgx-port-name": "LGX Back.3",
877 "lgx-port-rack": "000000.00",
878 "lgx-port-shelf": "00"
883 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
884 "port-type": "router",
885 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
886 "port-rack": "000000.00",
890 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
891 "lgx-port-name": "LGX Back.4",
892 "lgx-port-rack": "000000.00",
893 "lgx-port-shelf": "00"
899 "service-rate": "100",
900 "node-id": "XPDR-C1",
901 "service-format": "Ethernet",
902 "clli": "SNJSCAMCJT4",
905 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
906 "port-type": "router",
907 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
908 "port-rack": "000000.00",
912 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
913 "lgx-port-name": "LGX Back.29",
914 "lgx-port-rack": "000000.00",
915 "lgx-port-shelf": "00"
920 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
921 "port-type": "router",
922 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
923 "port-rack": "000000.00",
927 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
928 "lgx-port-name": "LGX Back.30",
929 "lgx-port-rack": "000000.00",
930 "lgx-port-shelf": "00"
935 "due-date": "2016-11-28T00:00:01Z",
936 "operator-contact": "pw1234"
939 headers = {'content-type': 'application/json',
940 "Accept": "application/json"}
941 response = requests.request(
942 "POST", url, data=json.dumps(data), headers=headers,
943 auth=('admin', 'admin'))
944 self.assertEqual(response.status_code, requests.codes.ok)
945 res = response.json()
946 self.assertIn('PCE calculation in progress',
947 res['output']['configuration-response-common']['response-message'])
948 self.assertIn('200', res['output']['configuration-response-common']['response-code'])
949 time.sleep(self.WAITING)
951 # add a test that check the openroadm-service-list still only contains 2 elements
952 def test_29_delete_eth_service3(self):
953 url = ("{}/operations/org-openroadm-service:service-delete"
954 .format(self.restconf_baseurl))
956 "sdnc-request-header": {
957 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
958 "rpc-action": "service-delete",
959 "request-system-id": "appname",
960 "notification-url": "http://localhost:8585/NotificationServer/notify"
962 "service-delete-req-info": {
963 "service-name": "service3",
964 "tail-retention": "no"
968 headers = {'content-type': 'application/json'}
969 response = requests.request(
970 "POST", url, data=json.dumps(data), headers=headers,
971 auth=('admin', 'admin'))
972 self.assertEqual(response.status_code, requests.codes.ok)
973 res = response.json()
974 self.assertIn('Service \'service3\' does not exist in datastore',
975 res['output']['configuration-response-common']['response-message'])
976 self.assertIn('500', res['output']['configuration-response-common']['response-code'])
979 def test_30_delete_eth_service1(self):
980 url = ("{}/operations/org-openroadm-service:service-delete"
981 .format(self.restconf_baseurl))
983 "sdnc-request-header": {
984 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
985 "rpc-action": "service-delete",
986 "request-system-id": "appname",
987 "notification-url": "http://localhost:8585/NotificationServer/notify"
989 "service-delete-req-info": {
990 "service-name": "service1",
991 "tail-retention": "no"
995 headers = {'content-type': 'application/json'}
996 response = requests.request(
997 "POST", url, data=json.dumps(data), headers=headers,
998 auth=('admin', 'admin'))
999 self.assertEqual(response.status_code, requests.codes.ok)
1000 res = response.json()
1001 self.assertIn('Renderer service delete in progress',
1002 res['output']['configuration-response-common']['response-message'])
1005 def test_31_delete_eth_service2(self):
1006 url = ("{}/operations/org-openroadm-service:service-delete"
1007 .format(self.restconf_baseurl))
1009 "sdnc-request-header": {
1010 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1011 "rpc-action": "service-delete",
1012 "request-system-id": "appname",
1013 "notification-url": "http://localhost:8585/NotificationServer/notify"
1015 "service-delete-req-info": {
1016 "service-name": "service2",
1017 "tail-retention": "no"
1021 headers = {'content-type': 'application/json'}
1022 response = requests.request(
1023 "POST", url, data=json.dumps(data), headers=headers,
1024 auth=('admin', 'admin'))
1025 self.assertEqual(response.status_code, requests.codes.ok)
1026 res = response.json()
1027 self.assertIn('Renderer service delete in progress',
1028 res['output']['configuration-response-common']['response-message'])
1031 def test_32_check_no_xc_ROADMA(self):
1032 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1033 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1034 .format(self.restconf_baseurl))
1035 response = requests.request(
1036 "GET", url, auth=('admin', 'admin'))
1037 res = response.json()
1038 self.assertEqual(response.status_code, requests.codes.ok)
1039 self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1042 def test_33_check_topo_XPDRA(self):
1043 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
1044 .format(self.restconf_baseurl))
1045 response = requests.request(
1046 "GET", url1, auth=('admin', 'admin'))
1047 self.assertEqual(response.status_code, requests.codes.ok)
1048 res = response.json()
1049 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1050 for ele in liste_tp:
1051 if ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT':
1052 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
1053 elif (ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK'):
1054 self.assertIn(u'tail-equipment-id',
1055 dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1056 self.assertNotIn('wavelength', dict.keys(
1057 ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1060 def test_34_check_topo_ROADMA_SRG1(self):
1061 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
1062 .format(self.restconf_baseurl))
1063 response = requests.request(
1064 "GET", url1, auth=('admin', 'admin'))
1065 self.assertEqual(response.status_code, requests.codes.ok)
1066 res = response.json()
1067 self.assertIn({u'index': 1}, res['node'][0]
1068 [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1069 self.assertIn({u'index': 2}, res['node'][0]
1070 [u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1071 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1072 for ele in liste_tp:
1073 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1074 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1076 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1079 def test_35_check_topo_ROADMA_DEG2(self):
1080 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
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 self.assertIn({u'index': 1}, res['node'][0]
1087 [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1088 self.assertIn({u'index': 2}, res['node'][0]
1089 [u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1090 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1091 for ele in liste_tp:
1092 if ele['tp-id'] == 'DEG2-CTP-TXRX':
1093 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1094 if ele['tp-id'] == 'DEG2-TTP-TXRX':
1095 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1098 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1099 def test_36_create_oc_service1(self):
1100 url = ("{}/operations/org-openroadm-service:service-create"
1101 .format(self.restconf_baseurl))
1103 "sdnc-request-header": {
1104 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1105 "rpc-action": "service-create",
1106 "request-system-id": "appname",
1107 "notification-url": "http://localhost:8585/NotificationServer/notify"
1109 "service-name": "service1",
1110 "common-id": "ASATT1234567",
1111 "connection-type": "roadm-line",
1113 "service-rate": "100",
1114 "node-id": "ROADM-A1",
1115 "service-format": "OC",
1116 "clli": "SNJSCAMCJP8",
1119 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1120 "port-type": "router",
1121 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1122 "port-rack": "000000.00",
1126 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1127 "lgx-port-name": "LGX Back.3",
1128 "lgx-port-rack": "000000.00",
1129 "lgx-port-shelf": "00"
1134 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1135 "port-type": "router",
1136 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1137 "port-rack": "000000.00",
1141 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1142 "lgx-port-name": "LGX Back.4",
1143 "lgx-port-rack": "000000.00",
1144 "lgx-port-shelf": "00"
1147 "optic-type": "gray"
1150 "service-rate": "100",
1151 "node-id": "ROADM-C1",
1152 "service-format": "OC",
1153 "clli": "SNJSCAMCJT4",
1156 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1157 "port-type": "router",
1158 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1159 "port-rack": "000000.00",
1163 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1164 "lgx-port-name": "LGX Back.29",
1165 "lgx-port-rack": "000000.00",
1166 "lgx-port-shelf": "00"
1171 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1172 "port-type": "router",
1173 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1174 "port-rack": "000000.00",
1178 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1179 "lgx-port-name": "LGX Back.30",
1180 "lgx-port-rack": "000000.00",
1181 "lgx-port-shelf": "00"
1184 "optic-type": "gray"
1186 "due-date": "2016-11-28T00:00:01Z",
1187 "operator-contact": "pw1234"
1190 headers = {'content-type': 'application/json',
1191 "Accept": "application/json"}
1192 response = requests.request(
1193 "POST", url, data=json.dumps(data), headers=headers,
1194 auth=('admin', 'admin'))
1195 self.assertEqual(response.status_code, requests.codes.ok)
1196 res = response.json()
1197 self.assertIn('PCE calculation in progress',
1198 res['output']['configuration-response-common']['response-message'])
1199 time.sleep(self.WAITING)
1201 def test_37_get_oc_service1(self):
1202 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1203 .format(self.restconf_baseurl))
1204 headers = {'content-type': 'application/json',
1205 "Accept": "application/json"}
1206 response = requests.request(
1207 "GET", url, headers=headers, auth=('admin', 'admin'))
1208 self.assertEqual(response.status_code, requests.codes.ok)
1209 res = response.json()
1211 res['services'][0]['administrative-state'],
1214 res['services'][0]['service-name'], 'service1')
1216 res['services'][0]['connection-type'], 'roadm-line')
1218 res['services'][0]['lifecycle-state'], 'planned')
1221 def test_38_check_xc1_ROADMA(self):
1222 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1223 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1224 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1225 .format(self.restconf_baseurl))
1226 headers = {'content-type': 'application/json'}
1227 response = requests.request(
1228 "GET", url, headers=headers, auth=('admin', 'admin'))
1229 self.assertEqual(response.status_code, requests.codes.ok)
1230 res = response.json()
1231 self.assertDictContainsSubset(
1232 {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1233 'opticalControlMode': 'gainLoss',
1234 'target-output-power': -3.0},
1235 res['roadm-connections'][0])
1236 self.assertDictEqual(
1237 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
1238 res['roadm-connections'][0]['source'])
1239 self.assertDictEqual(
1240 {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
1241 res['roadm-connections'][0]['destination'])
1244 def test_39_check_xc1_ROADMC(self):
1245 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1246 "node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1247 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1248 .format(self.restconf_baseurl))
1249 headers = {'content-type': 'application/json'}
1250 response = requests.request(
1251 "GET", url, headers=headers, auth=('admin', 'admin'))
1252 self.assertEqual(response.status_code, requests.codes.ok)
1253 res = response.json()
1254 self.assertDictContainsSubset(
1255 {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1256 'opticalControlMode': 'gainLoss',
1257 'target-output-power': -3.0},
1258 res['roadm-connections'][0])
1259 self.assertDictEqual(
1260 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
1261 res['roadm-connections'][0]['source'])
1262 self.assertDictEqual(
1263 {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
1264 res['roadm-connections'][0]['destination'])
1267 def test_40_create_oc_service2(self):
1268 url = ("{}/operations/org-openroadm-service:service-create"
1269 .format(self.restconf_baseurl))
1271 "sdnc-request-header": {
1272 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1273 "rpc-action": "service-create",
1274 "request-system-id": "appname",
1275 "notification-url": "http://localhost:8585/NotificationServer/notify"
1277 "service-name": "service2",
1278 "common-id": "ASATT1234567",
1279 "connection-type": "roadm-line",
1281 "service-rate": "100",
1282 "node-id": "ROADM-A1",
1283 "service-format": "OC",
1284 "clli": "SNJSCAMCJP8",
1287 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1288 "port-type": "router",
1289 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1290 "port-rack": "000000.00",
1294 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1295 "lgx-port-name": "LGX Back.3",
1296 "lgx-port-rack": "000000.00",
1297 "lgx-port-shelf": "00"
1302 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1303 "port-type": "router",
1304 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1305 "port-rack": "000000.00",
1309 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1310 "lgx-port-name": "LGX Back.4",
1311 "lgx-port-rack": "000000.00",
1312 "lgx-port-shelf": "00"
1315 "optic-type": "gray"
1318 "service-rate": "100",
1319 "node-id": "ROADM-C1",
1320 "service-format": "OC",
1321 "clli": "SNJSCAMCJT4",
1324 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1325 "port-type": "router",
1326 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1327 "port-rack": "000000.00",
1331 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1332 "lgx-port-name": "LGX Back.29",
1333 "lgx-port-rack": "000000.00",
1334 "lgx-port-shelf": "00"
1339 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1340 "port-type": "router",
1341 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1342 "port-rack": "000000.00",
1346 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1347 "lgx-port-name": "LGX Back.30",
1348 "lgx-port-rack": "000000.00",
1349 "lgx-port-shelf": "00"
1352 "optic-type": "gray"
1354 "due-date": "2016-11-28T00:00:01Z",
1355 "operator-contact": "pw1234"
1358 headers = {'content-type': 'application/json',
1359 "Accept": "application/json"}
1360 response = requests.request(
1361 "POST", url, data=json.dumps(data), headers=headers,
1362 auth=('admin', 'admin'))
1363 self.assertEqual(response.status_code, requests.codes.ok)
1364 res = response.json()
1365 self.assertIn('PCE calculation in progress',
1366 res['output']['configuration-response-common']['response-message'])
1367 time.sleep(self.WAITING)
1369 def test_41_get_oc_service2(self):
1370 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1371 .format(self.restconf_baseurl))
1372 headers = {'content-type': 'application/json',
1373 "Accept": "application/json"}
1374 response = requests.request(
1375 "GET", url, headers=headers, auth=('admin', 'admin'))
1376 self.assertEqual(response.status_code, requests.codes.ok)
1377 res = response.json()
1379 res['services'][0]['administrative-state'],
1382 res['services'][0]['service-name'], 'service2')
1384 res['services'][0]['connection-type'], 'roadm-line')
1386 res['services'][0]['lifecycle-state'], 'planned')
1389 def test_42_check_xc2_ROADMA(self):
1390 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1391 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1392 "roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-2"
1393 .format(self.restconf_baseurl))
1394 headers = {'content-type': 'application/json'}
1395 response = requests.request(
1396 "GET", url, headers=headers, auth=('admin', 'admin'))
1397 self.assertEqual(response.status_code, requests.codes.ok)
1398 res = response.json()
1399 self.assertDictContainsSubset(
1400 {'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-2',
1401 'opticalControlMode': 'gainLoss',
1402 'target-output-power': -3.0},
1403 res['roadm-connections'][0])
1404 self.assertDictEqual(
1405 {'src-if': 'SRG1-PP2-TXRX-nmc-2'},
1406 res['roadm-connections'][0]['source'])
1407 self.assertDictEqual(
1408 {'dst-if': 'DEG2-TTP-TXRX-nmc-2'},
1409 res['roadm-connections'][0]['destination'])
1412 def test_43_check_topo_ROADMA(self):
1413 self.test_26_check_topo_ROADMA_SRG1()
1414 self.test_27_check_topo_ROADMA_DEG2()
1417 def test_44_delete_oc_service1(self):
1418 url = ("{}/operations/org-openroadm-service:service-delete"
1419 .format(self.restconf_baseurl))
1421 "sdnc-request-header": {
1422 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1423 "rpc-action": "service-delete",
1424 "request-system-id": "appname",
1425 "notification-url": "http://localhost:8585/NotificationServer/notify"
1427 "service-delete-req-info": {
1428 "service-name": "service1",
1429 "tail-retention": "no"
1433 headers = {'content-type': 'application/json'}
1434 response = requests.request(
1435 "POST", url, data=json.dumps(data), headers=headers,
1436 auth=('admin', 'admin'))
1437 self.assertEqual(response.status_code, requests.codes.ok)
1438 res = response.json()
1439 self.assertIn('Renderer service delete in progress',
1440 res['output']['configuration-response-common']['response-message'])
1443 def test_45_delete_oc_service2(self):
1444 url = ("{}/operations/org-openroadm-service:service-delete"
1445 .format(self.restconf_baseurl))
1447 "sdnc-request-header": {
1448 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1449 "rpc-action": "service-delete",
1450 "request-system-id": "appname",
1451 "notification-url": "http://localhost:8585/NotificationServer/notify"
1453 "service-delete-req-info": {
1454 "service-name": "service2",
1455 "tail-retention": "no"
1459 headers = {'content-type': 'application/json'}
1460 response = requests.request(
1461 "POST", url, data=json.dumps(data), headers=headers,
1462 auth=('admin', 'admin'))
1463 self.assertEqual(response.status_code, requests.codes.ok)
1464 res = response.json()
1465 self.assertIn('Renderer service delete in progress',
1466 res['output']['configuration-response-common']['response-message'])
1469 def test_46_get_no_oc_services(self):
1471 url = ("{}/operational/org-openroadm-service:service-list"
1472 .format(self.restconf_baseurl))
1473 headers = {'content-type': 'application/json',
1474 "Accept": "application/json"}
1475 response = requests.request(
1476 "GET", url, headers=headers, auth=('admin', 'admin'))
1477 self.assertEqual(response.status_code, requests.codes.not_found)
1478 res = response.json()
1480 {"error-type": "application", "error-tag": "data-missing",
1481 "error-message": "Request could not be completed because the relevant data model content does not exist"},
1482 res['errors']['error'])
1485 def test_47_get_no_xc_ROADMA(self):
1486 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1487 "/node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1488 .format(self.restconf_baseurl))
1489 headers = {'content-type': 'application/json',
1490 "Accept": "application/json"}
1491 response = requests.request(
1492 "GET", url, headers=headers, auth=('admin', 'admin'))
1493 self.assertEqual(response.status_code, requests.codes.ok)
1494 res = response.json()
1495 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1498 def test_48_check_topo_ROADMA(self):
1499 self.test_34_check_topo_ROADMA_SRG1()
1500 self.test_35_check_topo_ROADMA_DEG2()
1502 def test_49_loop_create_eth_service(self):
1503 for i in range(1, 6):
1504 print("trial number {}".format(i))
1505 print("eth service creation")
1506 self.test_11_create_eth_service1()
1507 print("check xc in ROADM-A1")
1508 self.test_13_check_xc1_ROADMA()
1509 print("check xc in ROADM-C1")
1510 self.test_14_check_xc1_ROADMC()
1511 print("eth service deletion\n")
1512 self.test_30_delete_eth_service1()
1514 def test_50_loop_create_oc_service(self):
1515 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1516 .format(self.restconf_baseurl))
1517 response = requests.request("GET", url, auth=('admin', 'admin'))
1518 if response.status_code != 404:
1519 url = ("{}/operations/org-openroadm-service:service-delete"
1520 .format(self.restconf_baseurl))
1522 "sdnc-request-header": {
1523 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1524 "rpc-action": "service-delete",
1525 "request-system-id": "appname",
1526 "notification-url": "http://localhost:8585/NotificationServer/notify"
1528 "service-delete-req-info": {
1529 "service-name": "service1",
1530 "tail-retention": "no"
1534 headers = {'content-type': 'application/json'}
1535 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1538 for i in range(1, 6):
1539 print("trial number {}".format(i))
1540 print("oc service creation")
1541 self.test_36_create_oc_service1()
1542 print("check xc in ROADM-A1")
1543 self.test_38_check_xc1_ROADMA()
1544 print("check xc in ROADM-C1")
1545 self.test_39_check_xc1_ROADMC()
1546 print("oc service deletion\n")
1547 self.test_44_delete_oc_service1()
1549 def test_51_disconnect_XPDRA(self):
1550 url = ("{}/config/network-topology:"
1551 "network-topology/topology/topology-netconf/node/XPDR-A1"
1552 .format(self.restconf_baseurl))
1553 headers = {'content-type': 'application/json'}
1554 response = requests.request(
1555 "DELETE", url, headers=headers,
1556 auth=('admin', 'admin'))
1557 self.assertEqual(response.status_code, requests.codes.ok)
1560 def test_52_disconnect_XPDRC(self):
1561 url = ("{}/config/network-topology:"
1562 "network-topology/topology/topology-netconf/node/XPDR-C1"
1563 .format(self.restconf_baseurl))
1564 headers = {'content-type': 'application/json'}
1565 response = requests.request(
1566 "DELETE", url, headers=headers,
1567 auth=('admin', 'admin'))
1568 self.assertEqual(response.status_code, requests.codes.ok)
1571 def test_53_disconnect_ROADMA(self):
1572 url = ("{}/config/network-topology:"
1573 "network-topology/topology/topology-netconf/node/ROADM-A1"
1574 .format(self.restconf_baseurl))
1575 headers = {'content-type': 'application/json'}
1576 response = requests.request(
1577 "DELETE", url, headers=headers,
1578 auth=('admin', 'admin'))
1579 self.assertEqual(response.status_code, requests.codes.ok)
1582 def test_54_disconnect_ROADMC(self):
1583 url = ("{}/config/network-topology:"
1584 "network-topology/topology/topology-netconf/node/ROADM-C1"
1585 .format(self.restconf_baseurl))
1586 headers = {'content-type': 'application/json'}
1587 response = requests.request(
1588 "DELETE", url, headers=headers,
1589 auth=('admin', 'admin'))
1590 self.assertEqual(response.status_code, requests.codes.ok)
1594 if __name__ == "__main__":
1595 unittest.main(verbosity=2)