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('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
494 if ele['tp-id'] == 'XPDR1-NETWORK2':
495 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
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('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
790 def test_26_check_topo_ROADMA_SRG1(self):
791 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/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 @unittest.skip("Skip this test until tail-equipment-id deletion is finished.")
1035 def test_33_check_topo_XPDRA(self):
1036 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1037 .format(self.restconf_baseurl))
1038 response = requests.request(
1039 "GET", url1, auth=('admin', 'admin'))
1040 self.assertEqual(response.status_code, requests.codes.ok)
1041 res = response.json()
1042 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1043 for ele in liste_tp:
1044 if ((ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT')
1045 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1046 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
1047 elif ((ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK')
1048 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1049 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
1052 def test_34_check_topo_ROADMA_SRG1(self):
1053 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
1054 .format(self.restconf_baseurl))
1055 response = requests.request(
1056 "GET", url1, auth=('admin', 'admin'))
1057 self.assertEqual(response.status_code, requests.codes.ok)
1058 res = response.json()
1059 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1060 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1061 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1062 for ele in liste_tp:
1063 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1064 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1066 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1069 def test_35_check_topo_ROADMA_DEG1(self):
1070 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
1071 .format(self.restconf_baseurl))
1072 response = requests.request(
1073 "GET", url1, auth=('admin', 'admin'))
1074 self.assertEqual(response.status_code, requests.codes.ok)
1075 res = response.json()
1076 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1077 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1078 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1079 for ele in liste_tp:
1080 if ele['tp-id'] == 'DEG1-CTP-TXRX':
1081 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1082 if ele['tp-id'] == 'DEG1-TTP-TXRX':
1083 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1087 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1088 def test_36_create_oc_service1(self):
1089 url = ("{}/operations/org-openroadm-service:service-create"
1090 .format(self.restconf_baseurl))
1092 "sdnc-request-header": {
1093 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1094 "rpc-action": "service-create",
1095 "request-system-id": "appname",
1096 "notification-url": "http://localhost:8585/NotificationServer/notify"
1098 "service-name": "service1",
1099 "common-id": "ASATT1234567",
1100 "connection-type": "roadm-line",
1102 "service-rate": "100",
1103 "node-id": "ROADMA01",
1104 "service-format": "OC",
1105 "clli": "SNJSCAMCJP8",
1108 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1109 "port-type": "router",
1110 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1111 "port-rack": "000000.00",
1115 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1116 "lgx-port-name": "LGX Back.3",
1117 "lgx-port-rack": "000000.00",
1118 "lgx-port-shelf": "00"
1123 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1124 "port-type": "router",
1125 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1126 "port-rack": "000000.00",
1130 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1131 "lgx-port-name": "LGX Back.4",
1132 "lgx-port-rack": "000000.00",
1133 "lgx-port-shelf": "00"
1136 "optic-type": "gray"
1139 "service-rate": "100",
1140 "node-id": "ROADMC01",
1141 "service-format": "OC",
1142 "clli": "SNJSCAMCJT4",
1145 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1146 "port-type": "router",
1147 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1148 "port-rack": "000000.00",
1152 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1153 "lgx-port-name": "LGX Back.29",
1154 "lgx-port-rack": "000000.00",
1155 "lgx-port-shelf": "00"
1160 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1161 "port-type": "router",
1162 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1163 "port-rack": "000000.00",
1167 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1168 "lgx-port-name": "LGX Back.30",
1169 "lgx-port-rack": "000000.00",
1170 "lgx-port-shelf": "00"
1173 "optic-type": "gray"
1175 "due-date": "2016-11-28T00:00:01Z",
1176 "operator-contact": "pw1234"
1179 headers = {'content-type': 'application/json',
1180 "Accept": "application/json"}
1181 response = requests.request(
1182 "POST", url, data=json.dumps(data), headers=headers,
1183 auth=('admin', 'admin'))
1184 self.assertEqual(response.status_code, requests.codes.ok)
1185 res = response.json()
1186 self.assertIn('PCE calculation in progress',
1187 res['output']['configuration-response-common']['response-message'])
1188 time.sleep(self.WAITING)
1190 def test_37_get_oc_service1(self):
1191 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1192 .format(self.restconf_baseurl))
1193 headers = {'content-type': 'application/json',
1194 "Accept": "application/json"}
1195 response = requests.request(
1196 "GET", url, headers=headers, auth=('admin', 'admin'))
1197 self.assertEqual(response.status_code, requests.codes.ok)
1198 res = response.json()
1200 res['services'][0]['administrative-state'],
1203 res['services'][0]['service-name'], 'service1')
1205 res['services'][0]['connection-type'], 'roadm-line')
1207 res['services'][0]['lifecycle-state'], 'planned')
1210 def test_38_check_xc1_ROADMA(self):
1211 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1212 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1213 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1214 .format(self.restconf_baseurl))
1215 headers = {'content-type': 'application/json'}
1216 response = requests.request(
1217 "GET", url, headers=headers, auth=('admin', 'admin'))
1218 self.assertEqual(response.status_code, requests.codes.ok)
1219 res = response.json()
1220 self.assertDictContainsSubset(
1221 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1222 'wavelength-number': 1,
1223 'opticalControlMode': 'gainLoss',
1224 'target-output-power': -3.0},
1225 res['roadm-connections'][0])
1226 self.assertDictEqual(
1227 {'src-if': 'SRG1-PP1-TXRX-1'},
1228 res['roadm-connections'][0]['source'])
1229 self.assertDictEqual(
1230 {'dst-if': 'DEG1-TTP-TXRX-1'},
1231 res['roadm-connections'][0]['destination'])
1234 def test_39_check_xc1_ROADMC(self):
1235 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1236 "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1237 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1238 .format(self.restconf_baseurl))
1239 headers = {'content-type': 'application/json'}
1240 response = requests.request(
1241 "GET", url, headers=headers, auth=('admin', 'admin'))
1242 self.assertEqual(response.status_code, requests.codes.ok)
1243 res = response.json()
1244 self.assertDictContainsSubset(
1245 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1246 'wavelength-number': 1,
1247 'opticalControlMode': 'gainLoss',
1248 'target-output-power': 2.0},
1249 res['roadm-connections'][0])
1250 self.assertDictEqual(
1251 {'src-if': 'SRG1-PP1-TXRX-1'},
1252 res['roadm-connections'][0]['source'])
1253 self.assertDictEqual(
1254 {'dst-if': 'DEG2-TTP-TXRX-1'},
1255 res['roadm-connections'][0]['destination'])
1258 def test_40_create_oc_service2(self):
1259 url = ("{}/operations/org-openroadm-service:service-create"
1260 .format(self.restconf_baseurl))
1262 "sdnc-request-header": {
1263 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1264 "rpc-action": "service-create",
1265 "request-system-id": "appname",
1266 "notification-url": "http://localhost:8585/NotificationServer/notify"
1268 "service-name": "service2",
1269 "common-id": "ASATT1234567",
1270 "connection-type": "roadm-line",
1272 "service-rate": "100",
1273 "node-id": "ROADMA01",
1274 "service-format": "OC",
1275 "clli": "SNJSCAMCJP8",
1278 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1279 "port-type": "router",
1280 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1281 "port-rack": "000000.00",
1285 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1286 "lgx-port-name": "LGX Back.3",
1287 "lgx-port-rack": "000000.00",
1288 "lgx-port-shelf": "00"
1293 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1294 "port-type": "router",
1295 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1296 "port-rack": "000000.00",
1300 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1301 "lgx-port-name": "LGX Back.4",
1302 "lgx-port-rack": "000000.00",
1303 "lgx-port-shelf": "00"
1306 "optic-type": "gray"
1309 "service-rate": "100",
1310 "node-id": "ROADMC01",
1311 "service-format": "OC",
1312 "clli": "SNJSCAMCJT4",
1315 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1316 "port-type": "router",
1317 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1318 "port-rack": "000000.00",
1322 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1323 "lgx-port-name": "LGX Back.29",
1324 "lgx-port-rack": "000000.00",
1325 "lgx-port-shelf": "00"
1330 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1331 "port-type": "router",
1332 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1333 "port-rack": "000000.00",
1337 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1338 "lgx-port-name": "LGX Back.30",
1339 "lgx-port-rack": "000000.00",
1340 "lgx-port-shelf": "00"
1343 "optic-type": "gray"
1345 "due-date": "2016-11-28T00:00:01Z",
1346 "operator-contact": "pw1234"
1349 headers = {'content-type': 'application/json',
1350 "Accept": "application/json"}
1351 response = requests.request(
1352 "POST", url, data=json.dumps(data), headers=headers,
1353 auth=('admin', 'admin'))
1354 self.assertEqual(response.status_code, requests.codes.ok)
1355 res = response.json()
1356 self.assertIn('PCE calculation in progress',
1357 res['output']['configuration-response-common']['response-message'])
1358 time.sleep(self.WAITING)
1360 def test_41_get_oc_service2(self):
1361 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1362 .format(self.restconf_baseurl))
1363 headers = {'content-type': 'application/json',
1364 "Accept": "application/json"}
1365 response = requests.request(
1366 "GET", url, headers=headers, auth=('admin', 'admin'))
1367 self.assertEqual(response.status_code, requests.codes.ok)
1368 res = response.json()
1370 res['services'][0]['administrative-state'],
1373 res['services'][0]['service-name'], 'service2')
1375 res['services'][0]['connection-type'], 'roadm-line')
1377 res['services'][0]['lifecycle-state'], 'planned')
1380 def test_42_check_xc2_ROADMA(self):
1381 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1382 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1383 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1384 .format(self.restconf_baseurl))
1385 headers = {'content-type': 'application/json'}
1386 response = requests.request(
1387 "GET", url, headers=headers, auth=('admin', 'admin'))
1388 self.assertEqual(response.status_code, requests.codes.ok)
1389 res = response.json()
1390 self.assertDictContainsSubset(
1391 {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1392 'wavelength-number': 2,
1393 'opticalControlMode': 'gainLoss',
1394 'target-output-power': -3.0},
1395 res['roadm-connections'][0])
1396 self.assertDictEqual(
1397 {'src-if': 'SRG1-PP2-TXRX-2'},
1398 res['roadm-connections'][0]['source'])
1399 self.assertDictEqual(
1400 {'dst-if': 'DEG1-TTP-TXRX-2'},
1401 res['roadm-connections'][0]['destination'])
1404 def test_43_check_topo_ROADMA(self):
1405 self.test_26_check_topo_ROADMA_SRG1()
1406 self.test_27_check_topo_ROADMA_DEG1()
1409 def test_44_delete_oc_service1(self):
1410 url = ("{}/operations/org-openroadm-service:service-delete"
1411 .format(self.restconf_baseurl))
1413 "sdnc-request-header": {
1414 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1415 "rpc-action": "service-delete",
1416 "request-system-id": "appname",
1417 "notification-url": "http://localhost:8585/NotificationServer/notify"
1419 "service-delete-req-info": {
1420 "service-name": "service1",
1421 "tail-retention": "no"
1425 headers = {'content-type': 'application/json'}
1426 response = requests.request(
1427 "POST", url, data=json.dumps(data), headers=headers,
1428 auth=('admin', 'admin'))
1429 self.assertEqual(response.status_code, requests.codes.ok)
1430 res = response.json()
1431 self.assertIn('Renderer service delete in progress',
1432 res['output']['configuration-response-common']['response-message'])
1435 def test_45_delete_oc_service2(self):
1436 url = ("{}/operations/org-openroadm-service:service-delete"
1437 .format(self.restconf_baseurl))
1439 "sdnc-request-header": {
1440 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1441 "rpc-action": "service-delete",
1442 "request-system-id": "appname",
1443 "notification-url": "http://localhost:8585/NotificationServer/notify"
1445 "service-delete-req-info": {
1446 "service-name": "service2",
1447 "tail-retention": "no"
1451 headers = {'content-type': 'application/json'}
1452 response = requests.request(
1453 "POST", url, data=json.dumps(data), headers=headers,
1454 auth=('admin', 'admin'))
1455 self.assertEqual(response.status_code, requests.codes.ok)
1456 res = response.json()
1457 self.assertIn('Renderer service delete in progress',
1458 res['output']['configuration-response-common']['response-message'])
1461 def test_46_get_no_oc_services(self):
1462 print ("start test")
1463 url = ("{}/operational/org-openroadm-service:service-list"
1464 .format(self.restconf_baseurl))
1465 headers = {'content-type': 'application/json',
1466 "Accept": "application/json"}
1467 response = requests.request(
1468 "GET", url, headers=headers, auth=('admin', 'admin'))
1469 self.assertEqual(response.status_code, requests.codes.not_found)
1470 res = response.json()
1472 {"error-type":"application", "error-tag":"data-missing",
1473 "error-message":"Request could not be completed because the relevant data model content does not exist"},
1474 res['errors']['error'])
1477 def test_47_get_no_xc_ROADMA(self):
1478 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1479 "/node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1480 .format(self.restconf_baseurl))
1481 headers = {'content-type': 'application/json',
1482 "Accept": "application/json"}
1483 response = requests.request(
1484 "GET", url, headers=headers, auth=('admin', 'admin'))
1485 self.assertEqual(response.status_code, requests.codes.ok)
1486 res = response.json()
1487 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1490 def test_48_check_topo_ROADMA(self):
1491 self.test_34_check_topo_ROADMA_SRG1()
1492 self.test_35_check_topo_ROADMA_DEG1()
1494 def test_49_loop_create_eth_service(self):
1495 for i in range(1,6):
1496 print ("trial number {}".format(i))
1497 print("eth service creation")
1498 self.test_11_create_eth_service1()
1499 print ("check xc in ROADMA01")
1500 self.test_13_check_xc1_ROADMA()
1501 print ("check xc in ROADMC01")
1502 self.test_14_check_xc1_ROADMC()
1503 print ("eth service deletion\n")
1504 self.test_30_delete_eth_service1()
1506 def test_50_loop_create_oc_service(self):
1507 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1508 .format(self.restconf_baseurl))
1509 response = requests.request("GET", url, auth=('admin', 'admin'))
1510 if response.status_code != 404:
1511 url = ("{}/operations/org-openroadm-service:service-delete"
1512 .format(self.restconf_baseurl))
1514 "sdnc-request-header": {
1515 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1516 "rpc-action": "service-delete",
1517 "request-system-id": "appname",
1518 "notification-url": "http://localhost:8585/NotificationServer/notify"
1520 "service-delete-req-info": {
1521 "service-name": "service1",
1522 "tail-retention": "no"
1526 headers = {'content-type': 'application/json'}
1527 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1530 for i in range(1,6):
1531 print ("trial number {}".format(i))
1532 print("oc service creation")
1533 self.test_36_create_oc_service1()
1534 print ("check xc in ROADMA01")
1535 self.test_38_check_xc1_ROADMA()
1536 print ("check xc in ROADMC01")
1537 self.test_39_check_xc1_ROADMC()
1538 print ("oc service deletion\n")
1539 self.test_44_delete_oc_service1()
1541 def test_51_disconnect_XPDRA(self):
1542 url = ("{}/config/network-topology:"
1543 "network-topology/topology/topology-netconf/node/XPDRA01"
1544 .format(self.restconf_baseurl))
1545 headers = {'content-type': 'application/json'}
1546 response = requests.request(
1547 "DELETE", url, headers=headers,
1548 auth=('admin', 'admin'))
1549 self.assertEqual(response.status_code, requests.codes.ok)
1552 def test_52_disconnect_XPDRC(self):
1553 url = ("{}/config/network-topology:"
1554 "network-topology/topology/topology-netconf/node/XPDRC01"
1555 .format(self.restconf_baseurl))
1556 headers = {'content-type': 'application/json'}
1557 response = requests.request(
1558 "DELETE", url, headers=headers,
1559 auth=('admin', 'admin'))
1560 self.assertEqual(response.status_code, requests.codes.ok)
1563 def test_53_disconnect_ROADMA(self):
1564 url = ("{}/config/network-topology:"
1565 "network-topology/topology/topology-netconf/node/ROADMA01"
1566 .format(self.restconf_baseurl))
1567 headers = {'content-type': 'application/json'}
1568 response = requests.request(
1569 "DELETE", url, headers=headers,
1570 auth=('admin', 'admin'))
1571 self.assertEqual(response.status_code, requests.codes.ok)
1574 def test_54_disconnect_ROADMC(self):
1575 url = ("{}/config/network-topology:"
1576 "network-topology/topology/topology-netconf/node/ROADMC01"
1577 .format(self.restconf_baseurl))
1578 headers = {'content-type': 'application/json'}
1579 response = requests.request(
1580 "DELETE", url, headers=headers,
1581 auth=('admin', 'admin'))
1582 self.assertEqual(response.status_code, requests.codes.ok)
1586 if __name__ == "__main__":
1587 unittest.main(verbosity=2)