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))
271 "auto-spanloss": "true",
272 "spanloss-base": 11.4,
273 "spanloss-current": 12,
274 "engineered-spanloss": 12.2,
275 "link-concatenation": [{
278 "SRLG-length": 100000,
280 headers = {'content-type': 'application/json'}
281 response = requests.request(
282 "PUT", url, data=json.dumps(data), headers=headers,
283 auth=('admin', 'admin'))
284 self.assertEqual(response.status_code, requests.codes.created)
286 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
287 # Config ROADMC-ROADMA oms-attributes
288 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
289 "link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
290 "OMS-attributes/span"
291 .format(self.restconf_baseurl))
294 "auto-spanloss": "true",
295 "spanloss-base": 11.4,
296 "spanloss-current": 12,
297 "engineered-spanloss": 12.2,
298 "link-concatenation": [{
301 "SRLG-length": 100000,
303 headers = {'content-type': 'application/json'}
304 response = requests.request(
305 "PUT", url, data=json.dumps(data), headers=headers,
306 auth=('admin', 'admin'))
307 self.assertEqual(response.status_code, requests.codes.created)
309 #test service-create for Eth service from xpdr to xpdr
310 def test_11_create_eth_service1(self):
311 url = ("{}/operations/org-openroadm-service:service-create"
312 .format(self.restconf_baseurl))
314 "sdnc-request-header": {
315 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
316 "rpc-action": "service-create",
317 "request-system-id": "appname",
318 "notification-url": "http://localhost:8585/NotificationServer/notify"
320 "service-name": "service1",
321 "common-id": "ASATT1234567",
322 "connection-type": "service",
324 "service-rate": "100",
325 "node-id": "XPDR-A1",
326 "service-format": "Ethernet",
327 "clli": "SNJSCAMCJP8",
330 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
331 "port-type": "router",
332 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
333 "port-rack": "000000.00",
337 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
338 "lgx-port-name": "LGX Back.3",
339 "lgx-port-rack": "000000.00",
340 "lgx-port-shelf": "00"
345 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
346 "port-type": "router",
347 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
348 "port-rack": "000000.00",
352 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
353 "lgx-port-name": "LGX Back.4",
354 "lgx-port-rack": "000000.00",
355 "lgx-port-shelf": "00"
361 "service-rate": "100",
362 "node-id": "XPDR-C1",
363 "service-format": "Ethernet",
364 "clli": "SNJSCAMCJT4",
367 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
368 "port-type": "router",
369 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
370 "port-rack": "000000.00",
374 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
375 "lgx-port-name": "LGX Back.29",
376 "lgx-port-rack": "000000.00",
377 "lgx-port-shelf": "00"
382 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
383 "port-type": "router",
384 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
385 "port-rack": "000000.00",
389 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
390 "lgx-port-name": "LGX Back.30",
391 "lgx-port-rack": "000000.00",
392 "lgx-port-shelf": "00"
397 "due-date": "2016-11-28T00:00:01Z",
398 "operator-contact": "pw1234"
401 headers = {'content-type': 'application/json',
402 "Accept": "application/json"}
403 response = requests.request(
404 "POST", url, data=json.dumps(data), headers=headers,
405 auth=('admin', 'admin'))
406 self.assertEqual(response.status_code, requests.codes.ok)
407 res = response.json()
408 self.assertIn('PCE calculation in progress',
409 res['output']['configuration-response-common']['response-message'])
410 time.sleep(self.WAITING)
412 def test_12_get_eth_service1(self):
413 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
414 .format(self.restconf_baseurl))
415 headers = {'content-type': 'application/json',
416 "Accept": "application/json"}
417 response = requests.request(
418 "GET", url, headers=headers, auth=('admin', 'admin'))
419 self.assertEqual(response.status_code, requests.codes.ok)
420 res = response.json()
422 res['services'][0]['administrative-state'], 'inService')
424 res['services'][0]['service-name'], 'service1')
426 res['services'][0]['connection-type'], 'service')
428 res['services'][0]['lifecycle-state'], 'planned')
431 def test_13_check_xc1_ROADMA(self):
432 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
433 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
434 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
435 .format(self.restconf_baseurl))
436 headers = {'content-type': 'application/json'}
437 response = requests.request(
438 "GET", url, headers=headers, auth=('admin', 'admin'))
439 self.assertEqual(response.status_code, requests.codes.ok)
440 res = response.json()
441 self.assertDictContainsSubset(
442 {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
443 'opticalControlMode': 'gainLoss',
444 'target-output-power': -3.0},
445 res['roadm-connections'][0])
446 self.assertDictEqual(
447 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
448 res['roadm-connections'][0]['source'])
449 self.assertDictEqual(
450 {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
451 res['roadm-connections'][0]['destination'])
454 def test_14_check_xc1_ROADMC(self):
455 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
456 "node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
457 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
458 .format(self.restconf_baseurl))
459 headers = {'content-type': 'application/json'}
460 response = requests.request(
461 "GET", url, headers=headers, auth=('admin', 'admin'))
462 self.assertEqual(response.status_code, requests.codes.ok)
463 res = response.json()
464 self.assertDictContainsSubset(
465 {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
466 'opticalControlMode': 'gainLoss',
467 'target-output-power': -3.0},
468 res['roadm-connections'][0])
469 self.assertDictEqual(
470 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
471 res['roadm-connections'][0]['source'])
472 self.assertDictEqual(
473 {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
474 res['roadm-connections'][0]['destination'])
477 def test_15_check_topo_XPDRA(self):
478 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
479 .format(self.restconf_baseurl))
480 response = requests.request(
481 "GET", url1, auth=('admin', 'admin'))
482 self.assertEqual(response.status_code, requests.codes.ok)
483 res = response.json()
484 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
486 if ele['tp-id'] == 'XPDR1-NETWORK1':
487 self.assertEqual({u'frequency': 196.1,
489 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
490 if ele['tp-id'] == 'XPDR1-CLIENT2' or ele['tp-id'] == 'XPDR1-CLIENT1':
491 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
492 if ele['tp-id'] == 'XPDR1-NETWORK2':
493 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
496 def test_16_check_topo_ROADMA_SRG1(self):
497 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
498 .format(self.restconf_baseurl))
499 response = requests.request(
500 "GET", url1, auth=('admin', 'admin'))
501 self.assertEqual(response.status_code, requests.codes.ok)
502 res = response.json()
503 self.assertNotIn({u'index': 1},
504 res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
505 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
507 if ele['tp-id'] == 'SRG1-PP1-TXRX':
508 self.assertIn({u'index': 1, u'frequency': 196.1,
510 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
511 if ele['tp-id'] == 'SRG1-PP2-TXRX':
512 self.assertNotIn('used-wavelength', dict.keys(ele))
515 def test_17_check_topo_ROADMA_DEG1(self):
516 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
517 .format(self.restconf_baseurl))
518 response = requests.request(
519 "GET", url1, auth=('admin', 'admin'))
520 self.assertEqual(response.status_code, requests.codes.ok)
521 res = response.json()
522 self.assertNotIn({u'index': 1},
523 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
524 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
526 if ele['tp-id'] == 'DEG2-CTP-TXRX':
527 self.assertIn({u'index': 1, u'frequency': 196.1,
529 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
530 if ele['tp-id'] == 'DEG2-TTP-TXRX':
531 self.assertIn({u'index': 1, u'frequency': 196.1,
533 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
536 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
537 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
539 "networkutils:input": {
540 "networkutils:links-input": {
541 "networkutils:xpdr-node": "XPDR-A1",
542 "networkutils:xpdr-num": "1",
543 "networkutils:network-num": "2",
544 "networkutils:rdm-node": "ROADM-A1",
545 "networkutils:srg-num": "1",
546 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
550 headers = {'content-type': 'application/json'}
551 response = requests.request(
552 "POST", url, data=json.dumps(data),
553 headers=headers, auth=('admin', 'admin'))
554 self.assertEqual(response.status_code, requests.codes.ok)
555 res = response.json()
556 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
559 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
560 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
562 "networkutils:input": {
563 "networkutils:links-input": {
564 "networkutils:xpdr-node": "XPDR-A1",
565 "networkutils:xpdr-num": "1",
566 "networkutils:network-num": "2",
567 "networkutils:rdm-node": "ROADM-A1",
568 "networkutils:srg-num": "1",
569 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
573 headers = {'content-type': 'application/json'}
574 response = requests.request(
575 "POST", url, data=json.dumps(data),
576 headers=headers, auth=('admin', 'admin'))
577 self.assertEqual(response.status_code, requests.codes.ok)
578 res = response.json()
579 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
582 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
583 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
585 "networkutils:input": {
586 "networkutils:links-input": {
587 "networkutils:xpdr-node": "XPDR-C1",
588 "networkutils:xpdr-num": "1",
589 "networkutils:network-num": "2",
590 "networkutils:rdm-node": "ROADM-C1",
591 "networkutils:srg-num": "1",
592 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
596 headers = {'content-type': 'application/json'}
597 response = requests.request(
598 "POST", url, data=json.dumps(data),
599 headers=headers, auth=('admin', 'admin'))
600 self.assertEqual(response.status_code, requests.codes.ok)
601 res = response.json()
602 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
605 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
606 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
608 "networkutils:input": {
609 "networkutils:links-input": {
610 "networkutils:xpdr-node": "XPDR-C1",
611 "networkutils:xpdr-num": "1",
612 "networkutils:network-num": "2",
613 "networkutils:rdm-node": "ROADM-C1",
614 "networkutils:srg-num": "1",
615 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
619 headers = {'content-type': 'application/json'}
620 response = requests.request(
621 "POST", url, data=json.dumps(data),
622 headers=headers, auth=('admin', 'admin'))
623 self.assertEqual(response.status_code, requests.codes.ok)
624 res = response.json()
625 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
628 def test_22_create_eth_service2(self):
629 url = ("{}/operations/org-openroadm-service:service-create"
630 .format(self.restconf_baseurl))
632 "sdnc-request-header": {
633 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
634 "rpc-action": "service-create",
635 "request-system-id": "appname",
636 "notification-url": "http://localhost:8585/NotificationServer/notify"
638 "service-name": "service2",
639 "common-id": "ASATT1234567",
640 "connection-type": "service",
642 "service-rate": "100",
643 "node-id": "XPDR-A1",
644 "service-format": "Ethernet",
645 "clli": "SNJSCAMCJP8",
648 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
649 "port-type": "router",
650 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
651 "port-rack": "000000.00",
655 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
656 "lgx-port-name": "LGX Back.3",
657 "lgx-port-rack": "000000.00",
658 "lgx-port-shelf": "00"
663 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
664 "port-type": "router",
665 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
666 "port-rack": "000000.00",
670 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
671 "lgx-port-name": "LGX Back.4",
672 "lgx-port-rack": "000000.00",
673 "lgx-port-shelf": "00"
679 "service-rate": "100",
680 "node-id": "XPDR-C1",
681 "service-format": "Ethernet",
682 "clli": "SNJSCAMCJT4",
685 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
686 "port-type": "router",
687 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
688 "port-rack": "000000.00",
692 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
693 "lgx-port-name": "LGX Back.29",
694 "lgx-port-rack": "000000.00",
695 "lgx-port-shelf": "00"
700 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
701 "port-type": "router",
702 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
703 "port-rack": "000000.00",
707 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
708 "lgx-port-name": "LGX Back.30",
709 "lgx-port-rack": "000000.00",
710 "lgx-port-shelf": "00"
715 "due-date": "2016-11-28T00:00:01Z",
716 "operator-contact": "pw1234"
719 headers = {'content-type': 'application/json',
720 "Accept": "application/json"}
721 response = requests.request(
722 "POST", url, data=json.dumps(data), headers=headers,
723 auth=('admin', 'admin'))
724 self.assertEqual(response.status_code, requests.codes.ok)
725 res = response.json()
726 self.assertIn('PCE calculation in progress',
727 res['output']['configuration-response-common']['response-message'])
728 time.sleep(self.WAITING)
730 def test_23_get_eth_service2(self):
731 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
732 .format(self.restconf_baseurl))
733 headers = {'content-type': 'application/json',
734 "Accept": "application/json"}
735 response = requests.request(
736 "GET", url, headers=headers, auth=('admin', 'admin'))
737 self.assertEqual(response.status_code, requests.codes.ok)
738 res = response.json()
740 res['services'][0]['administrative-state'],
743 res['services'][0]['service-name'], 'service2')
745 res['services'][0]['connection-type'], 'service')
747 res['services'][0]['lifecycle-state'], 'planned')
750 def test_24_check_xc2_ROADMA(self):
751 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
752 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
753 "roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-2"
754 .format(self.restconf_baseurl))
755 headers = {'content-type': 'application/json'}
756 response = requests.request(
757 "GET", url, headers=headers, auth=('admin', 'admin'))
758 self.assertEqual(response.status_code, requests.codes.ok)
759 res = response.json()
760 self.assertDictContainsSubset(
761 {'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-2',
762 'opticalControlMode': 'power'},
763 res['roadm-connections'][0])
764 self.assertDictEqual(
765 {'src-if': 'DEG2-TTP-TXRX-nmc-2'},
766 res['roadm-connections'][0]['source'])
767 self.assertDictEqual(
768 {'dst-if': 'SRG1-PP2-TXRX-nmc-2'},
769 res['roadm-connections'][0]['destination'])
771 def test_25_check_topo_XPDRA(self):
772 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
773 .format(self.restconf_baseurl))
774 response = requests.request(
775 "GET", url1, auth=('admin', 'admin'))
776 self.assertEqual(response.status_code, requests.codes.ok)
777 res = response.json()
778 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
780 if ele['tp-id'] == 'XPDR1-NETWORK1':
781 self.assertEqual({u'frequency': 196.1,
783 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
784 if ele['tp-id'] == 'XPDR1-NETWORK2':
785 self.assertEqual({u'frequency': 196.05,
787 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
788 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT2':
789 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
792 def test_26_check_topo_ROADMA_SRG1(self):
793 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
794 .format(self.restconf_baseurl))
795 response = requests.request(
796 "GET", url1, auth=('admin', 'admin'))
797 self.assertEqual(response.status_code, requests.codes.ok)
798 res = response.json()
799 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
800 self.assertNotIn({u'index': 2}, res['node'][0][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][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
828 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
829 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
831 if ele['tp-id'] == 'DEG2-CTP-TXRX':
832 self.assertIn({u'index': 1, u'frequency': 196.1,
834 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
835 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
836 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
837 if ele['tp-id'] == 'DEG2-TTP-TXRX':
838 self.assertIn({u'index': 1, u'frequency': 196.1,
840 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
841 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
842 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
845 # creation service test on a non-available resource
846 def test_28_create_eth_service3(self):
847 url = ("{}/operations/org-openroadm-service:service-create"
848 .format(self.restconf_baseurl))
850 "sdnc-request-header": {
851 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
852 "rpc-action": "service-create",
853 "request-system-id": "appname",
854 "notification-url": "http://localhost:8585/NotificationServer/notify"
856 "service-name": "service3",
857 "common-id": "ASATT1234567",
858 "connection-type": "service",
860 "service-rate": "100",
861 "node-id": "XPDR-A1",
862 "service-format": "Ethernet",
863 "clli": "SNJSCAMCJP8",
866 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
867 "port-type": "router",
868 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
869 "port-rack": "000000.00",
873 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
874 "lgx-port-name": "LGX Back.3",
875 "lgx-port-rack": "000000.00",
876 "lgx-port-shelf": "00"
881 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
882 "port-type": "router",
883 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
884 "port-rack": "000000.00",
888 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
889 "lgx-port-name": "LGX Back.4",
890 "lgx-port-rack": "000000.00",
891 "lgx-port-shelf": "00"
897 "service-rate": "100",
898 "node-id": "XPDR-C1",
899 "service-format": "Ethernet",
900 "clli": "SNJSCAMCJT4",
903 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
904 "port-type": "router",
905 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
906 "port-rack": "000000.00",
910 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
911 "lgx-port-name": "LGX Back.29",
912 "lgx-port-rack": "000000.00",
913 "lgx-port-shelf": "00"
918 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
919 "port-type": "router",
920 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
921 "port-rack": "000000.00",
925 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
926 "lgx-port-name": "LGX Back.30",
927 "lgx-port-rack": "000000.00",
928 "lgx-port-shelf": "00"
933 "due-date": "2016-11-28T00:00:01Z",
934 "operator-contact": "pw1234"
937 headers = {'content-type': 'application/json',
938 "Accept": "application/json"}
939 response = requests.request(
940 "POST", url, data=json.dumps(data), headers=headers,
941 auth=('admin', 'admin'))
942 self.assertEqual(response.status_code, requests.codes.ok)
943 res = response.json()
944 self.assertIn('PCE calculation in progress',
945 res['output']['configuration-response-common']['response-message'])
946 self.assertIn('200', res['output']['configuration-response-common']['response-code'])
947 time.sleep(self.WAITING)
949 # add a test that check the openroadm-service-list still only contains 2 elements
951 def test_29_delete_eth_service3(self):
952 url = ("{}/operations/org-openroadm-service:service-delete"
953 .format(self.restconf_baseurl))
955 "sdnc-request-header": {
956 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
957 "rpc-action": "service-delete",
958 "request-system-id": "appname",
959 "notification-url": "http://localhost:8585/NotificationServer/notify"
961 "service-delete-req-info": {
962 "service-name": "service3",
963 "tail-retention": "no"
967 headers = {'content-type': 'application/json'}
968 response = requests.request(
969 "POST", url, data=json.dumps(data), headers=headers,
970 auth=('admin', 'admin'))
971 self.assertEqual(response.status_code, requests.codes.ok)
972 res = response.json()
973 self.assertIn('Service \'service3\' does not exist in datastore',
974 res['output']['configuration-response-common']['response-message'])
975 self.assertIn('500', res['output']['configuration-response-common']['response-code'])
978 def test_30_delete_eth_service1(self):
979 url = ("{}/operations/org-openroadm-service:service-delete"
980 .format(self.restconf_baseurl))
982 "sdnc-request-header": {
983 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
984 "rpc-action": "service-delete",
985 "request-system-id": "appname",
986 "notification-url": "http://localhost:8585/NotificationServer/notify"
988 "service-delete-req-info": {
989 "service-name": "service1",
990 "tail-retention": "no"
994 headers = {'content-type': 'application/json'}
995 response = requests.request(
996 "POST", url, data=json.dumps(data), headers=headers,
997 auth=('admin', 'admin'))
998 self.assertEqual(response.status_code, requests.codes.ok)
999 res = response.json()
1000 self.assertIn('Renderer service delete in progress',
1001 res['output']['configuration-response-common']['response-message'])
1004 def test_31_delete_eth_service2(self):
1005 url = ("{}/operations/org-openroadm-service:service-delete"
1006 .format(self.restconf_baseurl))
1008 "sdnc-request-header": {
1009 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1010 "rpc-action": "service-delete",
1011 "request-system-id": "appname",
1012 "notification-url": "http://localhost:8585/NotificationServer/notify"
1014 "service-delete-req-info": {
1015 "service-name": "service2",
1016 "tail-retention": "no"
1020 headers = {'content-type': 'application/json'}
1021 response = requests.request(
1022 "POST", url, data=json.dumps(data), headers=headers,
1023 auth=('admin', 'admin'))
1024 self.assertEqual(response.status_code, requests.codes.ok)
1025 res = response.json()
1026 self.assertIn('Renderer service delete in progress',
1027 res['output']['configuration-response-common']['response-message'])
1030 def test_32_check_no_xc_ROADMA(self):
1031 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1032 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1033 .format(self.restconf_baseurl))
1034 response = requests.request(
1035 "GET", url, auth=('admin', 'admin'))
1036 res = response.json()
1037 self.assertEqual(response.status_code, requests.codes.ok)
1038 self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1041 def test_33_check_topo_XPDRA(self):
1042 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDR-A1-XPDR1"
1043 .format(self.restconf_baseurl))
1044 response = requests.request(
1045 "GET", url1, auth=('admin', 'admin'))
1046 self.assertEqual(response.status_code, requests.codes.ok)
1047 res = response.json()
1048 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1049 for ele in liste_tp:
1050 if ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT':
1051 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
1052 elif (ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK'):
1053 self.assertIn(u'tail-equipment-id', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1054 self.assertNotIn('wavelength', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1057 def test_34_check_topo_ROADMA_SRG1(self):
1058 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-SRG1"
1059 .format(self.restconf_baseurl))
1060 response = requests.request(
1061 "GET", url1, auth=('admin', 'admin'))
1062 self.assertEqual(response.status_code, requests.codes.ok)
1063 res = response.json()
1064 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1065 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1066 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1067 for ele in liste_tp:
1068 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1069 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1071 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1074 def test_35_check_topo_ROADMA_DEG2(self):
1075 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADM-A1-DEG2"
1076 .format(self.restconf_baseurl))
1077 response = requests.request(
1078 "GET", url1, auth=('admin', 'admin'))
1079 self.assertEqual(response.status_code, requests.codes.ok)
1080 res = response.json()
1081 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1082 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1083 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1084 for ele in liste_tp:
1085 if ele['tp-id'] == 'DEG2-CTP-TXRX':
1086 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1087 if ele['tp-id'] == 'DEG2-TTP-TXRX':
1088 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1091 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1092 def test_36_create_oc_service1(self):
1093 url = ("{}/operations/org-openroadm-service:service-create"
1094 .format(self.restconf_baseurl))
1096 "sdnc-request-header": {
1097 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1098 "rpc-action": "service-create",
1099 "request-system-id": "appname",
1100 "notification-url": "http://localhost:8585/NotificationServer/notify"
1102 "service-name": "service1",
1103 "common-id": "ASATT1234567",
1104 "connection-type": "roadm-line",
1106 "service-rate": "100",
1107 "node-id": "ROADM-A1",
1108 "service-format": "OC",
1109 "clli": "SNJSCAMCJP8",
1112 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1113 "port-type": "router",
1114 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1115 "port-rack": "000000.00",
1119 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1120 "lgx-port-name": "LGX Back.3",
1121 "lgx-port-rack": "000000.00",
1122 "lgx-port-shelf": "00"
1127 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1128 "port-type": "router",
1129 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1130 "port-rack": "000000.00",
1134 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1135 "lgx-port-name": "LGX Back.4",
1136 "lgx-port-rack": "000000.00",
1137 "lgx-port-shelf": "00"
1140 "optic-type": "gray"
1143 "service-rate": "100",
1144 "node-id": "ROADM-C1",
1145 "service-format": "OC",
1146 "clli": "SNJSCAMCJT4",
1149 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1150 "port-type": "router",
1151 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1152 "port-rack": "000000.00",
1156 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1157 "lgx-port-name": "LGX Back.29",
1158 "lgx-port-rack": "000000.00",
1159 "lgx-port-shelf": "00"
1164 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1165 "port-type": "router",
1166 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1167 "port-rack": "000000.00",
1171 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1172 "lgx-port-name": "LGX Back.30",
1173 "lgx-port-rack": "000000.00",
1174 "lgx-port-shelf": "00"
1177 "optic-type": "gray"
1179 "due-date": "2016-11-28T00:00:01Z",
1180 "operator-contact": "pw1234"
1183 headers = {'content-type': 'application/json',
1184 "Accept": "application/json"}
1185 response = requests.request(
1186 "POST", url, data=json.dumps(data), headers=headers,
1187 auth=('admin', 'admin'))
1188 self.assertEqual(response.status_code, requests.codes.ok)
1189 res = response.json()
1190 self.assertIn('PCE calculation in progress',
1191 res['output']['configuration-response-common']['response-message'])
1192 time.sleep(self.WAITING)
1194 def test_37_get_oc_service1(self):
1195 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1196 .format(self.restconf_baseurl))
1197 headers = {'content-type': 'application/json',
1198 "Accept": "application/json"}
1199 response = requests.request(
1200 "GET", url, headers=headers, auth=('admin', 'admin'))
1201 self.assertEqual(response.status_code, requests.codes.ok)
1202 res = response.json()
1204 res['services'][0]['administrative-state'],
1207 res['services'][0]['service-name'], 'service1')
1209 res['services'][0]['connection-type'], 'roadm-line')
1211 res['services'][0]['lifecycle-state'], 'planned')
1214 def test_38_check_xc1_ROADMA(self):
1215 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1216 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1217 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1218 .format(self.restconf_baseurl))
1219 headers = {'content-type': 'application/json'}
1220 response = requests.request(
1221 "GET", url, headers=headers, auth=('admin', 'admin'))
1222 self.assertEqual(response.status_code, requests.codes.ok)
1223 res = response.json()
1224 self.assertDictContainsSubset(
1225 {'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1226 'opticalControlMode': 'gainLoss',
1227 'target-output-power': -3.0},
1228 res['roadm-connections'][0])
1229 self.assertDictEqual(
1230 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
1231 res['roadm-connections'][0]['source'])
1232 self.assertDictEqual(
1233 {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
1234 res['roadm-connections'][0]['destination'])
1237 def test_39_check_xc1_ROADMC(self):
1238 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1239 "node/ROADM-C1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1240 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1241 .format(self.restconf_baseurl))
1242 headers = {'content-type': 'application/json'}
1243 response = requests.request(
1244 "GET", url, headers=headers, auth=('admin', 'admin'))
1245 self.assertEqual(response.status_code, requests.codes.ok)
1246 res = response.json()
1247 self.assertDictContainsSubset(
1248 {'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1249 'opticalControlMode': 'gainLoss',
1250 'target-output-power': -3.0},
1251 res['roadm-connections'][0])
1252 self.assertDictEqual(
1253 {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
1254 res['roadm-connections'][0]['source'])
1255 self.assertDictEqual(
1256 {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
1257 res['roadm-connections'][0]['destination'])
1260 def test_40_create_oc_service2(self):
1261 url = ("{}/operations/org-openroadm-service:service-create"
1262 .format(self.restconf_baseurl))
1264 "sdnc-request-header": {
1265 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1266 "rpc-action": "service-create",
1267 "request-system-id": "appname",
1268 "notification-url": "http://localhost:8585/NotificationServer/notify"
1270 "service-name": "service2",
1271 "common-id": "ASATT1234567",
1272 "connection-type": "roadm-line",
1274 "service-rate": "100",
1275 "node-id": "ROADM-A1",
1276 "service-format": "OC",
1277 "clli": "SNJSCAMCJP8",
1280 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1281 "port-type": "router",
1282 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1283 "port-rack": "000000.00",
1287 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1288 "lgx-port-name": "LGX Back.3",
1289 "lgx-port-rack": "000000.00",
1290 "lgx-port-shelf": "00"
1295 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1296 "port-type": "router",
1297 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1298 "port-rack": "000000.00",
1302 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1303 "lgx-port-name": "LGX Back.4",
1304 "lgx-port-rack": "000000.00",
1305 "lgx-port-shelf": "00"
1308 "optic-type": "gray"
1311 "service-rate": "100",
1312 "node-id": "ROADM-C1",
1313 "service-format": "OC",
1314 "clli": "SNJSCAMCJT4",
1317 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1318 "port-type": "router",
1319 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1320 "port-rack": "000000.00",
1324 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1325 "lgx-port-name": "LGX Back.29",
1326 "lgx-port-rack": "000000.00",
1327 "lgx-port-shelf": "00"
1332 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1333 "port-type": "router",
1334 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1335 "port-rack": "000000.00",
1339 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1340 "lgx-port-name": "LGX Back.30",
1341 "lgx-port-rack": "000000.00",
1342 "lgx-port-shelf": "00"
1345 "optic-type": "gray"
1347 "due-date": "2016-11-28T00:00:01Z",
1348 "operator-contact": "pw1234"
1351 headers = {'content-type': 'application/json',
1352 "Accept": "application/json"}
1353 response = requests.request(
1354 "POST", url, data=json.dumps(data), headers=headers,
1355 auth=('admin', 'admin'))
1356 self.assertEqual(response.status_code, requests.codes.ok)
1357 res = response.json()
1358 self.assertIn('PCE calculation in progress',
1359 res['output']['configuration-response-common']['response-message'])
1360 time.sleep(self.WAITING)
1362 def test_41_get_oc_service2(self):
1363 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1364 .format(self.restconf_baseurl))
1365 headers = {'content-type': 'application/json',
1366 "Accept": "application/json"}
1367 response = requests.request(
1368 "GET", url, headers=headers, auth=('admin', 'admin'))
1369 self.assertEqual(response.status_code, requests.codes.ok)
1370 res = response.json()
1372 res['services'][0]['administrative-state'],
1375 res['services'][0]['service-name'], 'service2')
1377 res['services'][0]['connection-type'], 'roadm-line')
1379 res['services'][0]['lifecycle-state'], 'planned')
1382 def test_42_check_xc2_ROADMA(self):
1383 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1384 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1385 "roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-2"
1386 .format(self.restconf_baseurl))
1387 headers = {'content-type': 'application/json'}
1388 response = requests.request(
1389 "GET", url, headers=headers, auth=('admin', 'admin'))
1390 self.assertEqual(response.status_code, requests.codes.ok)
1391 res = response.json()
1392 self.assertDictContainsSubset(
1393 {'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-2',
1394 'opticalControlMode': 'gainLoss',
1395 'target-output-power': -3.0},
1396 res['roadm-connections'][0])
1397 self.assertDictEqual(
1398 {'src-if': 'SRG1-PP2-TXRX-nmc-2'},
1399 res['roadm-connections'][0]['source'])
1400 self.assertDictEqual(
1401 {'dst-if': 'DEG2-TTP-TXRX-nmc-2'},
1402 res['roadm-connections'][0]['destination'])
1405 def test_43_check_topo_ROADMA(self):
1406 self.test_26_check_topo_ROADMA_SRG1()
1407 self.test_27_check_topo_ROADMA_DEG2()
1410 def test_44_delete_oc_service1(self):
1411 url = ("{}/operations/org-openroadm-service:service-delete"
1412 .format(self.restconf_baseurl))
1414 "sdnc-request-header": {
1415 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1416 "rpc-action": "service-delete",
1417 "request-system-id": "appname",
1418 "notification-url": "http://localhost:8585/NotificationServer/notify"
1420 "service-delete-req-info": {
1421 "service-name": "service1",
1422 "tail-retention": "no"
1426 headers = {'content-type': 'application/json'}
1427 response = requests.request(
1428 "POST", url, data=json.dumps(data), headers=headers,
1429 auth=('admin', 'admin'))
1430 self.assertEqual(response.status_code, requests.codes.ok)
1431 res = response.json()
1432 self.assertIn('Renderer service delete in progress',
1433 res['output']['configuration-response-common']['response-message'])
1436 def test_45_delete_oc_service2(self):
1437 url = ("{}/operations/org-openroadm-service:service-delete"
1438 .format(self.restconf_baseurl))
1440 "sdnc-request-header": {
1441 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1442 "rpc-action": "service-delete",
1443 "request-system-id": "appname",
1444 "notification-url": "http://localhost:8585/NotificationServer/notify"
1446 "service-delete-req-info": {
1447 "service-name": "service2",
1448 "tail-retention": "no"
1452 headers = {'content-type': 'application/json'}
1453 response = requests.request(
1454 "POST", url, data=json.dumps(data), headers=headers,
1455 auth=('admin', 'admin'))
1456 self.assertEqual(response.status_code, requests.codes.ok)
1457 res = response.json()
1458 self.assertIn('Renderer service delete in progress',
1459 res['output']['configuration-response-common']['response-message'])
1462 def test_46_get_no_oc_services(self):
1463 print ("start test")
1464 url = ("{}/operational/org-openroadm-service:service-list"
1465 .format(self.restconf_baseurl))
1466 headers = {'content-type': 'application/json',
1467 "Accept": "application/json"}
1468 response = requests.request(
1469 "GET", url, headers=headers, auth=('admin', 'admin'))
1470 self.assertEqual(response.status_code, requests.codes.not_found)
1471 res = response.json()
1473 {"error-type":"application", "error-tag":"data-missing",
1474 "error-message":"Request could not be completed because the relevant data model content does not exist"},
1475 res['errors']['error'])
1478 def test_47_get_no_xc_ROADMA(self):
1479 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1480 "/node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1481 .format(self.restconf_baseurl))
1482 headers = {'content-type': 'application/json',
1483 "Accept": "application/json"}
1484 response = requests.request(
1485 "GET", url, headers=headers, auth=('admin', 'admin'))
1486 self.assertEqual(response.status_code, requests.codes.ok)
1487 res = response.json()
1488 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1491 def test_48_check_topo_ROADMA(self):
1492 self.test_34_check_topo_ROADMA_SRG1()
1493 self.test_35_check_topo_ROADMA_DEG2()
1495 def test_49_loop_create_eth_service(self):
1496 for i in range(1,6):
1497 print ("trial number {}".format(i))
1498 print("eth service creation")
1499 self.test_11_create_eth_service1()
1500 print ("check xc in ROADM-A1")
1501 self.test_13_check_xc1_ROADMA()
1502 print ("check xc in ROADM-C1")
1503 self.test_14_check_xc1_ROADMC()
1504 print ("eth service deletion\n")
1505 self.test_30_delete_eth_service1()
1507 def test_50_loop_create_oc_service(self):
1508 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1509 .format(self.restconf_baseurl))
1510 response = requests.request("GET", url, auth=('admin', 'admin'))
1511 if response.status_code != 404:
1512 url = ("{}/operations/org-openroadm-service:service-delete"
1513 .format(self.restconf_baseurl))
1515 "sdnc-request-header": {
1516 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1517 "rpc-action": "service-delete",
1518 "request-system-id": "appname",
1519 "notification-url": "http://localhost:8585/NotificationServer/notify"
1521 "service-delete-req-info": {
1522 "service-name": "service1",
1523 "tail-retention": "no"
1527 headers = {'content-type': 'application/json'}
1528 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1531 for i in range(1,6):
1532 print ("trial number {}".format(i))
1533 print("oc service creation")
1534 self.test_36_create_oc_service1()
1535 print ("check xc in ROADM-A1")
1536 self.test_38_check_xc1_ROADMA()
1537 print ("check xc in ROADM-C1")
1538 self.test_39_check_xc1_ROADMC()
1539 print ("oc service deletion\n")
1540 self.test_44_delete_oc_service1()
1542 def test_51_disconnect_XPDRA(self):
1543 url = ("{}/config/network-topology:"
1544 "network-topology/topology/topology-netconf/node/XPDR-A1"
1545 .format(self.restconf_baseurl))
1546 headers = {'content-type': 'application/json'}
1547 response = requests.request(
1548 "DELETE", url, headers=headers,
1549 auth=('admin', 'admin'))
1550 self.assertEqual(response.status_code, requests.codes.ok)
1553 def test_52_disconnect_XPDRC(self):
1554 url = ("{}/config/network-topology:"
1555 "network-topology/topology/topology-netconf/node/XPDR-C1"
1556 .format(self.restconf_baseurl))
1557 headers = {'content-type': 'application/json'}
1558 response = requests.request(
1559 "DELETE", url, headers=headers,
1560 auth=('admin', 'admin'))
1561 self.assertEqual(response.status_code, requests.codes.ok)
1564 def test_53_disconnect_ROADMA(self):
1565 url = ("{}/config/network-topology:"
1566 "network-topology/topology/topology-netconf/node/ROADM-A1"
1567 .format(self.restconf_baseurl))
1568 headers = {'content-type': 'application/json'}
1569 response = requests.request(
1570 "DELETE", url, headers=headers,
1571 auth=('admin', 'admin'))
1572 self.assertEqual(response.status_code, requests.codes.ok)
1575 def test_54_disconnect_ROADMC(self):
1576 url = ("{}/config/network-topology:"
1577 "network-topology/topology/topology-netconf/node/ROADM-C1"
1578 .format(self.restconf_baseurl))
1579 headers = {'content-type': 'application/json'}
1580 response = requests.request(
1581 "DELETE", url, headers=headers,
1582 auth=('admin', 'admin'))
1583 self.assertEqual(response.status_code, requests.codes.ok)
1587 if __name__ == "__main__":
1588 unittest.main(verbosity=2)