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.check_device_connection("SPDR-SA1")
54 self.assertEqual(response['status_code'], requests.codes.ok)
55 self.assertEqual(response['connection-status'], 'connected')
57 def test_02_connect_SPDR_SC1(self):
58 response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
59 self.assertEqual(response.status_code, requests.codes.created,
60 test_utils.CODE_SHOULD_BE_201)
63 response = test_utils.check_device_connection("SPDR-SC1")
64 self.assertEqual(response['status_code'], requests.codes.ok)
65 self.assertEqual(response['connection-status'], 'connected')
67 def test_03_service_create_OTU4(self):
68 response = test_utils.transportpce_api_rpc_request(
69 'transportpce-renderer', 'service-implementation-request',
71 'service-name': 'SPDRA-SPDRC-OTU4-ODU4',
72 'connection-type': 'infrastructure',
73 'service-handler-header': {
74 'request-id': 'abcd12-efgh34'
77 'service-format': 'OTU',
78 'otu-service-rate': 'org-openroadm-otn-common-types:OTU4',
84 'service-format': 'OTU',
85 'otu-service-rate': 'org-openroadm-otn-common-types:OTU4',
92 'modulation-format': 'dp-qpsk',
93 'aToZ-wavelength-number': 1,
98 'tp-node-id': 'SPDR-SA1-XPDR1',
105 'tp-node-id': 'SPDR-SA1-XPDR1',
106 'tp-id': 'XPDR1-NETWORK1'
112 'tp-node-id': 'SPDR-SC1-XPDR1',
113 'tp-id': 'XPDR1-NETWORK1'
119 'tp-node-id': 'SPDR-SC1-XPDR1',
124 'aToZ-min-frequency': 196.075,
125 'aToZ-max-frequency': 196.125
128 'zToA-wavelength-number': '1',
130 'modulation-format': 'dp-qpsk',
135 'tp-node-id': 'SPDR-SC1-XPDR1',
142 'tp-node-id': 'SPDR-SC1-XPDR1',
143 'tp-id': 'XPDR1-NETWORK1'
149 'tp-node-id': 'SPDR-SA1-XPDR1',
150 'tp-id': 'XPDR1-NETWORK1'
156 'tp-node-id': 'SPDR-SA1-XPDR1',
161 'zToA-min-frequency': 196.075,
162 'zToA-max-frequency': 196.125
166 self.assertEqual(response['status_code'], requests.codes.ok)
167 self.assertIn('Operation Successful',
168 response['output']['configuration-response-common']['response-message'])
170 # Test OCH-OTU interfaces on SPDR-A1
171 def test_04_check_interface_och(self):
172 response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
173 self.assertEqual(response['status_code'], requests.codes.ok)
174 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
175 'administrative-state': 'inService',
176 'supporting-circuit-pack-name': 'CP1-CFP0',
177 'type': 'org-openroadm-interfaces:opticalChannel',
178 'supporting-port': 'CP1-CFP0-P1'
179 }, **response['interface'][0]),
180 response['interface'][0])
181 intf = response['interface'][0]['org-openroadm-optical-channel-interfaces:och']
182 self.assertEqual(intf['rate'], 'org-openroadm-common-types:R100G')
183 self.assertEqual(intf['modulation-format'], 'dp-qpsk')
184 self.assertEqual(float(intf['frequency']), 196.1)
185 self.assertEqual(float(intf['transmit-power']), -5)
187 def test_05_check_interface_OTU(self):
188 response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
189 self.assertEqual(response['status_code'], requests.codes.ok)
190 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
191 'administrative-state': 'inService',
192 'supporting-circuit-pack-name': 'CP1-CFP0',
193 'supporting-interface': 'XPDR1-NETWORK1-1',
194 'type': 'org-openroadm-interfaces:otnOtu',
195 'supporting-port': 'CP1-CFP0-P1'
197 input_dict_2 = {'tx-dapi': 'AMf1n5hK6Xkk',
198 'expected-sapi': 'AMf1n5hK6Xkk',
199 'tx-sapi': 'H/OelLynehI=',
200 'expected-dapi': 'H/OelLynehI=',
201 'rate': 'org-openroadm-otn-common-types:OTU4',
204 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
205 response['interface'][0])
206 self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
207 response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
209 # Test OCH-OTU interfaces on SPDR-C1
210 def test_06_check_interface_och(self):
211 response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-761:768")
212 self.assertEqual(response['status_code'], requests.codes.ok)
213 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
214 'administrative-state': 'inService',
215 'supporting-circuit-pack-name': 'CP1-CFP0',
216 'type': 'org-openroadm-interfaces:opticalChannel',
217 'supporting-port': 'CP1-CFP0-P1'
218 }, **response['interface'][0]),
219 response['interface'][0])
220 intf = response['interface'][0]['org-openroadm-optical-channel-interfaces:och']
221 self.assertEqual(intf['rate'], 'org-openroadm-common-types:R100G')
222 self.assertEqual(intf['modulation-format'], 'dp-qpsk')
223 self.assertEqual(float(intf['frequency']), 196.1)
224 self.assertEqual(float(intf['transmit-power']), -5)
226 def test_07_check_interface_OTU(self):
227 response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-OTU")
228 self.assertEqual(response['status_code'], requests.codes.ok)
229 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
230 'administrative-state': 'inService',
231 'supporting-circuit-pack-name': 'CP1-CFP0',
232 'supporting-interface': 'XPDR1-NETWORK1-1',
233 'type': 'org-openroadm-interfaces:otnOtu',
234 'supporting-port': 'CP1-CFP0-P1'
236 input_dict_2 = {'tx-dapi': 'H/OelLynehI=',
237 'expected-sapi': 'H/OelLynehI=',
238 'tx-sapi': 'AMf1n5hK6Xkk',
239 'expected-dapi': 'AMf1n5hK6Xkk',
240 'rate': 'org-openroadm-otn-common-types:OTU4',
243 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
244 response['interface'][0])
245 self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
246 response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
248 # Test creation of ODU4 service
249 def test_08_service_create_ODU4(self):
250 response = test_utils.transportpce_api_rpc_request(
251 'transportpce-renderer', 'service-implementation-request',
254 'SPDRA-SPDRC-OTU4-ODU4',
255 'connection-type': 'infrastructure',
256 'service-handler-header': {
257 'request-id': 'abcd12-efgh34'
260 'service-format': 'ODU',
262 'org-openroadm-otn-common-types:ODU4',
264 'node-id': 'SPDR-SA1'
268 'service-format': 'ODU',
270 'org-openroadm-otn-common-types:ODU4',
272 'node-id': 'SPDR-SC1'
274 'path-description': {
281 'tp-node-id': 'SPDR-SA1-XPDR1',
288 'tp-node-id': 'SPDR-SA1-XPDR1',
289 'tp-id': 'XPDR1-NETWORK1'
295 'tp-node-id': 'SPDR-SC1-XPDR1',
296 'tp-id': 'XPDR1-NETWORK1'
302 'tp-node-id': 'SPDR-SC1-XPDR1',
314 'tp-node-id': 'SPDR-SC1-XPDR1',
321 'tp-node-id': 'SPDR-SC1-XPDR1',
322 'tp-id': 'XPDR1-NETWORK1'
328 'tp-node-id': 'SPDR-SA1-XPDR1',
329 'tp-id': 'XPDR1-NETWORK1'
335 'tp-node-id': 'SPDR-SA1-XPDR1',
343 self.assertEqual(response['status_code'], requests.codes.ok)
344 self.assertIn('Operation Successful',
345 response['output']['configuration-response-common']['response-message'])
347 # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
348 def test_09_check_interface_ODU4(self):
349 response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
350 self.assertEqual(response['status_code'], requests.codes.ok)
351 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
352 'administrative-state': 'inService',
353 'supporting-circuit-pack-name': 'CP1-CFP0',
354 'supporting-interface': 'XPDR1-NETWORK1-OTU',
355 'type': 'org-openroadm-interfaces:otnOdu',
356 'supporting-port': 'CP1-CFP0-P1'}
357 # SAPI/DAPI are added in the Otu4 renderer
358 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
359 'rate': 'org-openroadm-otn-common-types:ODU4',
360 'expected-dapi': 'H/OelLynehI=',
361 'expected-sapi': 'AMf1n5hK6Xkk',
362 'tx-dapi': 'AMf1n5hK6Xkk',
363 'tx-sapi': 'H/OelLynehI='}
365 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
366 response['interface'][0])
367 self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
369 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
371 self.assertDictEqual(
372 {'payload-type': '21', 'exp-payload-type': '21'},
373 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
375 def test_10_check_interface_ODU4(self):
376 response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU4")
377 self.assertEqual(response['status_code'], requests.codes.ok)
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 'tx-sapi': 'AMf1n5hK6Xkk',
388 'tx-dapi': 'H/OelLynehI=',
389 'expected-sapi': 'H/OelLynehI=',
390 'expected-dapi': 'AMf1n5hK6Xkk'
392 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
393 response['interface'][0])
394 self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
396 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
398 self.assertDictEqual(
399 {'payload-type': '21', 'exp-payload-type': '21'},
400 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
402 # Test creation of 10G service
403 def test_11_service_create_10GE(self):
404 response = test_utils.transportpce_api_rpc_request(
405 'transportpce-renderer', 'service-implementation-request',
407 'service-name': 'SPDRA-SPDRC-10G',
408 'connection-type': 'service',
409 'service-handler-header': {
410 'request-id': 'abcd12-efgh34'
413 'service-format': 'Ethernet',
414 'service-rate': '10',
416 'node-id': 'SPDR-SA1'
419 'service-format': 'Ethernet',
420 'service-rate': '10',
422 'node-id': 'SPDR-SC1'
424 'path-description': {
427 'min-trib-slot': '1.1',
428 'max-trib-slot': '1.8',
433 'tp-node-id': 'SPDR-SA1-XPDR1',
434 'tp-id': 'XPDR1-CLIENT1'
441 'tp-node-id': 'SPDR-SA1-XPDR1',
442 'tp-id': 'XPDR1-NETWORK1'
448 'tp-node-id': 'SPDR-SC1-XPDR1',
449 'tp-id': 'XPDR1-NETWORK1'
455 'tp-node-id': 'SPDR-SC1-XPDR1',
456 'tp-id': 'XPDR1-CLIENT1'
463 'min-trib-slot': '1.1',
464 'max-trib-slot': '1.8',
469 'tp-node-id': 'SPDR-SC1-XPDR1',
470 'tp-id': 'XPDR1-CLIENT1'
476 'tp-node-id': 'SPDR-SC1-XPDR1',
477 'tp-id': 'XPDR1-NETWORK1'
483 'tp-node-id': 'SPDR-SA1-XPDR1',
484 'tp-id': 'XPDR1-NETWORK1'
490 'tp-node-id': 'SPDR-SA1-XPDR1',
491 'tp-id': 'XPDR1-CLIENT1'
499 self.assertEqual(response['status_code'], requests.codes.ok)
500 self.assertIn('Operation Successful',
501 response['output']['configuration-response-common']['response-message'])
503 # Test the interfaces on SPDR-A1
504 def test_12_check_interface_10GE_CLIENT(self):
505 response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
506 self.assertEqual(response['status_code'], requests.codes.ok)
507 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
508 'administrative-state': 'inService',
509 'supporting-circuit-pack-name': 'CP1-SFP4',
510 'type': 'org-openroadm-interfaces:ethernetCsmacd',
511 'supporting-port': 'CP1-SFP4-P1'
513 self.assertDictEqual(dict(input_dict, **response['interface'][0]),
514 response['interface'][0])
515 self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
517 def test_13_check_interface_ODU2E_CLIENT(self):
518 response = test_utils.check_node_attribute_request(
519 "SPDR-SA1", "interface", "XPDR1-CLIENT1-ODU2e")
520 self.assertEqual(response['status_code'], requests.codes.ok)
521 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e',
522 'administrative-state': 'inService',
523 'supporting-circuit-pack-name': 'CP1-SFP4',
524 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
525 'type': 'org-openroadm-interfaces:otnOdu',
526 'supporting-port': 'CP1-SFP4-P1'}
528 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
529 'rate': 'org-openroadm-otn-common-types:ODU2e',
530 'monitoring-mode': 'terminated'}
532 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
533 response['interface'][0])
534 self.assertDictEqual(dict(input_dict_2,
535 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
536 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
537 self.assertDictEqual(
538 {'payload-type': '03', 'exp-payload-type': '03'},
539 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
541 def test_14_check_ODU2E_connection(self):
542 response = test_utils.check_node_attribute_request(
544 "odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
545 self.assertEqual(response['status_code'], requests.codes.ok)
548 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
549 'direction': 'bidirectional'
551 self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
552 response['odu-connection'][0])
553 self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'},
554 response['odu-connection'][0]['destination'])
555 self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'},
556 response['odu-connection'][0]['source'])
558 def test_15_check_interface_ODU2E_NETWORK(self):
559 response = test_utils.check_node_attribute_request(
560 "SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU2e")
561 self.assertEqual(response['status_code'], requests.codes.ok)
562 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
563 'administrative-state': 'inService',
564 'supporting-circuit-pack-name': 'CP1-CFP0',
565 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
566 'type': 'org-openroadm-interfaces:otnOdu',
567 'supporting-port': 'CP1-CFP0-P1'}
569 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
570 'rate': 'org-openroadm-otn-common-types:ODU2e',
571 'monitoring-mode': 'monitored'}
572 input_dict_3 = {'trib-port-number': 1}
573 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
574 response['interface'][0])
575 self.assertDictEqual(dict(input_dict_2,
576 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
577 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
578 self.assertDictEqual(dict(input_dict_3,
579 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
580 'parent-odu-allocation']),
581 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
582 'parent-odu-allocation'])
584 response['interface'][0][
585 'org-openroadm-otn-odu-interfaces:odu'][
586 'parent-odu-allocation']['trib-slots'])
588 # Test the interfaces on SPDR-C1
589 def test_16_check_interface_ODU2E_NETWORK(self):
590 response = test_utils.check_node_attribute_request(
591 "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e")
592 self.assertEqual(response['status_code'], requests.codes.ok)
593 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
594 'administrative-state': 'inService',
595 'supporting-circuit-pack-name': 'CP1-CFP0',
596 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
597 'type': 'org-openroadm-interfaces:otnOdu',
598 'supporting-port': 'CP1-CFP0-P1'}
600 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
601 'rate': 'org-openroadm-otn-common-types:ODU2e',
602 'monitoring-mode': 'monitored'}
603 input_dict_3 = {'trib-port-number': 1}
604 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
605 response['interface'][0])
606 self.assertDictEqual(dict(input_dict_2,
607 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
608 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
609 self.assertDictEqual(dict(input_dict_3,
610 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
611 'parent-odu-allocation']),
612 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
613 'parent-odu-allocation'])
615 response['interface'][0][
616 'org-openroadm-otn-odu-interfaces:odu'][
617 'parent-odu-allocation']['trib-slots'])
619 def test_17_check_interface_10GE_CLIENT(self):
620 response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
621 self.assertEqual(response['status_code'], requests.codes.ok)
622 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
623 'administrative-state': 'inService',
624 'supporting-circuit-pack-name': 'CP1-SFP4',
625 'type': 'org-openroadm-interfaces:ethernetCsmacd',
626 'supporting-port': 'CP1-SFP4-P1'
628 self.assertDictEqual(dict(input_dict, **response['interface'][0]),
629 response['interface'][0])
630 self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
632 def test_18_check_interface_ODU2E_CLIENT(self):
633 response = test_utils.check_node_attribute_request(
634 "SPDR-SC1", "interface", "XPDR1-CLIENT1-ODU2e")
635 self.assertEqual(response['status_code'], requests.codes.ok)
636 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e',
637 'administrative-state': 'inService',
638 'supporting-circuit-pack-name': 'CP1-SFP4',
639 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
640 'type': 'org-openroadm-interfaces:otnOdu',
641 'supporting-port': 'CP1-SFP4-P1'}
643 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
644 'rate': 'org-openroadm-otn-common-types:ODU2e',
645 'monitoring-mode': 'terminated'}
646 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
647 response['interface'][0])
648 self.assertDictEqual(dict(input_dict_2,
649 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
650 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
651 self.assertDictEqual(
652 {'payload-type': '03', 'exp-payload-type': '03'},
653 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
655 def test_19_check_ODU2E_connection(self):
656 response = test_utils.check_node_attribute_request(
658 "odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
659 self.assertEqual(response['status_code'], requests.codes.ok)
662 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
663 'direction': 'bidirectional'
665 self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
666 response['odu-connection'][0])
667 self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'},
668 response['odu-connection'][0]['destination'])
669 self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'},
670 response['odu-connection'][0]['source'])
672 def test_20_check_interface_ODU2E_NETWORK(self):
673 response = test_utils.check_node_attribute_request(
674 "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e")
675 self.assertEqual(response['status_code'], requests.codes.ok)
676 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
677 'administrative-state': 'inService',
678 'supporting-circuit-pack-name': 'CP1-CFP0',
679 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
680 'type': 'org-openroadm-interfaces:otnOdu',
681 'supporting-port': 'CP1-CFP0-P1'}
683 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
684 'rate': 'org-openroadm-otn-common-types:ODU2e',
685 'monitoring-mode': 'monitored'}
687 input_dict_3 = {'trib-port-number': 1}
689 self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
690 response['interface'][0])
691 self.assertDictEqual(dict(input_dict_2,
692 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
693 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
694 self.assertDictEqual(dict(input_dict_3,
695 **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
696 'parent-odu-allocation']),
697 response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
698 'parent-odu-allocation'])
700 response['interface'][0][
701 'org-openroadm-otn-odu-interfaces:odu'][
702 'parent-odu-allocation']['trib-slots'])
704 # TODO: Delete the services (OTU, ODU, LO-ODU)
705 # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
707 def test_21_disconnect_SPDR_SA1(self):
708 response = test_utils.unmount_device("SPDR-SA1")
709 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
711 def test_22_disconnect_SPDR_SC1(self):
712 response = test_utils.unmount_device("SPDR-SC1")
713 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
716 if __name__ == "__main__":
717 unittest.main(verbosity=2)