3 ##############################################################################
4 # Copyright (c) 2020 Orange, Inc. and others. All rights reserved.
6 # All rights reserved. This program and the accompanying materials
7 # are made available under the terms of the Apache License, Version 2.0
8 # which accompanies this distribution, and is available at
9 # http://www.apache.org/licenses/LICENSE-2.0
10 ##############################################################################
15 from common import test_utils
18 class TransportPCEtesting(unittest.TestCase):
21 WAITING = 20 # nominal value is 300
25 cls.processes = test_utils.start_tpce()
26 cls.processes = test_utils.start_sims(['spdra', 'roadma', 'roadmc', 'spdrc'])
29 def tearDownClass(cls):
30 for process in cls.processes:
31 test_utils.shutdown_process(process)
32 print("all processes killed")
37 def test_01_connect_spdrA(self):
38 response = test_utils.mount_device("SPDR-SA1", 'spdra')
39 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
41 def test_02_connect_spdrC(self):
42 response = test_utils.mount_device("SPDR-SC1", 'spdrc')
43 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
45 def test_03_connect_rdmA(self):
46 response = test_utils.mount_device("ROADM-A1", 'roadma')
47 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
49 def test_04_connect_rdmC(self):
50 response = test_utils.mount_device("ROADM-C1", 'roadmc')
51 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
53 def test_05_connect_sprdA_N1_to_roadmA_PP1(self):
54 response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "1", "1",
55 "ROADM-A1", "1", "SRG1-PP1-TXRX")
56 self.assertEqual(response.status_code, requests.codes.ok)
58 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
61 def test_06_connect_roadmA_PP1_to_spdrA_N1(self):
62 response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "1", "1",
63 "ROADM-A1", "1", "SRG1-PP1-TXRX")
64 self.assertEqual(response.status_code, requests.codes.ok)
66 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
69 def test_07_connect_sprdC_N1_to_roadmC_PP1(self):
70 response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "1", "1",
71 "ROADM-C1", "1", "SRG1-PP1-TXRX")
72 self.assertEqual(response.status_code, requests.codes.ok)
74 self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
77 def test_08_connect_roadmC_PP1_to_spdrC_N1(self):
78 response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "1", "1",
79 "ROADM-C1", "1", "SRG1-PP1-TXRX")
80 self.assertEqual(response.status_code, requests.codes.ok)
82 self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
85 def test_09_add_omsAttributes_ROADMA_ROADMC(self):
86 # Config ROADMA-ROADMC oms-attributes
88 "auto-spanloss": "true",
89 "spanloss-base": 11.4,
90 "spanloss-current": 12,
91 "engineered-spanloss": 12.2,
92 "link-concatenation": [{
95 "SRLG-length": 100000,
97 response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
98 self.assertEqual(response.status_code, requests.codes.created)
100 def test_10_add_omsAttributes_ROADMC_ROADMA(self):
101 # Config ROADMC-ROADMA oms-attributes
103 "auto-spanloss": "true",
104 "spanloss-base": 11.4,
105 "spanloss-current": 12,
106 "engineered-spanloss": 12.2,
107 "link-concatenation": [{
110 "SRLG-length": 100000,
112 response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
113 self.assertEqual(response.status_code, requests.codes.created)
115 # test service-create for OCH-OTU4 service from spdr to spdr
116 def test_11_check_otn_topology(self):
117 url = "{}/config/ietf-network:networks/network/otn-topology"
118 response = test_utils.get_request(url)
119 self.assertEqual(response.status_code, requests.codes.ok)
120 res = response.json()
121 nbNode = len(res['network'][0]['node'])
122 self.assertEqual(nbNode, 4)
123 self.assertNotIn('ietf-network-topology:link', res['network'][0])
125 def test_12_create_OCH_OTU4_service(self):
126 url = "{}/operations/org-openroadm-service:service-create"
128 "sdnc-request-header": {
129 "request-id": "request-1",
130 "rpc-action": "service-create",
131 "request-system-id": "appname"
133 "service-name": "service1-OCH-OTU4",
134 "common-id": "commonId",
135 "connection-type": "infrastructure",
137 "service-rate": "100",
138 "node-id": "SPDR-SA1",
139 "service-format": "OTU",
140 "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
144 "committed-info-rate": "100000",
145 "committed-burst-size": "64"
150 "port-device-name": "SPDR-SA1-XPDR1",
151 "port-type": "fixed",
152 "port-name": "XPDR1-NETWORK1",
153 "port-rack": "000000.00",
154 "port-shelf": "Chassis#1"
157 "lgx-device-name": "Some lgx-device-name",
158 "lgx-port-name": "Some lgx-port-name",
159 "lgx-port-rack": "000000.00",
160 "lgx-port-shelf": "00"
165 "port-device-name": "SPDR-SA1-XPDR1",
166 "port-type": "fixed",
167 "port-name": "XPDR1-NETWORK1",
168 "port-rack": "000000.00",
169 "port-shelf": "Chassis#1"
172 "lgx-device-name": "Some lgx-device-name",
173 "lgx-port-name": "Some lgx-port-name",
174 "lgx-port-rack": "000000.00",
175 "lgx-port-shelf": "00"
181 "service-rate": "100",
182 "node-id": "SPDR-SC1",
183 "service-format": "OTU",
184 "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
188 "committed-info-rate": "100000",
189 "committed-burst-size": "64"
194 "port-device-name": "SPDR-SC1-XPDR1",
195 "port-type": "fixed",
196 "port-name": "XPDR1-NETWORK1",
197 "port-rack": "000000.00",
198 "port-shelf": "Chassis#1"
201 "lgx-device-name": "Some lgx-device-name",
202 "lgx-port-name": "Some lgx-port-name",
203 "lgx-port-rack": "000000.00",
204 "lgx-port-shelf": "00"
209 "port-device-name": "SPDR-SC1-XPDR1",
210 "port-type": "fixed",
211 "port-name": "XPDR1-NETWORK1",
212 "port-rack": "000000.00",
213 "port-shelf": "Chassis#1"
216 "lgx-device-name": "Some lgx-device-name",
217 "lgx-port-name": "Some lgx-port-name",
218 "lgx-port-rack": "000000.00",
219 "lgx-port-shelf": "00"
224 "due-date": "2018-06-15T00:00:01Z",
225 "operator-contact": "pw1234"
228 response = test_utils.post_request(url, data)
229 self.assertEqual(response.status_code, requests.codes.ok)
230 res = response.json()
231 self.assertIn('PCE calculation in progress',
232 res['output']['configuration-response-common']['response-message'])
233 time.sleep(self.WAITING)
235 def test_13_get_OCH_OTU4_service1(self):
236 url = "{}/operational/org-openroadm-service:service-list/services/service1-OCH-OTU4"
237 response = test_utils.get_request(url)
238 self.assertEqual(response.status_code, requests.codes.ok)
239 res = response.json()
241 res['services'][0]['administrative-state'], 'inService')
243 res['services'][0]['service-name'], 'service1-OCH-OTU4')
245 res['services'][0]['connection-type'], 'infrastructure')
247 res['services'][0]['lifecycle-state'], 'planned')
250 # Check correct configuration of devices
251 def test_14_check_interface_och_spdra(self):
252 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
253 self.assertEqual(response.status_code, requests.codes.ok)
254 res = response.json()
255 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
256 'administrative-state': 'inService',
257 'supporting-circuit-pack-name': 'CP1-CFP0',
258 'type': 'org-openroadm-interfaces:opticalChannel',
259 'supporting-port': 'CP1-CFP0-P1'
260 }, **res['interface'][0]),
263 self.assertDictEqual(
264 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
265 u'transmit-power': -5},
266 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
268 def test_15_check_interface_OTU4_spdra(self):
269 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
270 self.assertEqual(response.status_code, requests.codes.ok)
271 res = response.json()
272 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
273 'administrative-state': 'inService',
274 'supporting-circuit-pack-name': 'CP1-CFP0',
275 'supporting-interface': 'XPDR1-NETWORK1-1',
276 'type': 'org-openroadm-interfaces:otnOtu',
277 'supporting-port': 'CP1-CFP0-P1'
279 input_dict_2 = {'tx-sapi': 'Swfw02qXGyI=',
280 'expected-dapi': 'Swfw02qXGyI=',
281 'rate': 'org-openroadm-otn-common-types:OTU4',
284 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
287 self.assertDictEqual(input_dict_2,
289 ['org-openroadm-otn-otu-interfaces:otu'])
291 def test_16_check_interface_och_spdrc(self):
292 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-1")
293 self.assertEqual(response.status_code, requests.codes.ok)
294 res = response.json()
295 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
296 'administrative-state': 'inService',
297 'supporting-circuit-pack-name': 'CP1-CFP0',
298 'type': 'org-openroadm-interfaces:opticalChannel',
299 'supporting-port': 'CP1-CFP0-P1'
300 }, **res['interface'][0]),
303 self.assertDictEqual(
304 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
305 u'transmit-power': -5},
306 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
308 def test_17_check_interface_OTU4_spdrc(self):
309 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
310 self.assertEqual(response.status_code, requests.codes.ok)
311 res = response.json()
312 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
313 'administrative-state': 'inService',
314 'supporting-circuit-pack-name': 'CP1-CFP0',
315 'supporting-interface': 'XPDR1-NETWORK1-1',
316 'type': 'org-openroadm-interfaces:otnOtu',
317 'supporting-port': 'CP1-CFP0-P1'
319 input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
320 'expected-sapi': 'Swfw02qXGyI=',
321 'tx-sapi': 'fuYZwEO660g=',
322 'expected-dapi': 'fuYZwEO660g=',
323 'rate': 'org-openroadm-otn-common-types:OTU4',
327 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
330 self.assertDictEqual(input_dict_2,
332 ['org-openroadm-otn-otu-interfaces:otu'])
334 def test_18_check_no_interface_ODU4_spdra(self):
335 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
336 self.assertEqual(response.status_code, requests.codes.not_found)
337 res = response.json()
339 {"error-type": "application", "error-tag": "data-missing",
340 "error-message": "Request could not be completed because the relevant data model content does not exist"},
341 res['errors']['error'])
343 def test_19_check_openroadm_topo_spdra(self):
344 response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR1")
345 self.assertEqual(response.status_code, requests.codes.ok)
346 res = response.json()
347 ele = res['node'][0]['ietf-network-topology:termination-point'][0]
348 self.assertEqual('XPDR1-NETWORK1', ele['tp-id'])
349 self.assertEqual({u'frequency': 196.1,
351 ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
354 def test_20_check_openroadm_topo_ROADMA_SRG(self):
355 response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
356 self.assertEqual(response.status_code, requests.codes.ok)
357 res = response.json()
358 self.assertNotIn({u'index': 1},
359 res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
360 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
362 if ele['tp-id'] == 'SRG1-PP1-TXRX':
363 self.assertIn({u'index': 1, u'frequency': 196.1,
365 ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
366 if ele['tp-id'] == 'SRG1-PP2-TXRX':
367 self.assertNotIn('used-wavelength', dict.keys(ele))
370 def test_21_check_openroadm_topo_ROADMA_DEG(self):
371 response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2")
372 self.assertEqual(response.status_code, requests.codes.ok)
373 res = response.json()
374 self.assertNotIn({u'index': 1},
375 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
376 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
378 if ele['tp-id'] == 'DEG2-CTP-TXRX':
379 self.assertIn({u'index': 1, u'frequency': 196.1,
381 ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
382 if ele['tp-id'] == 'DEG2-TTP-TXRX':
383 self.assertIn({u'index': 1, u'frequency': 196.1,
385 ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
388 def test_22_check_otn_topo_otu4_links(self):
389 url = "{}/config/ietf-network:networks/network/otn-topology"
390 response = test_utils.get_request(url)
391 self.assertEqual(response.status_code, requests.codes.ok)
392 res = response.json()
393 nb_links = len(res['network'][0]['ietf-network-topology:link'])
394 self.assertEqual(nb_links, 2)
395 listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
396 'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1']
397 for link in res['network'][0]['ietf-network-topology:link']:
398 self.assertIn(link['link-id'], listLinkId)
399 self.assertEqual(link['transportpce-topology:otn-link-type'], 'OTU4')
400 self.assertEqual(link['org-openroadm-common-network:link-type'], 'OTN-LINK')
401 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
402 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
403 self.assertIn(link['org-openroadm-common-network:opposite-link'], listLinkId)
405 # test service-create for ODU4 service from spdr to spdr
406 def test_23_create_ODU4_service(self):
407 url = "{}/operations/org-openroadm-service:service-create"
409 "sdnc-request-header": {
410 "request-id": "request-1",
411 "rpc-action": "service-create",
412 "request-system-id": "appname"
414 "service-name": "service1-ODU4",
415 "common-id": "commonId",
416 "connection-type": "infrastructure",
418 "service-rate": "100",
419 "node-id": "SPDR-SA1",
420 "service-format": "ODU",
421 "odu-service-rate": "org-openroadm-otn-common-types:ODU4",
425 "committed-info-rate": "100000",
426 "committed-burst-size": "64"
431 "port-device-name": "SPDR-SA1-XPDR1",
432 "port-type": "fixed",
433 "port-name": "XPDR1-NETWORK1",
434 "port-rack": "000000.00",
435 "port-shelf": "Chassis#1"
438 "lgx-device-name": "Some lgx-device-name",
439 "lgx-port-name": "Some lgx-port-name",
440 "lgx-port-rack": "000000.00",
441 "lgx-port-shelf": "00"
446 "port-device-name": "SPDR-SA1-XPDR1",
447 "port-type": "fixed",
448 "port-name": "XPDR1-NETWORK1",
449 "port-rack": "000000.00",
450 "port-shelf": "Chassis#1"
453 "lgx-device-name": "Some lgx-device-name",
454 "lgx-port-name": "Some lgx-port-name",
455 "lgx-port-rack": "000000.00",
456 "lgx-port-shelf": "00"
462 "service-rate": "100",
463 "node-id": "SPDR-SC1",
464 "service-format": "ODU",
465 "odu-service-rate": "org-openroadm-otn-common-types:ODU4",
469 "committed-info-rate": "100000",
470 "committed-burst-size": "64"
475 "port-device-name": "SPDR-SC1-XPDR1",
476 "port-type": "fixed",
477 "port-name": "XPDR1-NETWORK1",
478 "port-rack": "000000.00",
479 "port-shelf": "Chassis#1"
482 "lgx-device-name": "Some lgx-device-name",
483 "lgx-port-name": "Some lgx-port-name",
484 "lgx-port-rack": "000000.00",
485 "lgx-port-shelf": "00"
490 "port-device-name": "SPDR-SC1-XPDR1",
491 "port-type": "fixed",
492 "port-name": "XPDR1-NETWORK1",
493 "port-rack": "000000.00",
494 "port-shelf": "Chassis#1"
497 "lgx-device-name": "Some lgx-device-name",
498 "lgx-port-name": "Some lgx-port-name",
499 "lgx-port-rack": "000000.00",
500 "lgx-port-shelf": "00"
505 "due-date": "2018-06-15T00:00:01Z",
506 "operator-contact": "pw1234"
509 response = test_utils.post_request(url, data)
510 self.assertEqual(response.status_code, requests.codes.ok)
511 res = response.json()
512 self.assertIn('PCE calculation in progress',
513 res['output']['configuration-response-common']['response-message'])
514 time.sleep(self.WAITING)
516 def test_24_get_ODU4_service1(self):
517 url = "{}/operational/org-openroadm-service:service-list/services/service1-ODU4"
518 response = test_utils.get_request(url)
519 self.assertEqual(response.status_code, requests.codes.ok)
520 res = response.json()
522 res['services'][0]['administrative-state'], 'inService')
524 res['services'][0]['service-name'], 'service1-ODU4')
526 res['services'][0]['connection-type'], 'infrastructure')
528 res['services'][0]['lifecycle-state'], 'planned')
531 def test_25_check_interface_ODU4_spdra(self):
532 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
533 self.assertEqual(response.status_code, requests.codes.ok)
534 res = response.json()
535 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
536 'administrative-state': 'inService',
537 'supporting-circuit-pack-name': 'CP1-CFP0',
538 'supporting-interface': 'XPDR1-NETWORK1-OTU',
539 'type': 'org-openroadm-interfaces:otnOdu',
540 'supporting-port': 'CP1-CFP0-P1'}
541 # SAPI/DAPI are added in the Otu4 renderer
542 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
543 'rate': 'org-openroadm-otn-common-types:ODU4',
544 'expected-dapi': 'Swfw02qXGyI=',
545 'expected-sapi': 'fuYZwEO660g=',
546 'tx-dapi': 'fuYZwEO660g=',
547 'tx-sapi': 'Swfw02qXGyI='}
549 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
551 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
553 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
555 self.assertDictEqual(
556 {u'payload-type': u'21', u'exp-payload-type': u'21'},
557 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
559 def test_26_check_interface_ODU4_spdrc(self):
560 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
561 self.assertEqual(response.status_code, requests.codes.ok)
562 res = response.json()
563 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
564 'administrative-state': 'inService',
565 'supporting-circuit-pack-name': 'CP1-CFP0',
566 'supporting-interface': 'XPDR1-NETWORK1-OTU',
567 'type': 'org-openroadm-interfaces:otnOdu',
568 'supporting-port': 'CP1-CFP0-P1'}
569 # SAPI/DAPI are added in the Otu4 renderer
570 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
571 'rate': 'org-openroadm-otn-common-types:ODU4',
572 'tx-sapi': 'fuYZwEO660g=',
573 'tx-dapi': 'Swfw02qXGyI=',
574 'expected-sapi': 'Swfw02qXGyI=',
575 'expected-dapi': 'fuYZwEO660g='
577 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
579 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
581 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
583 self.assertDictEqual(
584 {u'payload-type': u'21', u'exp-payload-type': u'21'},
585 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
587 def test_27_check_otn_topo_links(self):
588 url = "{}/config/ietf-network:networks/network/otn-topology"
589 response = test_utils.get_request(url)
590 self.assertEqual(response.status_code, requests.codes.ok)
591 res = response.json()
592 nb_links = len(res['network'][0]['ietf-network-topology:link'])
593 self.assertEqual(nb_links, 4)
594 for link in res['network'][0]['ietf-network-topology:link']:
595 linkId = link['link-id']
596 if (linkId == 'OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
597 linkId == 'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
598 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 0)
599 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
600 elif (linkId == 'ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
601 linkId == 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
602 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
603 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
604 self.assertEqual(link['transportpce-topology:otn-link-type'], 'ODTU4')
605 self.assertEqual(link['org-openroadm-common-network:link-type'], 'OTN-LINK')
606 self.assertIn(link['org-openroadm-common-network:opposite-link'],
607 ['ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
608 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'])
610 self.fail("this link should not exist")
612 def test_28_check_otn_topo_tp(self):
613 url = "{}/config/ietf-network:networks/network/otn-topology"
614 response = test_utils.get_request(url)
615 res = response.json()
616 for node in res['network'][0]['node']:
617 if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
618 tpList = node['ietf-network-topology:termination-point']
620 if (tp['tp-id'] == 'XPDR1-NETWORK1'):
621 xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
622 self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
623 self.assertEqual(len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
624 self.assertEqual(xpdrTpPortConAt['odtu-tpn-pool'][0]['odtu-type'],
625 'org-openroadm-otn-common-types:ODTU4.ts-Allocated')
627 # test service-create for 10GE service from spdr to spdr
628 def test_29_create_10GE_service(self):
629 url = "{}/operations/org-openroadm-service:service-create"
631 "sdnc-request-header": {
632 "request-id": "request-1",
633 "rpc-action": "service-create",
634 "request-system-id": "appname"
636 "service-name": "service1-10GE",
637 "common-id": "commonId",
638 "connection-type": "service",
640 "service-rate": "10",
641 "node-id": "SPDR-SA1",
642 "service-format": "Ethernet",
646 "committed-info-rate": "100000",
647 "committed-burst-size": "64"
652 "port-device-name": "SPDR-SA1-XPDR1",
653 "port-type": "fixed",
654 "port-name": "XPDR1-CLIENT1",
655 "port-rack": "000000.00",
656 "port-shelf": "Chassis#1"
659 "lgx-device-name": "Some lgx-device-name",
660 "lgx-port-name": "Some lgx-port-name",
661 "lgx-port-rack": "000000.00",
662 "lgx-port-shelf": "00"
667 "port-device-name": "SPDR-SA1-XPDR1",
668 "port-type": "fixed",
669 "port-name": "XPDR1-CLIENT1",
670 "port-rack": "000000.00",
671 "port-shelf": "Chassis#1"
674 "lgx-device-name": "Some lgx-device-name",
675 "lgx-port-name": "Some lgx-port-name",
676 "lgx-port-rack": "000000.00",
677 "lgx-port-shelf": "00"
683 "service-rate": "10",
684 "node-id": "SPDR-SC1",
685 "service-format": "Ethernet",
689 "committed-info-rate": "100000",
690 "committed-burst-size": "64"
695 "port-device-name": "SPDR-SC1-XPDR1",
696 "port-type": "fixed",
697 "port-name": "XPDR1-CLIENT1",
698 "port-rack": "000000.00",
699 "port-shelf": "Chassis#1"
702 "lgx-device-name": "Some lgx-device-name",
703 "lgx-port-name": "Some lgx-port-name",
704 "lgx-port-rack": "000000.00",
705 "lgx-port-shelf": "00"
710 "port-device-name": "SPDR-SC1-XPDR1",
711 "port-type": "fixed",
712 "port-name": "XPDR1-CLIENT1",
713 "port-rack": "000000.00",
714 "port-shelf": "Chassis#1"
717 "lgx-device-name": "Some lgx-device-name",
718 "lgx-port-name": "Some lgx-port-name",
719 "lgx-port-rack": "000000.00",
720 "lgx-port-shelf": "00"
725 "due-date": "2018-06-15T00:00:01Z",
726 "operator-contact": "pw1234"
729 response = test_utils.post_request(url, data)
730 self.assertEqual(response.status_code, requests.codes.ok)
731 res = response.json()
732 self.assertIn('PCE calculation in progress',
733 res['output']['configuration-response-common']['response-message'])
734 time.sleep(self.WAITING)
736 def test_30_get_10GE_service1(self):
737 url = "{}/operational/org-openroadm-service:service-list/services/service1-10GE"
738 response = test_utils.get_request(url)
739 self.assertEqual(response.status_code, requests.codes.ok)
740 res = response.json()
742 res['services'][0]['administrative-state'], 'inService')
744 res['services'][0]['service-name'], 'service1-10GE')
746 res['services'][0]['connection-type'], 'service')
748 res['services'][0]['lifecycle-state'], 'planned')
751 def test_31_check_interface_10GE_CLIENT_spdra(self):
752 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
753 self.assertEqual(response.status_code, requests.codes.ok)
754 res = response.json()
755 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
756 'administrative-state': 'inService',
757 'supporting-circuit-pack-name': 'CP1-SFP4',
758 'type': 'org-openroadm-interfaces:ethernetCsmacd',
759 'supporting-port': 'CP1-SFP4-P1'
761 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
763 self.assertDictEqual(
765 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
767 def test_32_check_interface_ODU2E_CLIENT_spdra(self):
768 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1-10GE")
769 self.assertEqual(response.status_code, requests.codes.ok)
770 res = response.json()
771 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1-10GE',
772 'administrative-state': 'inService',
773 'supporting-circuit-pack-name': 'CP1-SFP4',
774 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
775 'type': 'org-openroadm-interfaces:otnOdu',
776 'supporting-port': 'CP1-SFP4-P1'}
778 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
779 'rate': 'org-openroadm-otn-common-types:ODU2e',
780 'monitoring-mode': 'terminated'}
782 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
784 self.assertDictEqual(dict(input_dict_2,
785 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
786 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
787 self.assertDictEqual(
788 {u'payload-type': u'03', u'exp-payload-type': u'03'},
789 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
791 def test_33_check_interface_ODU2E_NETWORK_spdra(self):
792 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1-10GE")
793 self.assertEqual(response.status_code, requests.codes.ok)
794 res = response.json()
795 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1-10GE',
796 'administrative-state': 'inService',
797 'supporting-circuit-pack-name': 'CP1-CFP0',
798 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
799 'type': 'org-openroadm-interfaces:otnOdu',
800 'supporting-port': 'CP1-CFP0-P1'}
802 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
803 'rate': 'org-openroadm-otn-common-types:ODU2e',
804 'monitoring-mode': 'monitored'}
805 input_dict_3 = {'trib-port-number': 1}
807 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
809 self.assertDictEqual(dict(input_dict_2,
810 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
811 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
812 self.assertDictEqual(dict(input_dict_3,
813 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
814 'parent-odu-allocation']),
815 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
816 self.assertIn(1, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
819 def test_34_check_ODU2E_connection_spdra(self):
820 response = test_utils.check_netconf_node_request(
822 "odu-connection/XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE")
823 self.assertEqual(response.status_code, requests.codes.ok)
824 res = response.json()
827 'XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE',
828 'direction': 'bidirectional'
831 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
832 res['odu-connection'][0])
833 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1-10GE'},
834 res['odu-connection'][0]['destination'])
835 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1-10GE'},
836 res['odu-connection'][0]['source'])
838 def test_35_check_interface_10GE_CLIENT_spdrc(self):
839 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
840 self.assertEqual(response.status_code, requests.codes.ok)
841 res = response.json()
842 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
843 'administrative-state': 'inService',
844 'supporting-circuit-pack-name': 'CP1-SFP4',
845 'type': 'org-openroadm-interfaces:ethernetCsmacd',
846 'supporting-port': 'CP1-SFP4-P1'
848 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
850 self.assertDictEqual(
852 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
854 def test_36_check_interface_ODU2E_CLIENT_spdrc(self):
855 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-service1-10GE")
856 self.assertEqual(response.status_code, requests.codes.ok)
857 res = response.json()
858 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1-10GE',
859 'administrative-state': 'inService',
860 'supporting-circuit-pack-name': 'CP1-SFP4',
861 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
862 'type': 'org-openroadm-interfaces:otnOdu',
863 'supporting-port': 'CP1-SFP4-P1'}
865 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
866 'rate': 'org-openroadm-otn-common-types:ODU2e',
867 'monitoring-mode': 'terminated'}
869 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
871 self.assertDictEqual(dict(input_dict_2,
872 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
873 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
874 self.assertDictEqual(
875 {u'payload-type': u'03', u'exp-payload-type': u'03'},
876 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
878 def test_37_check_interface_ODU2E_NETWORK_spdrc(self):
879 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-service1-10GE")
880 self.assertEqual(response.status_code, requests.codes.ok)
881 res = response.json()
882 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1-10GE',
883 'administrative-state': 'inService',
884 'supporting-circuit-pack-name': 'CP1-CFP0',
885 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
886 'type': 'org-openroadm-interfaces:otnOdu',
887 'supporting-port': 'CP1-CFP0-P1'}
889 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
890 'rate': 'org-openroadm-otn-common-types:ODU2e',
891 'monitoring-mode': 'monitored'}
893 input_dict_3 = {'trib-port-number': 1}
895 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
897 self.assertDictEqual(dict(input_dict_2,
898 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
899 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
900 self.assertDictEqual(dict(input_dict_3,
901 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
902 'parent-odu-allocation']),
903 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
904 'parent-odu-allocation'])
907 'org-openroadm-otn-odu-interfaces:odu'][
908 'parent-odu-allocation']['trib-slots'])
910 def test_38_check_ODU2E_connection_spdrc(self):
911 response = test_utils.check_netconf_node_request(
913 "odu-connection/XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE")
914 self.assertEqual(response.status_code, requests.codes.ok)
915 res = response.json()
918 'XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE',
919 'direction': 'bidirectional'
922 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
923 res['odu-connection'][0])
924 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1-10GE'},
925 res['odu-connection'][0]['destination'])
926 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1-10GE'},
927 res['odu-connection'][0]['source'])
929 def test_39_check_otn_topo_links(self):
930 url = "{}/config/ietf-network:networks/network/otn-topology"
931 response = test_utils.get_request(url)
932 self.assertEqual(response.status_code, requests.codes.ok)
933 res = response.json()
934 nb_links = len(res['network'][0]['ietf-network-topology:link'])
935 self.assertEqual(nb_links, 4)
936 for link in res['network'][0]['ietf-network-topology:link']:
937 linkId = link['link-id']
938 if (linkId == 'ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
939 linkId == 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
940 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 90000)
941 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
943 def test_40_check_otn_topo_tp(self):
944 url = "{}/config/ietf-network:networks/network/otn-topology"
945 response = test_utils.get_request(url)
946 res = response.json()
947 for node in res['network'][0]['node']:
948 if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
949 tpList = node['ietf-network-topology:termination-point']
951 if (tp['tp-id'] == 'XPDR1-NETWORK1'):
952 xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
953 self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 72)
954 tsPoolList = [i for i in range(1, 9)]
955 self.assertNotIn(tsPoolList, xpdrTpPortConAt['ts-pool'])
956 self.assertEqual(len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 79)
957 self.assertNotIn(1, xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool'])
959 def test_41_delete_10GE_service(self):
960 url = "{}/operations/org-openroadm-service:service-delete"
962 "sdnc-request-header": {
963 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
964 "rpc-action": "service-delete",
965 "request-system-id": "appname",
966 "notification-url": "http://localhost:8585/NotificationServer/notify"
968 "service-delete-req-info": {
969 "service-name": "service1-10GE",
970 "tail-retention": "no"
974 response = test_utils.post_request(url, data)
975 self.assertEqual(response.status_code, requests.codes.ok)
976 res = response.json()
977 self.assertIn('Renderer service delete in progress',
978 res['output']['configuration-response-common']['response-message'])
981 def test_42_check_service_list(self):
982 url = "{}/operational/org-openroadm-service:service-list"
983 response = test_utils.get_request(url)
984 self.assertEqual(response.status_code, requests.codes.ok)
985 res = response.json()
986 self.assertEqual(len(res['service-list']['services']), 2)
989 def test_43_check_no_ODU2e_connection_spdra(self):
990 response = test_utils.check_netconf_node_request("SPDR-SA1", "")
991 self.assertEqual(response.status_code, requests.codes.ok)
992 res = response.json()
993 self.assertNotIn(['odu-connection'][0], res['org-openroadm-device'])
996 def test_44_check_no_interface_ODU2E_NETWORK_spdra(self):
997 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1")
998 self.assertEqual(response.status_code, requests.codes.not_found)
1000 def test_45_check_no_interface_ODU2E_CLIENT_spdra(self):
1001 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1")
1002 self.assertEqual(response.status_code, requests.codes.not_found)
1004 def test_46_check_no_interface_10GE_CLIENT_spdra(self):
1005 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
1006 self.assertEqual(response.status_code, requests.codes.not_found)
1008 def test_47_check_otn_topo_links(self):
1009 url = "{}/config/ietf-network:networks/network/otn-topology"
1010 response = test_utils.get_request(url)
1011 self.assertEqual(response.status_code, requests.codes.ok)
1012 res = response.json()
1013 nb_links = len(res['network'][0]['ietf-network-topology:link'])
1014 self.assertEqual(nb_links, 4)
1015 for link in res['network'][0]['ietf-network-topology:link']:
1016 linkId = link['link-id']
1017 if (linkId == 'ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
1018 linkId == 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
1019 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
1020 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
1022 def test_48_check_otn_topo_tp(self):
1023 url = "{}/config/ietf-network:networks/network/otn-topology"
1024 response = test_utils.get_request(url)
1025 res = response.json()
1026 for node in res['network'][0]['node']:
1027 if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
1028 tpList = node['ietf-network-topology:termination-point']
1030 if (tp['tp-id'] == 'XPDR1-NETWORK1'):
1031 xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1032 self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
1033 self.assertEqual(len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
1035 def test_49_delete_ODU4_service(self):
1036 url = "{}/operations/org-openroadm-service:service-delete"
1038 "sdnc-request-header": {
1039 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1040 "rpc-action": "service-delete",
1041 "request-system-id": "appname",
1042 "notification-url": "http://localhost:8585/NotificationServer/notify"
1044 "service-delete-req-info": {
1045 "service-name": "service1-ODU4",
1046 "tail-retention": "no"
1050 response = test_utils.post_request(url, data)
1051 self.assertEqual(response.status_code, requests.codes.ok)
1052 res = response.json()
1053 self.assertIn('Renderer service delete in progress',
1054 res['output']['configuration-response-common']['response-message'])
1057 def test_50_check_service_list(self):
1058 url = "{}/operational/org-openroadm-service:service-list"
1059 response = test_utils.get_request(url)
1060 self.assertEqual(response.status_code, requests.codes.ok)
1061 res = response.json()
1062 self.assertEqual(len(res['service-list']['services']), 1)
1065 def test_51_check_no_interface_ODU4_spdra(self):
1066 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
1067 self.assertEqual(response.status_code, requests.codes.not_found)
1069 def test_52_check_otn_topo_links(self):
1070 self.test_22_check_otn_topo_otu4_links()
1072 def test_53_check_otn_topo_tp(self):
1073 url = "{}/config/ietf-network:networks/network/otn-topology"
1074 response = test_utils.get_request(url)
1075 res = response.json()
1076 for node in res['network'][0]['node']:
1077 if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
1078 tpList = node['ietf-network-topology:termination-point']
1080 if (tp['tp-id'] == 'XPDR1-NETWORK1'):
1081 xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1082 self.assertNotIn('ts-pool', dict.keys(xpdrTpPortConAt))
1083 self.assertNotIn('odtu-tpn-pool', dict.keys(xpdrTpPortConAt))
1085 def test_54_delete_OCH_OTU4_service(self):
1086 url = "{}/operations/org-openroadm-service:service-delete"
1088 "sdnc-request-header": {
1089 "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1090 "rpc-action": "service-delete",
1091 "request-system-id": "appname",
1092 "notification-url": "http://localhost:8585/NotificationServer/notify"
1094 "service-delete-req-info": {
1095 "service-name": "service1-OCH-OTU4",
1096 "tail-retention": "no"
1100 response = test_utils.post_request(url, data)
1101 self.assertEqual(response.status_code, requests.codes.ok)
1102 res = response.json()
1103 self.assertIn('Renderer service delete in progress',
1104 res['output']['configuration-response-common']['response-message'])
1107 def test_55_get_no_service(self):
1108 url = "{}/operational/org-openroadm-service:service-list"
1109 response = test_utils.get_request(url)
1110 self.assertEqual(response.status_code, requests.codes.not_found)
1111 res = response.json()
1113 {"error-type": "application", "error-tag": "data-missing",
1114 "error-message": "Request could not be completed because the relevant data model content does not exist"},
1115 res['errors']['error'])
1118 def test_56_check_no_interface_OTU4_spdra(self):
1119 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
1120 self.assertEqual(response.status_code, requests.codes.not_found)
1122 def test_57_check_no_interface_OCH_spdra(self):
1123 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
1124 self.assertEqual(response.status_code, requests.codes.not_found)
1126 def test_58_getLinks_OtnTopology(self):
1127 url = "{}/config/ietf-network:networks/network/otn-topology"
1128 response = test_utils.get_request(url)
1129 self.assertEqual(response.status_code, requests.codes.ok)
1130 res = response.json()
1131 self.assertNotIn('ietf-network-topology:link', res['network'][0])
1133 def test_59_check_openroadm_topo_spdra(self):
1134 response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR1")
1135 self.assertEqual(response.status_code, requests.codes.ok)
1136 res = response.json()
1137 tp = res['node'][0]['ietf-network-topology:termination-point'][0]
1138 self.assertEqual('XPDR1-NETWORK1', tp['tp-id'])
1139 self.assertNotIn('wavelength', dict.keys(
1140 tp[u'org-openroadm-network-topology:xpdr-network-attributes']))
1143 def test_60_check_openroadm_topo_ROADMA_SRG(self):
1144 response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
1145 self.assertEqual(response.status_code, requests.codes.ok)
1146 res = response.json()
1147 self.assertIn({u'index': 1},
1148 res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1149 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1150 for ele in liste_tp:
1151 if ele['tp-id'] == 'SRG1-PP1-TXRX':
1152 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1155 def test_61_check_openroadm_topo_ROADMA_DEG(self):
1156 response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2")
1157 self.assertEqual(response.status_code, requests.codes.ok)
1158 res = response.json()
1159 self.assertIn({u'index': 1},
1160 res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1161 liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1162 for ele in liste_tp:
1163 if ele['tp-id'] == 'DEG2-CTP-TXRX':
1164 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1165 if ele['tp-id'] == 'DEG2-TTP-TXRX':
1166 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1169 def test_62_disconnect_spdrA(self):
1170 response = test_utils.unmount_device("SPDR-SA1")
1171 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1173 def test_63_disconnect_spdrC(self):
1174 response = test_utils.unmount_device("SPDR-SC1")
1175 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1177 def test_64_disconnect_roadmA(self):
1178 response = test_utils.unmount_device("ROADM-A1")
1179 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1181 def test_65_disconnect_roadmC(self):
1182 response = test_utils.unmount_device("ROADM-C1")
1183 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1186 if __name__ == "__main__":
1187 unittest.main(verbosity=2)