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 ##############################################################################
12 # pylint: disable=no-member
13 # pylint: disable=too-many-public-methods
18 # pylint: disable=wrong-import-order
20 sys.path.append('transportpce_tests/common/')
21 # pylint: disable=wrong-import-position
22 # pylint: disable=import-error
23 import test_utils # nopep8
26 class TransportPCEtesting(unittest.TestCase):
29 NODE_VERSION = '2.2.1'
33 cls.processes = test_utils.start_tpce()
34 cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION),
35 ('spdrc', cls.NODE_VERSION)])
38 def tearDownClass(cls):
39 # pylint: disable=not-an-iterable
40 for process in cls.processes:
41 test_utils.shutdown_process(process)
42 print("all processes killed")
47 def test_01_connect_SPDR_SA1(self):
48 response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
49 self.assertEqual(response.status_code, requests.codes.created,
50 test_utils.CODE_SHOULD_BE_201)
53 response = test_utils.get_netconf_oper_request("SPDR-SA1")
54 self.assertEqual(response.status_code, requests.codes.ok)
57 res['node'][0]['netconf-node-topology:connection-status'],
60 def test_02_connect_SPDR_SC1(self):
61 response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
62 self.assertEqual(response.status_code, requests.codes.created,
63 test_utils.CODE_SHOULD_BE_201)
66 response = test_utils.get_netconf_oper_request("SPDR-SC1")
67 self.assertEqual(response.status_code, requests.codes.ok)
70 res['node'][0]['netconf-node-topology:connection-status'],
73 def test_03_service_create_OTU4(self):
74 url = "{}/operations/transportpce-renderer:service-implementation-request"
76 "transportpce-renderer:input": {
77 "transportpce-renderer:service-name": "SPDRA-SPDRC-OTU4-ODU4",
78 "transportpce-renderer:connection-type": "infrastructure",
79 "transportpce-renderer:service-handler-header": {
80 "transportpce-renderer:request-id": "abcd12-efgh34"
82 "transportpce-renderer:service-a-end": {
83 "transportpce-renderer:service-format": "OTU",
84 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
85 "transportpce-renderer:clli": "nodeSA",
86 "transportpce-renderer:node-id": "SPDR-SA1"
89 "transportpce-renderer:service-z-end": {
90 "transportpce-renderer:service-format": "OTU",
91 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
92 "transportpce-renderer:clli": "nodeSC",
93 "transportpce-renderer:node-id": "SPDR-SC1"
95 "transportpce-renderer:path-description": {
98 "transportpce-renderer:modulation-format": "dp-qpsk",
99 "aToZ-wavelength-number": 1,
104 "tp-node-id": "SPDR-SA1-XPDR1",
111 "tp-node-id": "SPDR-SA1-XPDR1",
112 "tp-id": "XPDR1-NETWORK1"
118 "tp-node-id": "SPDR-SC1-XPDR1",
119 "tp-id": "XPDR1-NETWORK1"
125 "tp-node-id": "SPDR-SC1-XPDR1",
130 "transportpce-renderer:aToZ-min-frequency": 196.075,
131 "transportpce-renderer:aToZ-max-frequency": 196.125
133 "transportpce-renderer:zToA-direction": {
134 "transportpce-renderer:zToA-wavelength-number": "1",
135 "transportpce-renderer:rate": "100",
136 "transportpce-renderer:modulation-format": "dp-qpsk",
141 "tp-node-id": "SPDR-SC1-XPDR1",
148 "tp-node-id": "SPDR-SC1-XPDR1",
149 "tp-id": "XPDR1-NETWORK1"
155 "tp-node-id": "SPDR-SA1-XPDR1",
156 "tp-id": "XPDR1-NETWORK1"
162 "tp-node-id": "SPDR-SA1-XPDR1",
167 "transportpce-renderer:zToA-min-frequency": 196.075,
168 "transportpce-renderer:zToA-max-frequency": 196.125
173 response = test_utils.post_request(url, data)
175 print(response.json())
176 self.assertEqual(response.status_code, requests.codes.ok)
177 res = response.json()
178 self.assertIn('Operation Successful',
179 res["output"]["configuration-response-common"]["response-message"])
181 # Test OCH-OTU interfaces on SPDR-A1
182 def test_04_check_interface_och(self):
183 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-761:768")
184 self.assertEqual(response.status_code, requests.codes.ok)
185 res = response.json()
186 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
187 'administrative-state': 'inService',
188 'supporting-circuit-pack-name': 'CP1-CFP0',
189 'type': 'org-openroadm-interfaces:opticalChannel',
190 'supporting-port': 'CP1-CFP0-P1'
191 }, **res['interface'][0]),
194 self.assertDictEqual(
195 {'frequency': 196.1, 'rate': 'org-openroadm-common-types:R100G',
196 'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
197 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
199 def test_05_check_interface_OTU(self):
200 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
201 self.assertEqual(response.status_code, requests.codes.ok)
202 res = response.json()
203 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
204 'administrative-state': 'inService',
205 'supporting-circuit-pack-name': 'CP1-CFP0',
206 'supporting-interface': 'XPDR1-NETWORK1-1',
207 'type': 'org-openroadm-interfaces:otnOtu',
208 'supporting-port': 'CP1-CFP0-P1'
210 input_dict_2 = {'tx-dapi': 'AMf1n5hK6Xkk',
211 'expected-sapi': 'AMf1n5hK6Xkk',
212 'tx-sapi': 'H/OelLynehI=',
213 'expected-dapi': 'H/OelLynehI=',
214 'rate': 'org-openroadm-otn-common-types:OTU4',
217 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
220 self.assertDictEqual(input_dict_2,
222 ['org-openroadm-otn-otu-interfaces:otu'])
224 # Test OCH-OTU interfaces on SPDR-C1
225 def test_06_check_interface_och(self):
226 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-761:768")
227 self.assertEqual(response.status_code, requests.codes.ok)
228 res = response.json()
229 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
230 'administrative-state': 'inService',
231 'supporting-circuit-pack-name': 'CP1-CFP0',
232 'type': 'org-openroadm-interfaces:opticalChannel',
233 'supporting-port': 'CP1-CFP0-P1'
234 }, **res['interface'][0]),
237 self.assertDictEqual(
238 {'frequency': 196.1, 'rate': 'org-openroadm-common-types:R100G',
239 'transmit-power': -5, 'modulation-format': 'dp-qpsk'},
240 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
242 def test_07_check_interface_OTU(self):
243 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
244 self.assertEqual(response.status_code, requests.codes.ok)
245 res = response.json()
246 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
247 'administrative-state': 'inService',
248 'supporting-circuit-pack-name': 'CP1-CFP0',
249 'supporting-interface': 'XPDR1-NETWORK1-1',
250 'type': 'org-openroadm-interfaces:otnOtu',
251 'supporting-port': 'CP1-CFP0-P1'
253 input_dict_2 = {'tx-dapi': 'H/OelLynehI=',
254 'expected-sapi': 'H/OelLynehI=',
255 'tx-sapi': 'AMf1n5hK6Xkk',
256 'expected-dapi': 'AMf1n5hK6Xkk',
257 'rate': 'org-openroadm-otn-common-types:OTU4',
261 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
264 self.assertDictEqual(input_dict_2,
266 ['org-openroadm-otn-otu-interfaces:otu'])
268 # Test creation of ODU4 service
269 def test_08_service_create_ODU4(self):
270 url = "{}/operations/transportpce-renderer:service-implementation-request"
273 "transportpce-renderer:input": {
274 "transportpce-renderer:service-name":
275 "SPDRA-SPDRC-OTU4-ODU4",
276 "transportpce-renderer:connection-type": "infrastructure",
277 "transportpce-renderer:service-handler-header": {
278 "transportpce-renderer:request-id": "abcd12-efgh34"
280 "transportpce-renderer:service-a-end": {
281 "transportpce-renderer:service-format": "ODU",
282 "transportpce-renderer:odu-service-rate":
283 "org-openroadm-otn-common-types:ODU4",
284 "transportpce-renderer:clli": "nodeSA",
285 "transportpce-renderer:node-id": "SPDR-SA1"
288 "transportpce-renderer:service-z-end": {
289 "transportpce-renderer:service-format": "ODU",
290 "transportpce-renderer:odu-service-rate":
291 "org-openroadm-otn-common-types:ODU4",
292 "transportpce-renderer:clli": "nodeSC",
293 "transportpce-renderer:node-id": "SPDR-SC1"
295 "transportpce-renderer:path-description": {
302 "tp-node-id": "SPDR-SA1-XPDR1",
309 "tp-node-id": "SPDR-SA1-XPDR1",
310 "tp-id": "XPDR1-NETWORK1"
316 "tp-node-id": "SPDR-SC1-XPDR1",
317 "tp-id": "XPDR1-NETWORK1"
323 "tp-node-id": "SPDR-SC1-XPDR1",
329 "transportpce-renderer:zToA-direction": {
330 "transportpce-renderer:rate": "100",
335 "tp-node-id": "SPDR-SC1-XPDR1",
342 "tp-node-id": "SPDR-SC1-XPDR1",
343 "tp-id": "XPDR1-NETWORK1"
349 "tp-node-id": "SPDR-SA1-XPDR1",
350 "tp-id": "XPDR1-NETWORK1"
356 "tp-node-id": "SPDR-SA1-XPDR1",
365 response = test_utils.post_request(url, data)
367 self.assertEqual(response.status_code, requests.codes.ok)
368 res = response.json()
369 self.assertIn('Operation Successful',
370 res["output"]["configuration-response-common"]
371 ["response-message"])
373 # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
374 def test_09_check_interface_ODU4(self):
375 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
376 self.assertEqual(response.status_code, requests.codes.ok)
377 res = response.json()
378 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
379 'administrative-state': 'inService',
380 'supporting-circuit-pack-name': 'CP1-CFP0',
381 'supporting-interface': 'XPDR1-NETWORK1-OTU',
382 'type': 'org-openroadm-interfaces:otnOdu',
383 'supporting-port': 'CP1-CFP0-P1'}
384 # SAPI/DAPI are added in the Otu4 renderer
385 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
386 'rate': 'org-openroadm-otn-common-types:ODU4',
387 'expected-dapi': 'H/OelLynehI=',
388 'expected-sapi': 'AMf1n5hK6Xkk',
389 'tx-dapi': 'AMf1n5hK6Xkk',
390 'tx-sapi': 'H/OelLynehI='}
392 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
394 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
396 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
398 self.assertDictEqual(
399 {'payload-type': '21', 'exp-payload-type': '21'},
400 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
402 def test_10_check_interface_ODU4(self):
403 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
404 self.assertEqual(response.status_code, requests.codes.ok)
405 res = response.json()
406 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
407 'administrative-state': 'inService',
408 'supporting-circuit-pack-name': 'CP1-CFP0',
409 'supporting-interface': 'XPDR1-NETWORK1-OTU',
410 'type': 'org-openroadm-interfaces:otnOdu',
411 'supporting-port': 'CP1-CFP0-P1'}
412 # SAPI/DAPI are added in the Otu4 renderer
413 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
414 'rate': 'org-openroadm-otn-common-types:ODU4',
415 'tx-sapi': 'AMf1n5hK6Xkk',
416 'tx-dapi': 'H/OelLynehI=',
417 'expected-sapi': 'H/OelLynehI=',
418 'expected-dapi': 'AMf1n5hK6Xkk'
420 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
422 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
424 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
426 self.assertDictEqual(
427 {'payload-type': '21', 'exp-payload-type': '21'},
428 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
430 # Test creation of 10G service
431 def test_11_service_create_10GE(self):
432 url = "{}/operations/transportpce-renderer:service-implementation-request"
435 "transportpce-renderer:input": {
436 "transportpce-renderer:service-name": "SPDRA-SPDRC-10G",
437 "transportpce-renderer:connection-type": "service",
438 "transportpce-renderer:service-handler-header": {
439 "transportpce-renderer:request-id": "abcd12-efgh34"
441 "transportpce-renderer:service-a-end": {
442 "transportpce-renderer:service-format": "Ethernet",
443 "transportpce-renderer:service-rate": "10",
444 "transportpce-renderer:clli": "nodeSA",
445 "transportpce-renderer:node-id": "SPDR-SA1"
447 "transportpce-renderer:service-z-end": {
448 "transportpce-renderer:service-format": "Ethernet",
449 "transportpce-renderer:service-rate": "10",
450 "transportpce-renderer:clli": "nodeSC",
451 "transportpce-renderer:node-id": "SPDR-SC1"
453 "transportpce-renderer:path-description": {
456 "min-trib-slot": "1.1",
457 "max-trib-slot": "1.8",
462 "tp-node-id": "SPDR-SA1-XPDR1",
463 "tp-id": "XPDR1-CLIENT1"
470 "tp-node-id": "SPDR-SA1-XPDR1",
471 "tp-id": "XPDR1-NETWORK1"
477 "tp-node-id": "SPDR-SC1-XPDR1",
478 "tp-id": "XPDR1-NETWORK1"
484 "tp-node-id": "SPDR-SC1-XPDR1",
485 "tp-id": "XPDR1-CLIENT1"
490 "transportpce-renderer:zToA-direction": {
492 "min-trib-slot": "1.1",
493 "max-trib-slot": "1.8",
498 "tp-node-id": "SPDR-SC1-XPDR1",
499 "tp-id": "XPDR1-CLIENT1"
505 "tp-node-id": "SPDR-SC1-XPDR1",
506 "tp-id": "XPDR1-NETWORK1"
512 "tp-node-id": "SPDR-SA1-XPDR1",
513 "tp-id": "XPDR1-NETWORK1"
519 "tp-node-id": "SPDR-SA1-XPDR1",
520 "tp-id": "XPDR1-CLIENT1"
530 response = test_utils.post_request(url, data)
532 self.assertEqual(response.status_code, requests.codes.ok)
533 res = response.json()
534 self.assertIn('Operation Successful',
535 res["output"]["configuration-response-common"]
536 ["response-message"])
538 # Test the interfaces on SPDR-A1
539 def test_12_check_interface_10GE_CLIENT(self):
540 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
541 self.assertEqual(response.status_code, requests.codes.ok)
542 res = response.json()
543 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
544 'administrative-state': 'inService',
545 'supporting-circuit-pack-name': 'CP1-SFP4',
546 'type': 'org-openroadm-interfaces:ethernetCsmacd',
547 'supporting-port': 'CP1-SFP4-P1'
549 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
551 self.assertDictEqual(
553 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
555 def test_13_check_interface_ODU2E_CLIENT(self):
556 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
557 self.assertEqual(response.status_code, requests.codes.ok)
558 res = response.json()
559 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
560 'administrative-state': 'inService',
561 'supporting-circuit-pack-name': 'CP1-SFP4',
562 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
563 'type': 'org-openroadm-interfaces:otnOdu',
564 'supporting-port': 'CP1-SFP4-P1'}
566 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
567 'rate': 'org-openroadm-otn-common-types:ODU2e',
568 'monitoring-mode': 'terminated'}
570 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
572 self.assertDictEqual(dict(input_dict_2,
573 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
574 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
575 self.assertDictEqual(
576 {'payload-type': '03', 'exp-payload-type': '03'},
577 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
579 def test_14_check_ODU2E_connection(self):
580 response = test_utils.check_netconf_node_request(
582 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
583 self.assertEqual(response.status_code, requests.codes.ok)
584 res = response.json()
587 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
588 'direction': 'bidirectional'
591 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
592 res['odu-connection'][0])
593 self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
594 res['odu-connection'][0]['destination'])
595 self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
596 res['odu-connection'][0]['source'])
598 def test_15_check_interface_ODU2E_NETWORK(self):
599 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
600 self.assertEqual(response.status_code, requests.codes.ok)
601 res = response.json()
602 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
603 'administrative-state': 'inService',
604 'supporting-circuit-pack-name': 'CP1-CFP0',
605 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
606 'type': 'org-openroadm-interfaces:otnOdu',
607 'supporting-port': 'CP1-CFP0-P1'}
609 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
610 'rate': 'org-openroadm-otn-common-types:ODU2e',
611 'monitoring-mode': 'monitored'}
613 input_dict_3 = {'trib-port-number': 1}
615 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
617 self.assertDictEqual(dict(input_dict_2,
618 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
619 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
620 self.assertDictEqual(dict(input_dict_3,
621 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
622 'parent-odu-allocation']),
623 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
624 'parent-odu-allocation'])
627 'org-openroadm-otn-odu-interfaces:odu'][
628 'parent-odu-allocation']['trib-slots'])
630 # Test the interfaces on SPDR-C1
631 def test_16_check_interface_ODU2E_NETWORK(self):
632 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
633 self.assertEqual(response.status_code, requests.codes.ok)
634 res = response.json()
635 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
636 'administrative-state': 'inService',
637 'supporting-circuit-pack-name': 'CP1-CFP0',
638 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
639 'type': 'org-openroadm-interfaces:otnOdu',
640 'supporting-port': 'CP1-CFP0-P1'}
642 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
643 'rate': 'org-openroadm-otn-common-types:ODU2e',
644 'monitoring-mode': 'monitored'}
646 input_dict_3 = {'trib-port-number': 1}
648 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
650 self.assertDictEqual(dict(input_dict_2,
651 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
652 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
653 self.assertDictEqual(dict(input_dict_3,
654 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
655 'parent-odu-allocation']),
656 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
657 'parent-odu-allocation'])
660 'org-openroadm-otn-odu-interfaces:odu'][
661 'parent-odu-allocation']['trib-slots'])
663 def test_17_check_interface_10GE_CLIENT(self):
664 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
665 self.assertEqual(response.status_code, requests.codes.ok)
666 res = response.json()
667 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
668 'administrative-state': 'inService',
669 'supporting-circuit-pack-name': 'CP1-SFP4',
670 'type': 'org-openroadm-interfaces:ethernetCsmacd',
671 'supporting-port': 'CP1-SFP4-P1'
673 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
675 self.assertDictEqual(
677 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
679 def test_18_check_interface_ODU2E_CLIENT(self):
680 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
681 self.assertEqual(response.status_code, requests.codes.ok)
682 res = response.json()
683 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
684 'administrative-state': 'inService',
685 'supporting-circuit-pack-name': 'CP1-SFP4',
686 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
687 'type': 'org-openroadm-interfaces:otnOdu',
688 'supporting-port': 'CP1-SFP4-P1'}
690 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
691 'rate': 'org-openroadm-otn-common-types:ODU2e',
692 'monitoring-mode': 'terminated'}
694 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
696 self.assertDictEqual(dict(input_dict_2,
697 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
698 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
699 self.assertDictEqual(
700 {'payload-type': '03', 'exp-payload-type': '03'},
701 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
703 def test_19_check_ODU2E_connection(self):
704 response = test_utils.check_netconf_node_request(
706 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
707 self.assertEqual(response.status_code, requests.codes.ok)
708 res = response.json()
711 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
712 'direction': 'bidirectional'
715 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
716 res['odu-connection'][0])
717 self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
718 res['odu-connection'][0]['destination'])
719 self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
720 res['odu-connection'][0]['source'])
722 def test_20_check_interface_ODU2E_NETWORK(self):
723 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
724 self.assertEqual(response.status_code, requests.codes.ok)
725 res = response.json()
726 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
727 'administrative-state': 'inService',
728 'supporting-circuit-pack-name': 'CP1-CFP0',
729 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
730 'type': 'org-openroadm-interfaces:otnOdu',
731 'supporting-port': 'CP1-CFP0-P1'}
733 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
734 'rate': 'org-openroadm-otn-common-types:ODU2e',
735 'monitoring-mode': 'monitored'}
737 input_dict_3 = {'trib-port-number': 1}
739 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
741 self.assertDictEqual(dict(input_dict_2,
742 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
743 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
744 self.assertDictEqual(dict(input_dict_3,
745 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
746 'parent-odu-allocation']),
747 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
748 'parent-odu-allocation'])
751 'org-openroadm-otn-odu-interfaces:odu'][
752 'parent-odu-allocation']['trib-slots'])
754 # TODO: Delete the services (OTU, ODU, LO-ODU)
755 # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
757 def test_21_disconnect_SPDR_SA1(self):
758 response = test_utils.unmount_device("SPDR-SA1")
759 self.assertEqual(response.status_code, requests.codes.ok,
760 test_utils.CODE_SHOULD_BE_200)
762 def test_22_disconnect_SPDR_SC1(self):
763 response = test_utils.unmount_device("SPDR-SC1")
764 self.assertEqual(response.status_code, requests.codes.ok,
765 test_utils.CODE_SHOULD_BE_200)
768 if __name__ == "__main__":
769 unittest.main(verbosity=2)