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_full_honeynode()
46 print ("starting honeynode3...")
47 cls.honeynode_process3 = test_utils.start_roadmc_full_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/XPDRA01"
98 .format(self.restconf_baseurl))
100 "node-id": "XPDRA01",
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": "17830",
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/XPDRC01"
117 .format(self.restconf_baseurl))
119 "node-id": "XPDRC01",
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": "17834",
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/ROADMA01"
136 .format(self.restconf_baseurl))
138 "node-id": "ROADMA01",
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": "17821",
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/ROADMC01"
155 .format(self.restconf_baseurl))
157 "node-id": "ROADMC01",
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": "17823",
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": "XPDRA01",
177 "networkutils:xpdr-num": "1",
178 "networkutils:network-num": "1",
179 "networkutils:rdm-node": "ROADMA01",
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": "XPDRA01",
200 "networkutils:xpdr-num": "1",
201 "networkutils:network-num": "1",
202 "networkutils:rdm-node": "ROADMA01",
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": "XPDRC01",
223 "networkutils:xpdr-num": "1",
224 "networkutils:network-num": "1",
225 "networkutils:rdm-node": "ROADMC01",
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": "XPDRC01",
246 "networkutils:xpdr-num": "1",
247 "networkutils:network-num": "1",
248 "networkutils:rdm-node": "ROADMC01",
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/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-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/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-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": "XPDRA01",
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": "XPDRC01",
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'],
425 res['services'][0]['service-name'], 'service1')
427 res['services'][0]['connection-type'], 'service')
429 res['services'][0]['lifecycle-state'], 'planned')
432 def test_13_check_xc1_ROADMA(self):
433 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
434 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
435 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
436 .format(self.restconf_baseurl))
437 headers = {'content-type': 'application/json'}
438 response = requests.request(
439 "GET", url, headers=headers, auth=('admin', 'admin'))
440 self.assertEqual(response.status_code, requests.codes.ok)
441 res = response.json()
442 self.assertDictContainsSubset(
443 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
444 'wavelength-number': 1,
445 'opticalControlMode': 'gainLoss',
446 'target-output-power': -3.0},
447 res['roadm-connections'][0])
448 self.assertDictEqual(
449 {'src-if': 'SRG1-PP1-TXRX-1'},
450 res['roadm-connections'][0]['source'])
451 self.assertDictEqual(
452 {'dst-if': 'DEG1-TTP-TXRX-1'},
453 res['roadm-connections'][0]['destination'])
456 def test_14_check_xc1_ROADMC(self):
457 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
458 "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
459 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
460 .format(self.restconf_baseurl))
461 headers = {'content-type': 'application/json'}
462 response = requests.request(
463 "GET", url, headers=headers, auth=('admin', 'admin'))
464 self.assertEqual(response.status_code, requests.codes.ok)
465 res = response.json()
466 self.assertDictContainsSubset(
467 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
468 'wavelength-number': 1,
469 'opticalControlMode': 'gainLoss',
470 'target-output-power': 2.0},
471 res['roadm-connections'][0])
472 self.assertDictEqual(
473 {'src-if': 'SRG1-PP1-TXRX-1'},
474 res['roadm-connections'][0]['source'])
475 self.assertDictEqual(
476 {'dst-if': 'DEG2-TTP-TXRX-1'},
477 res['roadm-connections'][0]['destination'])
480 def test_15_check_topo_XPDRA(self):
481 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
482 .format(self.restconf_baseurl))
483 response = requests.request(
484 "GET", url1, auth=('admin', 'admin'))
485 self.assertEqual(response.status_code, requests.codes.ok)
486 res = response.json()
487 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
489 if ele['tp-id'] == 'XPDR1-NETWORK1':
490 self.assertEqual({u'frequency': 196.1, u'width': 40},
491 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
492 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
493 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
494 if ele['tp-id'] == 'XPDR1-NETWORK2':
495 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes']))
498 def test_16_check_topo_ROADMA_SRG1(self):
499 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
500 .format(self.restconf_baseurl))
501 response = requests.request(
502 "GET", url1, auth=('admin', 'admin'))
503 self.assertEqual(response.status_code, requests.codes.ok)
504 res = response.json()
505 self.assertNotIn({u'index': 1},
506 res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
507 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
509 if ele['tp-id'] == 'SRG1-PP1-TXRX':
510 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
511 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
512 if ele['tp-id'] == 'SRG1-PP2-TXRX':
513 self.assertNotIn('used-wavelength', dict.keys(ele))
516 def test_17_check_topo_ROADMA_DEG1(self):
517 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
518 .format(self.restconf_baseurl))
519 response = requests.request(
520 "GET", url1, auth=('admin', 'admin'))
521 self.assertEqual(response.status_code, requests.codes.ok)
522 res = response.json()
523 self.assertNotIn({u'index': 1},
524 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
525 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
527 if ele['tp-id'] == 'DEG1-CTP-TXRX':
528 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
529 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
530 if ele['tp-id'] == 'DEG1-TTP-TXRX':
531 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
532 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
535 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
536 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
538 "networkutils:input": {
539 "networkutils:links-input": {
540 "networkutils:xpdr-node": "XPDRA01",
541 "networkutils:xpdr-num": "1",
542 "networkutils:network-num": "2",
543 "networkutils:rdm-node": "ROADMA01",
544 "networkutils:srg-num": "1",
545 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
549 headers = {'content-type': 'application/json'}
550 response = requests.request(
551 "POST", url, data=json.dumps(data),
552 headers=headers, auth=('admin', 'admin'))
553 self.assertEqual(response.status_code, requests.codes.ok)
554 res = response.json()
555 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
558 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
559 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
561 "networkutils:input": {
562 "networkutils:links-input": {
563 "networkutils:xpdr-node": "XPDRA01",
564 "networkutils:xpdr-num": "1",
565 "networkutils:network-num": "2",
566 "networkutils:rdm-node": "ROADMA01",
567 "networkutils:srg-num": "1",
568 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
572 headers = {'content-type': 'application/json'}
573 response = requests.request(
574 "POST", url, data=json.dumps(data),
575 headers=headers, auth=('admin', 'admin'))
576 self.assertEqual(response.status_code, requests.codes.ok)
577 res = response.json()
578 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
581 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
582 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
584 "networkutils:input": {
585 "networkutils:links-input": {
586 "networkutils:xpdr-node": "XPDRC01",
587 "networkutils:xpdr-num": "1",
588 "networkutils:network-num": "2",
589 "networkutils:rdm-node": "ROADMC01",
590 "networkutils:srg-num": "1",
591 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
595 headers = {'content-type': 'application/json'}
596 response = requests.request(
597 "POST", url, data=json.dumps(data),
598 headers=headers, auth=('admin', 'admin'))
599 self.assertEqual(response.status_code, requests.codes.ok)
600 res = response.json()
601 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
604 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
605 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
607 "networkutils:input": {
608 "networkutils:links-input": {
609 "networkutils:xpdr-node": "XPDRC01",
610 "networkutils:xpdr-num": "1",
611 "networkutils:network-num": "2",
612 "networkutils:rdm-node": "ROADMC01",
613 "networkutils:srg-num": "1",
614 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
618 headers = {'content-type': 'application/json'}
619 response = requests.request(
620 "POST", url, data=json.dumps(data),
621 headers=headers, auth=('admin', 'admin'))
622 self.assertEqual(response.status_code, requests.codes.ok)
623 res = response.json()
624 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
627 def test_22_create_eth_service2(self):
628 url = ("{}/operations/org-openroadm-service:service-create"
629 .format(self.restconf_baseurl))
631 "sdnc-request-header": {
632 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
633 "rpc-action": "service-create",
634 "request-system-id": "appname",
635 "notification-url": "http://localhost:8585/NotificationServer/notify"
637 "service-name": "service2",
638 "common-id": "ASATT1234567",
639 "connection-type": "service",
641 "service-rate": "100",
642 "node-id": "XPDRA01",
643 "service-format": "Ethernet",
644 "clli": "SNJSCAMCJP8",
647 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
648 "port-type": "router",
649 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
650 "port-rack": "000000.00",
654 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
655 "lgx-port-name": "LGX Back.3",
656 "lgx-port-rack": "000000.00",
657 "lgx-port-shelf": "00"
662 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
663 "port-type": "router",
664 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
665 "port-rack": "000000.00",
669 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
670 "lgx-port-name": "LGX Back.4",
671 "lgx-port-rack": "000000.00",
672 "lgx-port-shelf": "00"
678 "service-rate": "100",
679 "node-id": "XPDRC01",
680 "service-format": "Ethernet",
681 "clli": "SNJSCAMCJT4",
684 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
685 "port-type": "router",
686 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
687 "port-rack": "000000.00",
691 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
692 "lgx-port-name": "LGX Back.29",
693 "lgx-port-rack": "000000.00",
694 "lgx-port-shelf": "00"
699 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
700 "port-type": "router",
701 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
702 "port-rack": "000000.00",
706 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
707 "lgx-port-name": "LGX Back.30",
708 "lgx-port-rack": "000000.00",
709 "lgx-port-shelf": "00"
714 "due-date": "2016-11-28T00:00:01Z",
715 "operator-contact": "pw1234"
718 headers = {'content-type': 'application/json',
719 "Accept": "application/json"}
720 response = requests.request(
721 "POST", url, data=json.dumps(data), headers=headers,
722 auth=('admin', 'admin'))
723 self.assertEqual(response.status_code, requests.codes.ok)
724 res = response.json()
725 self.assertIn('PCE calculation in progress',
726 res['output']['configuration-response-common']['response-message'])
727 time.sleep(self.WAITING)
729 def test_23_get_eth_service2(self):
730 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
731 .format(self.restconf_baseurl))
732 headers = {'content-type': 'application/json',
733 "Accept": "application/json"}
734 response = requests.request(
735 "GET", url, headers=headers, auth=('admin', 'admin'))
736 self.assertEqual(response.status_code, requests.codes.ok)
737 res = response.json()
739 res['services'][0]['administrative-state'],
742 res['services'][0]['service-name'], 'service2')
744 res['services'][0]['connection-type'], 'service')
746 res['services'][0]['lifecycle-state'], 'planned')
749 def test_24_check_xc2_ROADMA(self):
750 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
751 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
752 "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
753 .format(self.restconf_baseurl))
754 headers = {'content-type': 'application/json'}
755 response = requests.request(
756 "GET", url, headers=headers, auth=('admin', 'admin'))
757 self.assertEqual(response.status_code, requests.codes.ok)
758 res = response.json()
759 self.assertDictContainsSubset(
760 {'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
761 'wavelength-number': 2,
762 'opticalControlMode': 'power'},
763 res['roadm-connections'][0])
764 self.assertDictEqual(
765 {'src-if': 'DEG1-TTP-TXRX-2'},
766 res['roadm-connections'][0]['source'])
767 self.assertDictEqual(
768 {'dst-if': 'SRG1-PP2-TXRX-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/XPDRA01-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, u'width': 40},
782 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
783 if ele['tp-id'] == 'XPDR1-NETWORK2':
784 self.assertEqual({u'frequency': 196.05, u'width': 40},
785 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
786 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
787 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
790 def test_26_check_topo_ROADMA_SRG1(self):
791 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-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][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
798 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
799 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
801 if ele['tp-id'] == 'SRG1-PP1-TXRX':
802 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
803 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
804 self.assertNotIn({u'index': 2, u'frequency': 196.05, u'width': 40},
805 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
806 if ele['tp-id'] == 'SRG1-PP2-TXRX':
807 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
808 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
809 self.assertNotIn({u'index': 1, u'frequency': 196.1, u'width': 40},
810 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
811 if ele['tp-id'] == 'SRG1-PP3-TXRX':
812 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
815 def test_27_check_topo_ROADMA_DEG1(self):
816 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
817 .format(self.restconf_baseurl))
818 response = requests.request(
819 "GET", url1, auth=('admin', 'admin'))
820 self.assertEqual(response.status_code, requests.codes.ok)
821 res = response.json()
822 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
823 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
824 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
826 if ele['tp-id'] == 'DEG1-CTP-TXRX':
827 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
828 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
829 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
830 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
831 if ele['tp-id'] == 'DEG1-TTP-TXRX':
832 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
833 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
834 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
835 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
838 # creation service test on a non-available resource
839 def test_28_create_eth_service3(self):
840 url = ("{}/operations/org-openroadm-service:service-create"
841 .format(self.restconf_baseurl))
843 "sdnc-request-header": {
844 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
845 "rpc-action": "service-create",
846 "request-system-id": "appname",
847 "notification-url": "http://localhost:8585/NotificationServer/notify"
849 "service-name": "service3",
850 "common-id": "ASATT1234567",
851 "connection-type": "service",
853 "service-rate": "100",
854 "node-id": "XPDRA01",
855 "service-format": "Ethernet",
856 "clli": "SNJSCAMCJP8",
859 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
860 "port-type": "router",
861 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
862 "port-rack": "000000.00",
866 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
867 "lgx-port-name": "LGX Back.3",
868 "lgx-port-rack": "000000.00",
869 "lgx-port-shelf": "00"
874 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
875 "port-type": "router",
876 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
877 "port-rack": "000000.00",
881 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
882 "lgx-port-name": "LGX Back.4",
883 "lgx-port-rack": "000000.00",
884 "lgx-port-shelf": "00"
890 "service-rate": "100",
891 "node-id": "XPDRC01",
892 "service-format": "Ethernet",
893 "clli": "SNJSCAMCJT4",
896 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
897 "port-type": "router",
898 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
899 "port-rack": "000000.00",
903 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
904 "lgx-port-name": "LGX Back.29",
905 "lgx-port-rack": "000000.00",
906 "lgx-port-shelf": "00"
911 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
912 "port-type": "router",
913 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
914 "port-rack": "000000.00",
918 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
919 "lgx-port-name": "LGX Back.30",
920 "lgx-port-rack": "000000.00",
921 "lgx-port-shelf": "00"
926 "due-date": "2016-11-28T00:00:01Z",
927 "operator-contact": "pw1234"
930 headers = {'content-type': 'application/json',
931 "Accept": "application/json"}
932 response = requests.request(
933 "POST", url, data=json.dumps(data), headers=headers,
934 auth=('admin', 'admin'))
935 self.assertEqual(response.status_code, requests.codes.ok)
936 res = response.json()
937 self.assertIn('PCE calculation in progress',
938 res['output']['configuration-response-common']['response-message'])
939 self.assertIn('200', res['output']['configuration-response-common']['response-code'])
940 time.sleep(self.WAITING)
942 # add a test that check the openroadm-service-list still only contains 2 elements
944 def test_29_delete_eth_service3(self):
945 url = ("{}/operations/org-openroadm-service:service-delete"
946 .format(self.restconf_baseurl))
948 "sdnc-request-header": {
949 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
950 "rpc-action": "service-delete",
951 "request-system-id": "appname",
952 "notification-url": "http://localhost:8585/NotificationServer/notify"
954 "service-delete-req-info": {
955 "service-name": "service3",
956 "tail-retention": "no"
960 headers = {'content-type': 'application/json'}
961 response = requests.request(
962 "POST", url, data=json.dumps(data), headers=headers,
963 auth=('admin', 'admin'))
964 self.assertEqual(response.status_code, requests.codes.ok)
965 res = response.json()
966 self.assertIn('Service \'service3\' does not exist in datastore',
967 res['output']['configuration-response-common']['response-message'])
968 self.assertIn('500', res['output']['configuration-response-common']['response-code'])
971 def test_30_delete_eth_service1(self):
972 url = ("{}/operations/org-openroadm-service:service-delete"
973 .format(self.restconf_baseurl))
975 "sdnc-request-header": {
976 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
977 "rpc-action": "service-delete",
978 "request-system-id": "appname",
979 "notification-url": "http://localhost:8585/NotificationServer/notify"
981 "service-delete-req-info": {
982 "service-name": "service1",
983 "tail-retention": "no"
987 headers = {'content-type': 'application/json'}
988 response = requests.request(
989 "POST", url, data=json.dumps(data), headers=headers,
990 auth=('admin', 'admin'))
991 self.assertEqual(response.status_code, requests.codes.ok)
992 res = response.json()
993 self.assertIn('Renderer service delete in progress',
994 res['output']['configuration-response-common']['response-message'])
997 def test_31_delete_eth_service2(self):
998 url = ("{}/operations/org-openroadm-service:service-delete"
999 .format(self.restconf_baseurl))
1001 "sdnc-request-header": {
1002 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1003 "rpc-action": "service-delete",
1004 "request-system-id": "appname",
1005 "notification-url": "http://localhost:8585/NotificationServer/notify"
1007 "service-delete-req-info": {
1008 "service-name": "service2",
1009 "tail-retention": "no"
1013 headers = {'content-type': 'application/json'}
1014 response = requests.request(
1015 "POST", url, data=json.dumps(data), headers=headers,
1016 auth=('admin', 'admin'))
1017 self.assertEqual(response.status_code, requests.codes.ok)
1018 res = response.json()
1019 self.assertIn('Renderer service delete in progress',
1020 res['output']['configuration-response-common']['response-message'])
1023 def test_32_check_no_xc_ROADMA(self):
1024 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1025 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1026 .format(self.restconf_baseurl))
1027 response = requests.request(
1028 "GET", url, auth=('admin', 'admin'))
1029 res = response.json()
1030 self.assertEqual(response.status_code, requests.codes.ok)
1031 self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1034 def test_33_check_topo_XPDRA(self):
1035 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1036 .format(self.restconf_baseurl))
1037 response = requests.request(
1038 "GET", url1, auth=('admin', 'admin'))
1039 self.assertEqual(response.status_code, requests.codes.ok)
1040 res = response.json()
1041 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1042 for ele in liste_tp:
1043 if ((ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT')
1044 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1045 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-client-attributes']))
1046 elif ((ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK')
1047 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1048 self.assertNotIn('wavelength', dict.keys(ele['org-openroadm-network-topology:xpdr-network-attributes']))
1051 def test_34_check_topo_ROADMA_SRG1(self):
1052 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
1053 .format(self.restconf_baseurl))
1054 response = requests.request(
1055 "GET", url1, auth=('admin', 'admin'))
1056 self.assertEqual(response.status_code, requests.codes.ok)
1057 res = response.json()
1058 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1059 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1060 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1061 for ele in liste_tp:
1062 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1063 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1065 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1068 def test_35_check_topo_ROADMA_DEG1(self):
1069 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
1070 .format(self.restconf_baseurl))
1071 response = requests.request(
1072 "GET", url1, auth=('admin', 'admin'))
1073 self.assertEqual(response.status_code, requests.codes.ok)
1074 res = response.json()
1075 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1076 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1077 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1078 for ele in liste_tp:
1079 if ele['tp-id'] == 'DEG1-CTP-TXRX':
1080 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1081 if ele['tp-id'] == 'DEG1-TTP-TXRX':
1082 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1086 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1087 def test_36_create_oc_service1(self):
1088 url = ("{}/operations/org-openroadm-service:service-create"
1089 .format(self.restconf_baseurl))
1091 "sdnc-request-header": {
1092 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1093 "rpc-action": "service-create",
1094 "request-system-id": "appname",
1095 "notification-url": "http://localhost:8585/NotificationServer/notify"
1097 "service-name": "service1",
1098 "common-id": "ASATT1234567",
1099 "connection-type": "roadm-line",
1101 "service-rate": "100",
1102 "node-id": "ROADMA01",
1103 "service-format": "OC",
1104 "clli": "SNJSCAMCJP8",
1107 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1108 "port-type": "router",
1109 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1110 "port-rack": "000000.00",
1114 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1115 "lgx-port-name": "LGX Back.3",
1116 "lgx-port-rack": "000000.00",
1117 "lgx-port-shelf": "00"
1122 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1123 "port-type": "router",
1124 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1125 "port-rack": "000000.00",
1129 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1130 "lgx-port-name": "LGX Back.4",
1131 "lgx-port-rack": "000000.00",
1132 "lgx-port-shelf": "00"
1135 "optic-type": "gray"
1138 "service-rate": "100",
1139 "node-id": "ROADMC01",
1140 "service-format": "OC",
1141 "clli": "SNJSCAMCJT4",
1144 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1145 "port-type": "router",
1146 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1147 "port-rack": "000000.00",
1151 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1152 "lgx-port-name": "LGX Back.29",
1153 "lgx-port-rack": "000000.00",
1154 "lgx-port-shelf": "00"
1159 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1160 "port-type": "router",
1161 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1162 "port-rack": "000000.00",
1166 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1167 "lgx-port-name": "LGX Back.30",
1168 "lgx-port-rack": "000000.00",
1169 "lgx-port-shelf": "00"
1172 "optic-type": "gray"
1174 "due-date": "2016-11-28T00:00:01Z",
1175 "operator-contact": "pw1234"
1178 headers = {'content-type': 'application/json',
1179 "Accept": "application/json"}
1180 response = requests.request(
1181 "POST", url, data=json.dumps(data), headers=headers,
1182 auth=('admin', 'admin'))
1183 self.assertEqual(response.status_code, requests.codes.ok)
1184 res = response.json()
1185 self.assertIn('PCE calculation in progress',
1186 res['output']['configuration-response-common']['response-message'])
1187 time.sleep(self.WAITING)
1189 def test_37_get_oc_service1(self):
1190 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1191 .format(self.restconf_baseurl))
1192 headers = {'content-type': 'application/json',
1193 "Accept": "application/json"}
1194 response = requests.request(
1195 "GET", url, headers=headers, auth=('admin', 'admin'))
1196 self.assertEqual(response.status_code, requests.codes.ok)
1197 res = response.json()
1199 res['services'][0]['administrative-state'],
1202 res['services'][0]['service-name'], 'service1')
1204 res['services'][0]['connection-type'], 'roadm-line')
1206 res['services'][0]['lifecycle-state'], 'planned')
1209 def test_38_check_xc1_ROADMA(self):
1210 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1211 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1212 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1213 .format(self.restconf_baseurl))
1214 headers = {'content-type': 'application/json'}
1215 response = requests.request(
1216 "GET", url, headers=headers, auth=('admin', 'admin'))
1217 self.assertEqual(response.status_code, requests.codes.ok)
1218 res = response.json()
1219 self.assertDictContainsSubset(
1220 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1221 'wavelength-number': 1,
1222 'opticalControlMode': 'gainLoss',
1223 'target-output-power': -3.0},
1224 res['roadm-connections'][0])
1225 self.assertDictEqual(
1226 {'src-if': 'SRG1-PP1-TXRX-1'},
1227 res['roadm-connections'][0]['source'])
1228 self.assertDictEqual(
1229 {'dst-if': 'DEG1-TTP-TXRX-1'},
1230 res['roadm-connections'][0]['destination'])
1233 def test_39_check_xc1_ROADMC(self):
1234 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1235 "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1236 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1237 .format(self.restconf_baseurl))
1238 headers = {'content-type': 'application/json'}
1239 response = requests.request(
1240 "GET", url, headers=headers, auth=('admin', 'admin'))
1241 self.assertEqual(response.status_code, requests.codes.ok)
1242 res = response.json()
1243 self.assertDictContainsSubset(
1244 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1245 'wavelength-number': 1,
1246 'opticalControlMode': 'gainLoss',
1247 'target-output-power': 2.0},
1248 res['roadm-connections'][0])
1249 self.assertDictEqual(
1250 {'src-if': 'SRG1-PP1-TXRX-1'},
1251 res['roadm-connections'][0]['source'])
1252 self.assertDictEqual(
1253 {'dst-if': 'DEG2-TTP-TXRX-1'},
1254 res['roadm-connections'][0]['destination'])
1257 def test_40_create_oc_service2(self):
1258 url = ("{}/operations/org-openroadm-service:service-create"
1259 .format(self.restconf_baseurl))
1261 "sdnc-request-header": {
1262 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1263 "rpc-action": "service-create",
1264 "request-system-id": "appname",
1265 "notification-url": "http://localhost:8585/NotificationServer/notify"
1267 "service-name": "service2",
1268 "common-id": "ASATT1234567",
1269 "connection-type": "roadm-line",
1271 "service-rate": "100",
1272 "node-id": "ROADMA01",
1273 "service-format": "OC",
1274 "clli": "SNJSCAMCJP8",
1277 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1278 "port-type": "router",
1279 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1280 "port-rack": "000000.00",
1284 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1285 "lgx-port-name": "LGX Back.3",
1286 "lgx-port-rack": "000000.00",
1287 "lgx-port-shelf": "00"
1292 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1293 "port-type": "router",
1294 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1295 "port-rack": "000000.00",
1299 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1300 "lgx-port-name": "LGX Back.4",
1301 "lgx-port-rack": "000000.00",
1302 "lgx-port-shelf": "00"
1305 "optic-type": "gray"
1308 "service-rate": "100",
1309 "node-id": "ROADMC01",
1310 "service-format": "OC",
1311 "clli": "SNJSCAMCJT4",
1314 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1315 "port-type": "router",
1316 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1317 "port-rack": "000000.00",
1321 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1322 "lgx-port-name": "LGX Back.29",
1323 "lgx-port-rack": "000000.00",
1324 "lgx-port-shelf": "00"
1329 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1330 "port-type": "router",
1331 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1332 "port-rack": "000000.00",
1336 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1337 "lgx-port-name": "LGX Back.30",
1338 "lgx-port-rack": "000000.00",
1339 "lgx-port-shelf": "00"
1342 "optic-type": "gray"
1344 "due-date": "2016-11-28T00:00:01Z",
1345 "operator-contact": "pw1234"
1348 headers = {'content-type': 'application/json',
1349 "Accept": "application/json"}
1350 response = requests.request(
1351 "POST", url, data=json.dumps(data), headers=headers,
1352 auth=('admin', 'admin'))
1353 self.assertEqual(response.status_code, requests.codes.ok)
1354 res = response.json()
1355 self.assertIn('PCE calculation in progress',
1356 res['output']['configuration-response-common']['response-message'])
1357 time.sleep(self.WAITING)
1359 def test_41_get_oc_service2(self):
1360 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1361 .format(self.restconf_baseurl))
1362 headers = {'content-type': 'application/json',
1363 "Accept": "application/json"}
1364 response = requests.request(
1365 "GET", url, headers=headers, auth=('admin', 'admin'))
1366 self.assertEqual(response.status_code, requests.codes.ok)
1367 res = response.json()
1369 res['services'][0]['administrative-state'],
1372 res['services'][0]['service-name'], 'service2')
1374 res['services'][0]['connection-type'], 'roadm-line')
1376 res['services'][0]['lifecycle-state'], 'planned')
1379 def test_42_check_xc2_ROADMA(self):
1380 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1381 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1382 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1383 .format(self.restconf_baseurl))
1384 headers = {'content-type': 'application/json'}
1385 response = requests.request(
1386 "GET", url, headers=headers, auth=('admin', 'admin'))
1387 self.assertEqual(response.status_code, requests.codes.ok)
1388 res = response.json()
1389 self.assertDictContainsSubset(
1390 {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1391 'wavelength-number': 2,
1392 'opticalControlMode': 'gainLoss',
1393 'target-output-power': -3.0},
1394 res['roadm-connections'][0])
1395 self.assertDictEqual(
1396 {'src-if': 'SRG1-PP2-TXRX-2'},
1397 res['roadm-connections'][0]['source'])
1398 self.assertDictEqual(
1399 {'dst-if': 'DEG1-TTP-TXRX-2'},
1400 res['roadm-connections'][0]['destination'])
1403 def test_43_check_topo_ROADMA(self):
1404 self.test_26_check_topo_ROADMA_SRG1()
1405 self.test_27_check_topo_ROADMA_DEG1()
1408 def test_44_delete_oc_service1(self):
1409 url = ("{}/operations/org-openroadm-service:service-delete"
1410 .format(self.restconf_baseurl))
1412 "sdnc-request-header": {
1413 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1414 "rpc-action": "service-delete",
1415 "request-system-id": "appname",
1416 "notification-url": "http://localhost:8585/NotificationServer/notify"
1418 "service-delete-req-info": {
1419 "service-name": "service1",
1420 "tail-retention": "no"
1424 headers = {'content-type': 'application/json'}
1425 response = requests.request(
1426 "POST", url, data=json.dumps(data), headers=headers,
1427 auth=('admin', 'admin'))
1428 self.assertEqual(response.status_code, requests.codes.ok)
1429 res = response.json()
1430 self.assertIn('Renderer service delete in progress',
1431 res['output']['configuration-response-common']['response-message'])
1434 def test_45_delete_oc_service2(self):
1435 url = ("{}/operations/org-openroadm-service:service-delete"
1436 .format(self.restconf_baseurl))
1438 "sdnc-request-header": {
1439 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1440 "rpc-action": "service-delete",
1441 "request-system-id": "appname",
1442 "notification-url": "http://localhost:8585/NotificationServer/notify"
1444 "service-delete-req-info": {
1445 "service-name": "service2",
1446 "tail-retention": "no"
1450 headers = {'content-type': 'application/json'}
1451 response = requests.request(
1452 "POST", url, data=json.dumps(data), headers=headers,
1453 auth=('admin', 'admin'))
1454 self.assertEqual(response.status_code, requests.codes.ok)
1455 res = response.json()
1456 self.assertIn('Renderer service delete in progress',
1457 res['output']['configuration-response-common']['response-message'])
1460 def test_46_get_no_oc_services(self):
1461 print ("start test")
1462 url = ("{}/operational/org-openroadm-service:service-list"
1463 .format(self.restconf_baseurl))
1464 headers = {'content-type': 'application/json',
1465 "Accept": "application/json"}
1466 response = requests.request(
1467 "GET", url, headers=headers, auth=('admin', 'admin'))
1468 self.assertEqual(response.status_code, requests.codes.not_found)
1469 res = response.json()
1471 {"error-type":"application", "error-tag":"data-missing",
1472 "error-message":"Request could not be completed because the relevant data model content does not exist"},
1473 res['errors']['error'])
1476 def test_47_get_no_xc_ROADMA(self):
1477 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1478 "/node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1479 .format(self.restconf_baseurl))
1480 headers = {'content-type': 'application/json',
1481 "Accept": "application/json"}
1482 response = requests.request(
1483 "GET", url, headers=headers, auth=('admin', 'admin'))
1484 self.assertEqual(response.status_code, requests.codes.ok)
1485 res = response.json()
1486 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1489 def test_48_check_topo_ROADMA(self):
1490 self.test_34_check_topo_ROADMA_SRG1()
1491 self.test_35_check_topo_ROADMA_DEG1()
1493 def test_49_loop_create_eth_service(self):
1494 for i in range(1,6):
1495 print ("trial number {}".format(i))
1496 print("eth service creation")
1497 self.test_11_create_eth_service1()
1498 print ("check xc in ROADMA01")
1499 self.test_13_check_xc1_ROADMA()
1500 print ("check xc in ROADMC01")
1501 self.test_14_check_xc1_ROADMC()
1502 print ("eth service deletion\n")
1503 self.test_30_delete_eth_service1()
1505 def test_50_loop_create_oc_service(self):
1506 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1507 .format(self.restconf_baseurl))
1508 response = requests.request("GET", url, auth=('admin', 'admin'))
1509 if response.status_code != 404:
1510 url = ("{}/operations/org-openroadm-service:service-delete"
1511 .format(self.restconf_baseurl))
1513 "sdnc-request-header": {
1514 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1515 "rpc-action": "service-delete",
1516 "request-system-id": "appname",
1517 "notification-url": "http://localhost:8585/NotificationServer/notify"
1519 "service-delete-req-info": {
1520 "service-name": "service1",
1521 "tail-retention": "no"
1525 headers = {'content-type': 'application/json'}
1526 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1529 for i in range(1,6):
1530 print ("trial number {}".format(i))
1531 print("oc service creation")
1532 self.test_36_create_oc_service1()
1533 print ("check xc in ROADMA01")
1534 self.test_38_check_xc1_ROADMA()
1535 print ("check xc in ROADMC01")
1536 self.test_39_check_xc1_ROADMC()
1537 print ("oc service deletion\n")
1538 self.test_44_delete_oc_service1()
1540 def test_51_disconnect_XPDRA(self):
1541 url = ("{}/config/network-topology:"
1542 "network-topology/topology/topology-netconf/node/XPDRA01"
1543 .format(self.restconf_baseurl))
1544 headers = {'content-type': 'application/json'}
1545 response = requests.request(
1546 "DELETE", url, headers=headers,
1547 auth=('admin', 'admin'))
1548 self.assertEqual(response.status_code, requests.codes.ok)
1551 def test_52_disconnect_XPDRC(self):
1552 url = ("{}/config/network-topology:"
1553 "network-topology/topology/topology-netconf/node/XPDRC01"
1554 .format(self.restconf_baseurl))
1555 headers = {'content-type': 'application/json'}
1556 response = requests.request(
1557 "DELETE", url, headers=headers,
1558 auth=('admin', 'admin'))
1559 self.assertEqual(response.status_code, requests.codes.ok)
1562 def test_53_disconnect_ROADMA(self):
1563 url = ("{}/config/network-topology:"
1564 "network-topology/topology/topology-netconf/node/ROADMA01"
1565 .format(self.restconf_baseurl))
1566 headers = {'content-type': 'application/json'}
1567 response = requests.request(
1568 "DELETE", url, headers=headers,
1569 auth=('admin', 'admin'))
1570 self.assertEqual(response.status_code, requests.codes.ok)
1573 def test_54_disconnect_ROADMC(self):
1574 url = ("{}/config/network-topology:"
1575 "network-topology/topology/topology-netconf/node/ROADMC01"
1576 .format(self.restconf_baseurl))
1577 headers = {'content-type': 'application/json'}
1578 response = requests.request(
1579 "DELETE", url, headers=headers,
1580 auth=('admin', 'admin'))
1581 self.assertEqual(response.status_code, requests.codes.ok)
1585 if __name__ == "__main__":
1586 unittest.main(verbosity=2)