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))
270 "auto-spanloss": "true",
271 "spanloss-base": 11.4,
272 "spanloss-current": 12,
273 "engineered-spanloss": 12.2,
274 "link-concatenation": [{
277 "SRLG-length": 100000,
279 headers = {'content-type': 'application/json'}
280 response = requests.request(
281 "PUT", url, data=json.dumps(data), headers=headers,
282 auth=('admin', 'admin'))
283 self.assertEqual(response.status_code, requests.codes.created)
285 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
286 # Config ROADMC-ROADMA oms-attributes
287 url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
288 "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
289 "OMS-attributes/span"
290 .format(self.restconf_baseurl))
292 "auto-spanloss": "true",
293 "spanloss-base": 11.4,
294 "spanloss-current": 12,
295 "engineered-spanloss": 12.2,
296 "link-concatenation": [{
299 "SRLG-length": 100000,
301 headers = {'content-type': 'application/json'}
302 response = requests.request(
303 "PUT", url, data=json.dumps(data), headers=headers,
304 auth=('admin', 'admin'))
305 self.assertEqual(response.status_code, requests.codes.created)
307 #test service-create for Eth service from xpdr to xpdr
308 def test_11_create_eth_service1(self):
309 url = ("{}/operations/org-openroadm-service:service-create"
310 .format(self.restconf_baseurl))
312 "sdnc-request-header": {
313 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
314 "rpc-action": "service-create",
315 "request-system-id": "appname",
316 "notification-url": "http://localhost:8585/NotificationServer/notify"
318 "service-name": "service1",
319 "common-id": "ASATT1234567",
320 "connection-type": "service",
322 "service-rate": "100",
323 "node-id": "XPDRA01",
324 "service-format": "Ethernet",
325 "clli": "SNJSCAMCJP8",
328 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
329 "port-type": "router",
330 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
331 "port-rack": "000000.00",
335 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
336 "lgx-port-name": "LGX Back.3",
337 "lgx-port-rack": "000000.00",
338 "lgx-port-shelf": "00"
343 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
344 "port-type": "router",
345 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
346 "port-rack": "000000.00",
350 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
351 "lgx-port-name": "LGX Back.4",
352 "lgx-port-rack": "000000.00",
353 "lgx-port-shelf": "00"
359 "service-rate": "100",
360 "node-id": "XPDRC01",
361 "service-format": "Ethernet",
362 "clli": "SNJSCAMCJT4",
365 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
366 "port-type": "router",
367 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
368 "port-rack": "000000.00",
372 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
373 "lgx-port-name": "LGX Back.29",
374 "lgx-port-rack": "000000.00",
375 "lgx-port-shelf": "00"
380 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
381 "port-type": "router",
382 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
383 "port-rack": "000000.00",
387 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
388 "lgx-port-name": "LGX Back.30",
389 "lgx-port-rack": "000000.00",
390 "lgx-port-shelf": "00"
395 "due-date": "2016-11-28T00:00:01Z",
396 "operator-contact": "pw1234"
399 headers = {'content-type': 'application/json',
400 "Accept": "application/json"}
401 response = requests.request(
402 "POST", url, data=json.dumps(data), headers=headers,
403 auth=('admin', 'admin'))
404 self.assertEqual(response.status_code, requests.codes.ok)
405 res = response.json()
406 self.assertIn('PCE calculation in progress',
407 res['output']['configuration-response-common']['response-message'])
408 time.sleep(self.WAITING)
410 def test_12_get_eth_service1(self):
411 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
412 .format(self.restconf_baseurl))
413 headers = {'content-type': 'application/json',
414 "Accept": "application/json"}
415 response = requests.request(
416 "GET", url, headers=headers, auth=('admin', 'admin'))
417 self.assertEqual(response.status_code, requests.codes.ok)
418 res = response.json()
420 res['services'][0]['administrative-state'],
423 res['services'][0]['service-name'], 'service1')
425 res['services'][0]['connection-type'], 'service')
427 res['services'][0]['lifecycle-state'], 'planned')
430 def test_13_check_xc1_ROADMA(self):
431 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
432 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
433 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
434 .format(self.restconf_baseurl))
435 headers = {'content-type': 'application/json'}
436 response = requests.request(
437 "GET", url, headers=headers, auth=('admin', 'admin'))
438 self.assertEqual(response.status_code, requests.codes.ok)
439 res = response.json()
440 self.assertDictContainsSubset(
441 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
442 'wavelength-number': 1,
443 'opticalControlMode': 'gainLoss',
444 'target-output-power': -3.0},
445 res['roadm-connections'][0])
446 self.assertDictEqual(
447 {'src-if': 'SRG1-PP1-TXRX-1'},
448 res['roadm-connections'][0]['source'])
449 self.assertDictEqual(
450 {'dst-if': 'DEG1-TTP-TXRX-1'},
451 res['roadm-connections'][0]['destination'])
454 def test_14_check_xc1_ROADMC(self):
455 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
456 "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
457 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
458 .format(self.restconf_baseurl))
459 headers = {'content-type': 'application/json'}
460 response = requests.request(
461 "GET", url, headers=headers, auth=('admin', 'admin'))
462 self.assertEqual(response.status_code, requests.codes.ok)
463 res = response.json()
464 self.assertDictContainsSubset(
465 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
466 'wavelength-number': 1,
467 'opticalControlMode': 'gainLoss',
468 'target-output-power': 2.0},
469 res['roadm-connections'][0])
470 self.assertDictEqual(
471 {'src-if': 'SRG1-PP1-TXRX-1'},
472 res['roadm-connections'][0]['source'])
473 self.assertDictEqual(
474 {'dst-if': 'DEG2-TTP-TXRX-1'},
475 res['roadm-connections'][0]['destination'])
478 def test_15_check_topo_XPDRA(self):
479 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
480 .format(self.restconf_baseurl))
481 response = requests.request(
482 "GET", url1, auth=('admin', 'admin'))
483 self.assertEqual(response.status_code, requests.codes.ok)
484 res = response.json()
485 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
487 if ele['tp-id'] == 'XPDR1-NETWORK1':
488 self.assertEqual({u'frequency': 196.1, u'width': 40},
489 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
490 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
491 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
492 if ele['tp-id'] == 'XPDR1-NETWORK2':
493 self.assertNotIn('org-openroadm-network-topology:xpdr-network-attributes', dict.keys(ele))
496 def test_16_check_topo_ROADMA_SRG1(self):
497 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
498 .format(self.restconf_baseurl))
499 response = requests.request(
500 "GET", url1, auth=('admin', 'admin'))
501 self.assertEqual(response.status_code, requests.codes.ok)
502 res = response.json()
503 self.assertNotIn({u'index': 1},
504 res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
505 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
507 if ele['tp-id'] == 'SRG1-PP1-TXRX':
508 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
509 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
510 if ele['tp-id'] == 'SRG1-PP2-TXRX':
511 self.assertNotIn('used-wavelength', dict.keys(ele))
514 def test_17_check_topo_ROADMA_DEG1(self):
515 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
516 .format(self.restconf_baseurl))
517 response = requests.request(
518 "GET", url1, auth=('admin', 'admin'))
519 self.assertEqual(response.status_code, requests.codes.ok)
520 res = response.json()
521 self.assertNotIn({u'index': 1},
522 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
523 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
525 if ele['tp-id'] == 'DEG1-CTP-TXRX':
526 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
527 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
528 if ele['tp-id'] == 'DEG1-TTP-TXRX':
529 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
530 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
533 def test_18_connect_xprdA_N2_to_roadmA_PP2(self):
534 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
536 "networkutils:input": {
537 "networkutils:links-input": {
538 "networkutils:xpdr-node": "XPDRA01",
539 "networkutils:xpdr-num": "1",
540 "networkutils:network-num": "2",
541 "networkutils:rdm-node": "ROADMA01",
542 "networkutils:srg-num": "1",
543 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
547 headers = {'content-type': 'application/json'}
548 response = requests.request(
549 "POST", url, data=json.dumps(data),
550 headers=headers, auth=('admin', 'admin'))
551 self.assertEqual(response.status_code, requests.codes.ok)
552 res = response.json()
553 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
556 def test_19_connect_roadmA_PP2_to_xpdrA_N2(self):
557 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
559 "networkutils:input": {
560 "networkutils:links-input": {
561 "networkutils:xpdr-node": "XPDRA01",
562 "networkutils:xpdr-num": "1",
563 "networkutils:network-num": "2",
564 "networkutils:rdm-node": "ROADMA01",
565 "networkutils:srg-num": "1",
566 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
570 headers = {'content-type': 'application/json'}
571 response = requests.request(
572 "POST", url, data=json.dumps(data),
573 headers=headers, auth=('admin', 'admin'))
574 self.assertEqual(response.status_code, requests.codes.ok)
575 res = response.json()
576 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
579 def test_20_connect_xprdC_N2_to_roadmC_PP2(self):
580 url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links".format(self.restconf_baseurl)
582 "networkutils:input": {
583 "networkutils:links-input": {
584 "networkutils:xpdr-node": "XPDRC01",
585 "networkutils:xpdr-num": "1",
586 "networkutils:network-num": "2",
587 "networkutils:rdm-node": "ROADMC01",
588 "networkutils:srg-num": "1",
589 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
593 headers = {'content-type': 'application/json'}
594 response = requests.request(
595 "POST", url, data=json.dumps(data),
596 headers=headers, auth=('admin', 'admin'))
597 self.assertEqual(response.status_code, requests.codes.ok)
598 res = response.json()
599 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
602 def test_21_connect_roadmC_PP2_to_xpdrC_N2(self):
603 url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links".format(self.restconf_baseurl)
605 "networkutils:input": {
606 "networkutils:links-input": {
607 "networkutils:xpdr-node": "XPDRC01",
608 "networkutils:xpdr-num": "1",
609 "networkutils:network-num": "2",
610 "networkutils:rdm-node": "ROADMC01",
611 "networkutils:srg-num": "1",
612 "networkutils:termination-point-num": "SRG1-PP2-TXRX"
616 headers = {'content-type': 'application/json'}
617 response = requests.request(
618 "POST", url, data=json.dumps(data),
619 headers=headers, auth=('admin', 'admin'))
620 self.assertEqual(response.status_code, requests.codes.ok)
621 res = response.json()
622 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
625 def test_22_create_eth_service2(self):
626 url = ("{}/operations/org-openroadm-service:service-create"
627 .format(self.restconf_baseurl))
629 "sdnc-request-header": {
630 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
631 "rpc-action": "service-create",
632 "request-system-id": "appname",
633 "notification-url": "http://localhost:8585/NotificationServer/notify"
635 "service-name": "service2",
636 "common-id": "ASATT1234567",
637 "connection-type": "service",
639 "service-rate": "100",
640 "node-id": "XPDRA01",
641 "service-format": "Ethernet",
642 "clli": "SNJSCAMCJP8",
645 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
646 "port-type": "router",
647 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
648 "port-rack": "000000.00",
652 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
653 "lgx-port-name": "LGX Back.3",
654 "lgx-port-rack": "000000.00",
655 "lgx-port-shelf": "00"
660 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
661 "port-type": "router",
662 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
663 "port-rack": "000000.00",
667 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
668 "lgx-port-name": "LGX Back.4",
669 "lgx-port-rack": "000000.00",
670 "lgx-port-shelf": "00"
676 "service-rate": "100",
677 "node-id": "XPDRC01",
678 "service-format": "Ethernet",
679 "clli": "SNJSCAMCJT4",
682 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
683 "port-type": "router",
684 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
685 "port-rack": "000000.00",
689 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
690 "lgx-port-name": "LGX Back.29",
691 "lgx-port-rack": "000000.00",
692 "lgx-port-shelf": "00"
697 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
698 "port-type": "router",
699 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
700 "port-rack": "000000.00",
704 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
705 "lgx-port-name": "LGX Back.30",
706 "lgx-port-rack": "000000.00",
707 "lgx-port-shelf": "00"
712 "due-date": "2016-11-28T00:00:01Z",
713 "operator-contact": "pw1234"
716 headers = {'content-type': 'application/json',
717 "Accept": "application/json"}
718 response = requests.request(
719 "POST", url, data=json.dumps(data), headers=headers,
720 auth=('admin', 'admin'))
721 self.assertEqual(response.status_code, requests.codes.ok)
722 res = response.json()
723 self.assertIn('PCE calculation in progress',
724 res['output']['configuration-response-common']['response-message'])
725 time.sleep(self.WAITING)
727 def test_23_get_eth_service2(self):
728 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
729 .format(self.restconf_baseurl))
730 headers = {'content-type': 'application/json',
731 "Accept": "application/json"}
732 response = requests.request(
733 "GET", url, headers=headers, auth=('admin', 'admin'))
734 self.assertEqual(response.status_code, requests.codes.ok)
735 res = response.json()
737 res['services'][0]['administrative-state'],
740 res['services'][0]['service-name'], 'service2')
742 res['services'][0]['connection-type'], 'service')
744 res['services'][0]['lifecycle-state'], 'planned')
747 def test_24_check_xc2_ROADMA(self):
748 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
749 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
750 "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2"
751 .format(self.restconf_baseurl))
752 headers = {'content-type': 'application/json'}
753 response = requests.request(
754 "GET", url, headers=headers, auth=('admin', 'admin'))
755 self.assertEqual(response.status_code, requests.codes.ok)
756 res = response.json()
757 self.assertDictContainsSubset(
758 {'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
759 'wavelength-number': 2,
760 'opticalControlMode': 'power'},
761 res['roadm-connections'][0])
762 self.assertDictEqual(
763 {'src-if': 'DEG1-TTP-TXRX-2'},
764 res['roadm-connections'][0]['source'])
765 self.assertDictEqual(
766 {'dst-if': 'SRG1-PP2-TXRX-2'},
767 res['roadm-connections'][0]['destination'])
769 def test_25_check_topo_XPDRA(self):
770 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
771 .format(self.restconf_baseurl))
772 response = requests.request(
773 "GET", url1, auth=('admin', 'admin'))
774 self.assertEqual(response.status_code, requests.codes.ok)
775 res = response.json()
776 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
778 if ele['tp-id'] == 'XPDR1-NETWORK1':
779 self.assertEqual({u'frequency': 196.1, u'width': 40},
780 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
781 if ele['tp-id'] == 'XPDR1-NETWORK2':
782 self.assertEqual({u'frequency': 196.05, u'width': 40},
783 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
784 if ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3':
785 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
788 def test_26_check_topo_ROADMA_SRG1(self):
789 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
790 .format(self.restconf_baseurl))
791 response = requests.request(
792 "GET", url1, auth=('admin', 'admin'))
793 self.assertEqual(response.status_code, requests.codes.ok)
794 res = response.json()
795 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
796 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
797 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
799 if ele['tp-id'] == 'SRG1-PP1-TXRX':
800 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
801 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
802 self.assertNotIn({u'index': 2, u'frequency': 196.05, u'width': 40},
803 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
804 if ele['tp-id'] == 'SRG1-PP2-TXRX':
805 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
806 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
807 self.assertNotIn({u'index': 1, u'frequency': 196.1, u'width': 40},
808 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
809 if ele['tp-id'] == 'SRG1-PP3-TXRX':
810 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
813 def test_27_check_topo_ROADMA_DEG1(self):
814 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
815 .format(self.restconf_baseurl))
816 response = requests.request(
817 "GET", url1, auth=('admin', 'admin'))
818 self.assertEqual(response.status_code, requests.codes.ok)
819 res = response.json()
820 self.assertNotIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
821 self.assertNotIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
822 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
824 if ele['tp-id'] == 'DEG1-CTP-TXRX':
825 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
826 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
827 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
828 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
829 if ele['tp-id'] == 'DEG1-TTP-TXRX':
830 self.assertIn({u'index': 1, u'frequency': 196.1, u'width': 40},
831 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
832 self.assertIn({u'index': 2, u'frequency': 196.05, u'width': 40},
833 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
836 # creation service test on a non-available resource
837 def test_28_create_eth_service3(self):
838 url = ("{}/operations/org-openroadm-service:service-create"
839 .format(self.restconf_baseurl))
841 "sdnc-request-header": {
842 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
843 "rpc-action": "service-create",
844 "request-system-id": "appname",
845 "notification-url": "http://localhost:8585/NotificationServer/notify"
847 "service-name": "service3",
848 "common-id": "ASATT1234567",
849 "connection-type": "service",
851 "service-rate": "100",
852 "node-id": "XPDRA01",
853 "service-format": "Ethernet",
854 "clli": "SNJSCAMCJP8",
857 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
858 "port-type": "router",
859 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
860 "port-rack": "000000.00",
864 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
865 "lgx-port-name": "LGX Back.3",
866 "lgx-port-rack": "000000.00",
867 "lgx-port-shelf": "00"
872 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
873 "port-type": "router",
874 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
875 "port-rack": "000000.00",
879 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
880 "lgx-port-name": "LGX Back.4",
881 "lgx-port-rack": "000000.00",
882 "lgx-port-shelf": "00"
888 "service-rate": "100",
889 "node-id": "XPDRC01",
890 "service-format": "Ethernet",
891 "clli": "SNJSCAMCJT4",
894 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
895 "port-type": "router",
896 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
897 "port-rack": "000000.00",
901 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
902 "lgx-port-name": "LGX Back.29",
903 "lgx-port-rack": "000000.00",
904 "lgx-port-shelf": "00"
909 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
910 "port-type": "router",
911 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
912 "port-rack": "000000.00",
916 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
917 "lgx-port-name": "LGX Back.30",
918 "lgx-port-rack": "000000.00",
919 "lgx-port-shelf": "00"
924 "due-date": "2016-11-28T00:00:01Z",
925 "operator-contact": "pw1234"
928 headers = {'content-type': 'application/json',
929 "Accept": "application/json"}
930 response = requests.request(
931 "POST", url, data=json.dumps(data), headers=headers,
932 auth=('admin', 'admin'))
933 self.assertEqual(response.status_code, requests.codes.ok)
934 res = response.json()
935 self.assertIn('PCE calculation in progress',
936 res['output']['configuration-response-common']['response-message'])
937 self.assertIn('200', res['output']['configuration-response-common']['response-code'])
938 time.sleep(self.WAITING)
940 # add a test that check the openroadm-service-list still only contains 2 elements
942 def test_29_delete_eth_service3(self):
943 url = ("{}/operations/org-openroadm-service:service-delete"
944 .format(self.restconf_baseurl))
946 "sdnc-request-header": {
947 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
948 "rpc-action": "service-delete",
949 "request-system-id": "appname",
950 "notification-url": "http://localhost:8585/NotificationServer/notify"
952 "service-delete-req-info": {
953 "service-name": "service3",
954 "tail-retention": "no"
958 headers = {'content-type': 'application/json'}
959 response = requests.request(
960 "POST", url, data=json.dumps(data), headers=headers,
961 auth=('admin', 'admin'))
962 self.assertEqual(response.status_code, requests.codes.ok)
963 res = response.json()
964 self.assertIn('Service \'service3\' does not exist in datastore',
965 res['output']['configuration-response-common']['response-message'])
966 self.assertIn('500', res['output']['configuration-response-common']['response-code'])
969 def test_30_delete_eth_service1(self):
970 url = ("{}/operations/org-openroadm-service:service-delete"
971 .format(self.restconf_baseurl))
973 "sdnc-request-header": {
974 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
975 "rpc-action": "service-delete",
976 "request-system-id": "appname",
977 "notification-url": "http://localhost:8585/NotificationServer/notify"
979 "service-delete-req-info": {
980 "service-name": "service1",
981 "tail-retention": "no"
985 headers = {'content-type': 'application/json'}
986 response = requests.request(
987 "POST", url, data=json.dumps(data), headers=headers,
988 auth=('admin', 'admin'))
989 self.assertEqual(response.status_code, requests.codes.ok)
990 res = response.json()
991 self.assertIn('Renderer service delete in progress',
992 res['output']['configuration-response-common']['response-message'])
995 def test_31_delete_eth_service2(self):
996 url = ("{}/operations/org-openroadm-service:service-delete"
997 .format(self.restconf_baseurl))
999 "sdnc-request-header": {
1000 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1001 "rpc-action": "service-delete",
1002 "request-system-id": "appname",
1003 "notification-url": "http://localhost:8585/NotificationServer/notify"
1005 "service-delete-req-info": {
1006 "service-name": "service2",
1007 "tail-retention": "no"
1011 headers = {'content-type': 'application/json'}
1012 response = requests.request(
1013 "POST", url, data=json.dumps(data), headers=headers,
1014 auth=('admin', 'admin'))
1015 self.assertEqual(response.status_code, requests.codes.ok)
1016 res = response.json()
1017 self.assertIn('Renderer service delete in progress',
1018 res['output']['configuration-response-common']['response-message'])
1021 def test_32_check_no_xc_ROADMA(self):
1022 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1023 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1024 .format(self.restconf_baseurl))
1025 response = requests.request(
1026 "GET", url, auth=('admin', 'admin'))
1027 res = response.json()
1028 self.assertEqual(response.status_code, requests.codes.ok)
1029 self.assertNotIn('roadm-connections', dict.keys(res['org-openroadm-device']))
1032 def test_33_check_topo_XPDRA(self):
1033 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPDRA01-XPDR1"
1034 .format(self.restconf_baseurl))
1035 response = requests.request(
1036 "GET", url1, auth=('admin', 'admin'))
1037 self.assertEqual(response.status_code, requests.codes.ok)
1038 res = response.json()
1039 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1040 for ele in liste_tp:
1041 if ((ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-CLIENT')
1042 and (ele['tp-id'] == 'XPDR1-CLIENT1' or ele['tp-id'] == 'XPDR1-CLIENT3')):
1043 self.assertNotIn('org-openroadm-network-topology:xpdr-client-attributes', dict.keys(ele))
1044 elif (ele[u'org-openroadm-common-network:tp-type'] == 'XPONDER-NETWORK'):
1045 self.assertIn(u'tail-equipment-id', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1046 self.assertNotIn('wavelength', dict.keys(ele[u'org-openroadm-network-topology:xpdr-network-attributes']))
1049 def test_34_check_topo_ROADMA_SRG1(self):
1050 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
1051 .format(self.restconf_baseurl))
1052 response = requests.request(
1053 "GET", url1, auth=('admin', 'admin'))
1054 self.assertEqual(response.status_code, requests.codes.ok)
1055 res = response.json()
1056 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1057 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1058 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1059 for ele in liste_tp:
1060 if ele['tp-id'] == 'SRG1-PP1-TXRX' or ele['tp-id'] == 'SRG1-PP1-TXRX':
1061 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1063 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1066 def test_35_check_topo_ROADMA_DEG1(self):
1067 url1 = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-DEG1"
1068 .format(self.restconf_baseurl))
1069 response = requests.request(
1070 "GET", url1, auth=('admin', 'admin'))
1071 self.assertEqual(response.status_code, requests.codes.ok)
1072 res = response.json()
1073 self.assertIn({u'index': 1}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1074 self.assertIn({u'index': 2}, res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1075 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1076 for ele in liste_tp:
1077 if ele['tp-id'] == 'DEG1-CTP-TXRX':
1078 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1079 if ele['tp-id'] == 'DEG1-TTP-TXRX':
1080 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1084 # test service-create for Optical Channel (OC) service from srg-pp to srg-pp
1085 def test_36_create_oc_service1(self):
1086 url = ("{}/operations/org-openroadm-service:service-create"
1087 .format(self.restconf_baseurl))
1089 "sdnc-request-header": {
1090 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1091 "rpc-action": "service-create",
1092 "request-system-id": "appname",
1093 "notification-url": "http://localhost:8585/NotificationServer/notify"
1095 "service-name": "service1",
1096 "common-id": "ASATT1234567",
1097 "connection-type": "roadm-line",
1099 "service-rate": "100",
1100 "node-id": "ROADMA01",
1101 "service-format": "OC",
1102 "clli": "SNJSCAMCJP8",
1105 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1106 "port-type": "router",
1107 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1108 "port-rack": "000000.00",
1112 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1113 "lgx-port-name": "LGX Back.3",
1114 "lgx-port-rack": "000000.00",
1115 "lgx-port-shelf": "00"
1120 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1121 "port-type": "router",
1122 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1123 "port-rack": "000000.00",
1127 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1128 "lgx-port-name": "LGX Back.4",
1129 "lgx-port-rack": "000000.00",
1130 "lgx-port-shelf": "00"
1133 "optic-type": "gray"
1136 "service-rate": "100",
1137 "node-id": "ROADMC01",
1138 "service-format": "OC",
1139 "clli": "SNJSCAMCJT4",
1142 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1143 "port-type": "router",
1144 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1145 "port-rack": "000000.00",
1149 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1150 "lgx-port-name": "LGX Back.29",
1151 "lgx-port-rack": "000000.00",
1152 "lgx-port-shelf": "00"
1157 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1158 "port-type": "router",
1159 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1160 "port-rack": "000000.00",
1164 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1165 "lgx-port-name": "LGX Back.30",
1166 "lgx-port-rack": "000000.00",
1167 "lgx-port-shelf": "00"
1170 "optic-type": "gray"
1172 "due-date": "2016-11-28T00:00:01Z",
1173 "operator-contact": "pw1234"
1176 headers = {'content-type': 'application/json',
1177 "Accept": "application/json"}
1178 response = requests.request(
1179 "POST", url, data=json.dumps(data), headers=headers,
1180 auth=('admin', 'admin'))
1181 self.assertEqual(response.status_code, requests.codes.ok)
1182 res = response.json()
1183 self.assertIn('PCE calculation in progress',
1184 res['output']['configuration-response-common']['response-message'])
1185 time.sleep(self.WAITING)
1187 def test_37_get_oc_service1(self):
1188 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1189 .format(self.restconf_baseurl))
1190 headers = {'content-type': 'application/json',
1191 "Accept": "application/json"}
1192 response = requests.request(
1193 "GET", url, headers=headers, auth=('admin', 'admin'))
1194 self.assertEqual(response.status_code, requests.codes.ok)
1195 res = response.json()
1197 res['services'][0]['administrative-state'],
1200 res['services'][0]['service-name'], 'service1')
1202 res['services'][0]['connection-type'], 'roadm-line')
1204 res['services'][0]['lifecycle-state'], 'planned')
1207 def test_38_check_xc1_ROADMA(self):
1208 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1209 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1210 "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1"
1211 .format(self.restconf_baseurl))
1212 headers = {'content-type': 'application/json'}
1213 response = requests.request(
1214 "GET", url, headers=headers, auth=('admin', 'admin'))
1215 self.assertEqual(response.status_code, requests.codes.ok)
1216 res = response.json()
1217 self.assertDictContainsSubset(
1218 {'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
1219 'wavelength-number': 1,
1220 'opticalControlMode': 'gainLoss',
1221 'target-output-power': -3.0},
1222 res['roadm-connections'][0])
1223 self.assertDictEqual(
1224 {'src-if': 'SRG1-PP1-TXRX-1'},
1225 res['roadm-connections'][0]['source'])
1226 self.assertDictEqual(
1227 {'dst-if': 'DEG1-TTP-TXRX-1'},
1228 res['roadm-connections'][0]['destination'])
1231 def test_39_check_xc1_ROADMC(self):
1232 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1233 "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1234 "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1"
1235 .format(self.restconf_baseurl))
1236 headers = {'content-type': 'application/json'}
1237 response = requests.request(
1238 "GET", url, headers=headers, auth=('admin', 'admin'))
1239 self.assertEqual(response.status_code, requests.codes.ok)
1240 res = response.json()
1241 self.assertDictContainsSubset(
1242 {'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
1243 'wavelength-number': 1,
1244 'opticalControlMode': 'gainLoss',
1245 'target-output-power': 2.0},
1246 res['roadm-connections'][0])
1247 self.assertDictEqual(
1248 {'src-if': 'SRG1-PP1-TXRX-1'},
1249 res['roadm-connections'][0]['source'])
1250 self.assertDictEqual(
1251 {'dst-if': 'DEG2-TTP-TXRX-1'},
1252 res['roadm-connections'][0]['destination'])
1255 def test_40_create_oc_service2(self):
1256 url = ("{}/operations/org-openroadm-service:service-create"
1257 .format(self.restconf_baseurl))
1259 "sdnc-request-header": {
1260 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1261 "rpc-action": "service-create",
1262 "request-system-id": "appname",
1263 "notification-url": "http://localhost:8585/NotificationServer/notify"
1265 "service-name": "service2",
1266 "common-id": "ASATT1234567",
1267 "connection-type": "roadm-line",
1269 "service-rate": "100",
1270 "node-id": "ROADMA01",
1271 "service-format": "OC",
1272 "clli": "SNJSCAMCJP8",
1275 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1276 "port-type": "router",
1277 "port-name": "Gigabit Ethernet_Tx.ge-5/0/0.0",
1278 "port-rack": "000000.00",
1282 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1283 "lgx-port-name": "LGX Back.3",
1284 "lgx-port-rack": "000000.00",
1285 "lgx-port-shelf": "00"
1290 "port-device-name": "ROUTER_SNJSCAMCJP8_000000.00_00",
1291 "port-type": "router",
1292 "port-name": "Gigabit Ethernet_Rx.ge-5/0/0.0",
1293 "port-rack": "000000.00",
1297 "lgx-device-name": "LGX Panel_SNJSCAMCJP8_000000.00_00",
1298 "lgx-port-name": "LGX Back.4",
1299 "lgx-port-rack": "000000.00",
1300 "lgx-port-shelf": "00"
1303 "optic-type": "gray"
1306 "service-rate": "100",
1307 "node-id": "ROADMC01",
1308 "service-format": "OC",
1309 "clli": "SNJSCAMCJT4",
1312 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1313 "port-type": "router",
1314 "port-name": "Gigabit Ethernet_Tx.ge-1/0/0.0",
1315 "port-rack": "000000.00",
1319 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1320 "lgx-port-name": "LGX Back.29",
1321 "lgx-port-rack": "000000.00",
1322 "lgx-port-shelf": "00"
1327 "port-device-name": "ROUTER_SNJSCAMCJT4_000000.00_00",
1328 "port-type": "router",
1329 "port-name": "Gigabit Ethernet_Rx.ge-1/0/0.0",
1330 "port-rack": "000000.00",
1334 "lgx-device-name": "LGX Panel_SNJSCAMCJT4_000000.00_00",
1335 "lgx-port-name": "LGX Back.30",
1336 "lgx-port-rack": "000000.00",
1337 "lgx-port-shelf": "00"
1340 "optic-type": "gray"
1342 "due-date": "2016-11-28T00:00:01Z",
1343 "operator-contact": "pw1234"
1346 headers = {'content-type': 'application/json',
1347 "Accept": "application/json"}
1348 response = requests.request(
1349 "POST", url, data=json.dumps(data), headers=headers,
1350 auth=('admin', 'admin'))
1351 self.assertEqual(response.status_code, requests.codes.ok)
1352 res = response.json()
1353 self.assertIn('PCE calculation in progress',
1354 res['output']['configuration-response-common']['response-message'])
1355 time.sleep(self.WAITING)
1357 def test_41_get_oc_service2(self):
1358 url = ("{}/operational/org-openroadm-service:service-list/services/service2"
1359 .format(self.restconf_baseurl))
1360 headers = {'content-type': 'application/json',
1361 "Accept": "application/json"}
1362 response = requests.request(
1363 "GET", url, headers=headers, auth=('admin', 'admin'))
1364 self.assertEqual(response.status_code, requests.codes.ok)
1365 res = response.json()
1367 res['services'][0]['administrative-state'],
1370 res['services'][0]['service-name'], 'service2')
1372 res['services'][0]['connection-type'], 'roadm-line')
1374 res['services'][0]['lifecycle-state'], 'planned')
1377 def test_42_check_xc2_ROADMA(self):
1378 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
1379 "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1380 "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2"
1381 .format(self.restconf_baseurl))
1382 headers = {'content-type': 'application/json'}
1383 response = requests.request(
1384 "GET", url, headers=headers, auth=('admin', 'admin'))
1385 self.assertEqual(response.status_code, requests.codes.ok)
1386 res = response.json()
1387 self.assertDictContainsSubset(
1388 {'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
1389 'wavelength-number': 2,
1390 'opticalControlMode': 'gainLoss',
1391 'target-output-power': -3.0},
1392 res['roadm-connections'][0])
1393 self.assertDictEqual(
1394 {'src-if': 'SRG1-PP2-TXRX-2'},
1395 res['roadm-connections'][0]['source'])
1396 self.assertDictEqual(
1397 {'dst-if': 'DEG1-TTP-TXRX-2'},
1398 res['roadm-connections'][0]['destination'])
1401 def test_43_check_topo_ROADMA(self):
1402 self.test_26_check_topo_ROADMA_SRG1()
1403 self.test_27_check_topo_ROADMA_DEG1()
1406 def test_44_delete_oc_service1(self):
1407 url = ("{}/operations/org-openroadm-service:service-delete"
1408 .format(self.restconf_baseurl))
1410 "sdnc-request-header": {
1411 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1412 "rpc-action": "service-delete",
1413 "request-system-id": "appname",
1414 "notification-url": "http://localhost:8585/NotificationServer/notify"
1416 "service-delete-req-info": {
1417 "service-name": "service1",
1418 "tail-retention": "no"
1422 headers = {'content-type': 'application/json'}
1423 response = requests.request(
1424 "POST", url, data=json.dumps(data), headers=headers,
1425 auth=('admin', 'admin'))
1426 self.assertEqual(response.status_code, requests.codes.ok)
1427 res = response.json()
1428 self.assertIn('Renderer service delete in progress',
1429 res['output']['configuration-response-common']['response-message'])
1432 def test_45_delete_oc_service2(self):
1433 url = ("{}/operations/org-openroadm-service:service-delete"
1434 .format(self.restconf_baseurl))
1436 "sdnc-request-header": {
1437 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1438 "rpc-action": "service-delete",
1439 "request-system-id": "appname",
1440 "notification-url": "http://localhost:8585/NotificationServer/notify"
1442 "service-delete-req-info": {
1443 "service-name": "service2",
1444 "tail-retention": "no"
1448 headers = {'content-type': 'application/json'}
1449 response = requests.request(
1450 "POST", url, data=json.dumps(data), headers=headers,
1451 auth=('admin', 'admin'))
1452 self.assertEqual(response.status_code, requests.codes.ok)
1453 res = response.json()
1454 self.assertIn('Renderer service delete in progress',
1455 res['output']['configuration-response-common']['response-message'])
1458 def test_46_get_no_oc_services(self):
1459 print ("start test")
1460 url = ("{}/operational/org-openroadm-service:service-list"
1461 .format(self.restconf_baseurl))
1462 headers = {'content-type': 'application/json',
1463 "Accept": "application/json"}
1464 response = requests.request(
1465 "GET", url, headers=headers, auth=('admin', 'admin'))
1466 self.assertEqual(response.status_code, requests.codes.not_found)
1467 res = response.json()
1469 {"error-type":"application", "error-tag":"data-missing",
1470 "error-message":"Request could not be completed because the relevant data model content does not exist"},
1471 res['errors']['error'])
1474 def test_47_get_no_xc_ROADMA(self):
1475 url = ("{}/config/network-topology:network-topology/topology/topology-netconf"
1476 "/node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
1477 .format(self.restconf_baseurl))
1478 headers = {'content-type': 'application/json',
1479 "Accept": "application/json"}
1480 response = requests.request(
1481 "GET", url, headers=headers, auth=('admin', 'admin'))
1482 self.assertEqual(response.status_code, requests.codes.ok)
1483 res = response.json()
1484 self.assertNotIn(['roadm-connections'][0], res['org-openroadm-device'])
1487 def test_48_check_topo_ROADMA(self):
1488 self.test_34_check_topo_ROADMA_SRG1()
1489 self.test_35_check_topo_ROADMA_DEG1()
1491 def test_49_loop_create_eth_service(self):
1492 for i in range(1,6):
1493 print ("trial number {}".format(i))
1494 print("eth service creation")
1495 self.test_11_create_eth_service1()
1496 print ("check xc in ROADMA01")
1497 self.test_13_check_xc1_ROADMA()
1498 print ("check xc in ROADMC01")
1499 self.test_14_check_xc1_ROADMC()
1500 print ("eth service deletion\n")
1501 self.test_30_delete_eth_service1()
1503 def test_50_loop_create_oc_service(self):
1504 url = ("{}/operational/org-openroadm-service:service-list/services/service1"
1505 .format(self.restconf_baseurl))
1506 response = requests.request("GET", url, auth=('admin', 'admin'))
1507 if response.status_code != 404:
1508 url = ("{}/operations/org-openroadm-service:service-delete"
1509 .format(self.restconf_baseurl))
1511 "sdnc-request-header": {
1512 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1513 "rpc-action": "service-delete",
1514 "request-system-id": "appname",
1515 "notification-url": "http://localhost:8585/NotificationServer/notify"
1517 "service-delete-req-info": {
1518 "service-name": "service1",
1519 "tail-retention": "no"
1523 headers = {'content-type': 'application/json'}
1524 requests.request("POST", url, data=json.dumps(data), headers=headers, auth=('admin', 'admin'))
1527 for i in range(1,6):
1528 print ("trial number {}".format(i))
1529 print("oc service creation")
1530 self.test_36_create_oc_service1()
1531 print ("check xc in ROADMA01")
1532 self.test_38_check_xc1_ROADMA()
1533 print ("check xc in ROADMC01")
1534 self.test_39_check_xc1_ROADMC()
1535 print ("oc service deletion\n")
1536 self.test_44_delete_oc_service1()
1538 def test_51_disconnect_XPDRA(self):
1539 url = ("{}/config/network-topology:"
1540 "network-topology/topology/topology-netconf/node/XPDRA01"
1541 .format(self.restconf_baseurl))
1542 headers = {'content-type': 'application/json'}
1543 response = requests.request(
1544 "DELETE", url, headers=headers,
1545 auth=('admin', 'admin'))
1546 self.assertEqual(response.status_code, requests.codes.ok)
1549 def test_52_disconnect_XPDRC(self):
1550 url = ("{}/config/network-topology:"
1551 "network-topology/topology/topology-netconf/node/XPDRC01"
1552 .format(self.restconf_baseurl))
1553 headers = {'content-type': 'application/json'}
1554 response = requests.request(
1555 "DELETE", url, headers=headers,
1556 auth=('admin', 'admin'))
1557 self.assertEqual(response.status_code, requests.codes.ok)
1560 def test_53_disconnect_ROADMA(self):
1561 url = ("{}/config/network-topology:"
1562 "network-topology/topology/topology-netconf/node/ROADMA01"
1563 .format(self.restconf_baseurl))
1564 headers = {'content-type': 'application/json'}
1565 response = requests.request(
1566 "DELETE", url, headers=headers,
1567 auth=('admin', 'admin'))
1568 self.assertEqual(response.status_code, requests.codes.ok)
1571 def test_54_disconnect_ROADMC(self):
1572 url = ("{}/config/network-topology:"
1573 "network-topology/topology/topology-netconf/node/ROADMC01"
1574 .format(self.restconf_baseurl))
1575 headers = {'content-type': 'application/json'}
1576 response = requests.request(
1577 "DELETE", url, headers=headers,
1578 auth=('admin', 'admin'))
1579 self.assertEqual(response.status_code, requests.codes.ok)
1583 if __name__ == "__main__":
1584 unittest.main(verbosity=2)