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 from common import test_utils
21 class TransportPCEtesting(unittest.TestCase):
27 cls.processes = test_utils.start_tpce()
28 cls.processes = test_utils.start_sims(['spdra', 'spdrc'])
31 def tearDownClass(cls):
32 # pylint: disable=not-an-iterable
33 for process in cls.processes:
34 test_utils.shutdown_process(process)
35 print("all processes killed")
40 def test_01_connect_SPDR_SA1(self):
41 response = test_utils.mount_device("SPDR-SA1", 'spdra')
42 self.assertEqual(response.status_code, requests.codes.created,
43 test_utils.CODE_SHOULD_BE_201)
46 response = test_utils.get_netconf_oper_request("SPDR-SA1")
47 self.assertEqual(response.status_code, requests.codes.ok)
50 res['node'][0]['netconf-node-topology:connection-status'],
53 def test_02_connect_SPDR_SC1(self):
54 response = test_utils.mount_device("SPDR-SC1", 'spdrc')
55 self.assertEqual(response.status_code, requests.codes.created,
56 test_utils.CODE_SHOULD_BE_201)
59 response = test_utils.get_netconf_oper_request("SPDR-SC1")
60 self.assertEqual(response.status_code, requests.codes.ok)
63 res['node'][0]['netconf-node-topology:connection-status'],
66 def test_03_service_create_OTU4(self):
67 url = "{}/operations/transportpce-renderer:service-implementation-request"
69 "transportpce-renderer:input": {
70 "transportpce-renderer:service-name": "SPDRA-SPDRC-OTU4-ODU4",
71 "transportpce-renderer:connection-type": "infrastructure",
72 "transportpce-renderer:service-handler-header": {
73 "transportpce-renderer:request-id": "abcd12-efgh34"
75 "transportpce-renderer:service-a-end": {
76 "transportpce-renderer:service-format": "OTU",
77 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
78 "transportpce-renderer:clli": "nodeSA",
79 "transportpce-renderer:node-id": "SPDR-SA1"
82 "transportpce-renderer:service-z-end": {
83 "transportpce-renderer:service-format": "OTU",
84 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
85 "transportpce-renderer:clli": "nodeSC",
86 "transportpce-renderer:node-id": "SPDR-SC1"
88 "transportpce-renderer:path-description": {
91 "transportpce-renderer:modulation-format": "dp-qpsk",
92 "aToZ-wavelength-number": 1,
97 "tp-node-id": "SPDR-SA1-XPDR1",
104 "tp-node-id": "SPDR-SA1-XPDR1",
105 "tp-id": "XPDR1-NETWORK1"
111 "tp-node-id": "SPDR-SC1-XPDR1",
112 "tp-id": "XPDR1-NETWORK1"
118 "tp-node-id": "SPDR-SC1-XPDR1",
124 "transportpce-renderer:zToA-direction": {
125 "transportpce-renderer:zToA-wavelength-number": "1",
126 "transportpce-renderer:rate": "100",
127 "transportpce-renderer:modulation-format": "dp-qpsk",
132 "tp-node-id": "SPDR-SC1-XPDR1",
139 "tp-node-id": "SPDR-SC1-XPDR1",
140 "tp-id": "XPDR1-NETWORK1"
146 "tp-node-id": "SPDR-SA1-XPDR1",
147 "tp-id": "XPDR1-NETWORK1"
153 "tp-node-id": "SPDR-SA1-XPDR1",
162 response = test_utils.post_request(url, data)
164 self.assertEqual(response.status_code, requests.codes.ok)
165 res = response.json()
166 self.assertIn('Operation Successful',
167 res["output"]["configuration-response-common"]["response-message"])
169 # Test OCH-OTU interfaces on SPDR-A1
170 def test_04_check_interface_och(self):
171 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
172 self.assertEqual(response.status_code, requests.codes.ok)
173 res = response.json()
174 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
175 'administrative-state': 'inService',
176 'supporting-circuit-pack-name': 'CP1-CFP0',
177 'type': 'org-openroadm-interfaces:opticalChannel',
178 'supporting-port': 'CP1-CFP0-P1'
179 }, **res['interface'][0]),
182 self.assertDictEqual(
183 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
184 u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
185 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
187 def test_05_check_interface_OTU(self):
188 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
189 self.assertEqual(response.status_code, requests.codes.ok)
190 res = response.json()
191 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
192 'administrative-state': 'inService',
193 'supporting-circuit-pack-name': 'CP1-CFP0',
194 'supporting-interface': 'XPDR1-NETWORK1-1',
195 'type': 'org-openroadm-interfaces:otnOtu',
196 'supporting-port': 'CP1-CFP0-P1'
198 input_dict_2 = {'tx-dapi': 'fuYZwEO660g=',
199 'expected-sapi': 'fuYZwEO660g=',
200 'tx-sapi': 'Swfw02qXGyI=',
201 'expected-dapi': 'Swfw02qXGyI=',
202 'rate': 'org-openroadm-otn-common-types:OTU4',
205 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
208 self.assertDictEqual(input_dict_2,
210 ['org-openroadm-otn-otu-interfaces:otu'])
212 # Test OCH-OTU interfaces on SPDR-C1
213 def test_06_check_interface_och(self):
214 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-1")
215 self.assertEqual(response.status_code, requests.codes.ok)
216 res = response.json()
217 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
218 'administrative-state': 'inService',
219 'supporting-circuit-pack-name': 'CP1-CFP0',
220 'type': 'org-openroadm-interfaces:opticalChannel',
221 'supporting-port': 'CP1-CFP0-P1'
222 }, **res['interface'][0]),
225 self.assertDictEqual(
226 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
227 u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
228 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
230 def test_07_check_interface_OTU(self):
231 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
232 self.assertEqual(response.status_code, requests.codes.ok)
233 res = response.json()
234 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
235 'administrative-state': 'inService',
236 'supporting-circuit-pack-name': 'CP1-CFP0',
237 'supporting-interface': 'XPDR1-NETWORK1-1',
238 'type': 'org-openroadm-interfaces:otnOtu',
239 'supporting-port': 'CP1-CFP0-P1'
241 input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
242 'expected-sapi': 'Swfw02qXGyI=',
243 'tx-sapi': 'fuYZwEO660g=',
244 'expected-dapi': 'fuYZwEO660g=',
245 'rate': 'org-openroadm-otn-common-types:OTU4',
249 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
252 self.assertDictEqual(input_dict_2,
254 ['org-openroadm-otn-otu-interfaces:otu'])
256 # Test creation of ODU4 service
257 def test_08_service_create_ODU4(self):
258 url = "{}/operations/transportpce-renderer:service-implementation-request"
261 "transportpce-renderer:input": {
262 "transportpce-renderer:service-name":
263 "SPDRA-SPDRC-OTU4-ODU4",
264 "transportpce-renderer:connection-type": "infrastructure",
265 "transportpce-renderer:service-handler-header": {
266 "transportpce-renderer:request-id": "abcd12-efgh34"
268 "transportpce-renderer:service-a-end": {
269 "transportpce-renderer:service-format": "ODU",
270 "transportpce-renderer:odu-service-rate":
271 "org-openroadm-otn-common-types:ODU4",
272 "transportpce-renderer:clli": "nodeSA",
273 "transportpce-renderer:node-id": "SPDR-SA1"
276 "transportpce-renderer:service-z-end": {
277 "transportpce-renderer:service-format": "ODU",
278 "transportpce-renderer:odu-service-rate":
279 "org-openroadm-otn-common-types:ODU4",
280 "transportpce-renderer:clli": "nodeSC",
281 "transportpce-renderer:node-id": "SPDR-SC1"
283 "transportpce-renderer:path-description": {
290 "tp-node-id": "SPDR-SA1-XPDR1",
297 "tp-node-id": "SPDR-SA1-XPDR1",
298 "tp-id": "XPDR1-NETWORK1"
304 "tp-node-id": "SPDR-SC1-XPDR1",
305 "tp-id": "XPDR1-NETWORK1"
311 "tp-node-id": "SPDR-SC1-XPDR1",
317 "transportpce-renderer:zToA-direction": {
318 "transportpce-renderer:rate": "100",
323 "tp-node-id": "SPDR-SC1-XPDR1",
330 "tp-node-id": "SPDR-SC1-XPDR1",
331 "tp-id": "XPDR1-NETWORK1"
337 "tp-node-id": "SPDR-SA1-XPDR1",
338 "tp-id": "XPDR1-NETWORK1"
344 "tp-node-id": "SPDR-SA1-XPDR1",
353 response = test_utils.post_request(url, data)
355 self.assertEqual(response.status_code, requests.codes.ok)
356 res = response.json()
357 self.assertIn('Operation Successful',
358 res["output"]["configuration-response-common"]
359 ["response-message"])
361 # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
362 def test_09_check_interface_ODU4(self):
363 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
364 self.assertEqual(response.status_code, requests.codes.ok)
365 res = response.json()
366 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
367 'administrative-state': 'inService',
368 'supporting-circuit-pack-name': 'CP1-CFP0',
369 'supporting-interface': 'XPDR1-NETWORK1-OTU',
370 'type': 'org-openroadm-interfaces:otnOdu',
371 'supporting-port': 'CP1-CFP0-P1'}
372 # SAPI/DAPI are added in the Otu4 renderer
373 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
374 'rate': 'org-openroadm-otn-common-types:ODU4',
375 'expected-dapi': 'Swfw02qXGyI=',
376 'expected-sapi': 'fuYZwEO660g=',
377 'tx-dapi': 'fuYZwEO660g=',
378 'tx-sapi': 'Swfw02qXGyI='}
380 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
382 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
384 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
386 self.assertDictEqual(
387 {u'payload-type': u'21', u'exp-payload-type': u'21'},
388 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
390 def test_10_check_interface_ODU4(self):
391 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
392 self.assertEqual(response.status_code, requests.codes.ok)
393 res = response.json()
394 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
395 'administrative-state': 'inService',
396 'supporting-circuit-pack-name': 'CP1-CFP0',
397 'supporting-interface': 'XPDR1-NETWORK1-OTU',
398 'type': 'org-openroadm-interfaces:otnOdu',
399 'supporting-port': 'CP1-CFP0-P1'}
400 # SAPI/DAPI are added in the Otu4 renderer
401 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
402 'rate': 'org-openroadm-otn-common-types:ODU4',
403 'tx-sapi': 'fuYZwEO660g=',
404 'tx-dapi': 'Swfw02qXGyI=',
405 'expected-sapi': 'Swfw02qXGyI=',
406 'expected-dapi': 'fuYZwEO660g='
408 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
410 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
412 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
414 self.assertDictEqual(
415 {u'payload-type': u'21', u'exp-payload-type': u'21'},
416 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
418 # Test creation of 10G service
419 def test_11_service_create_10GE(self):
420 url = "{}/operations/transportpce-renderer:service-implementation-request"
423 "transportpce-renderer:input": {
424 "transportpce-renderer:service-name": "SPDRA-SPDRC-10G",
425 "transportpce-renderer:connection-type": "service",
426 "transportpce-renderer:service-handler-header": {
427 "transportpce-renderer:request-id": "abcd12-efgh34"
429 "transportpce-renderer:service-a-end": {
430 "transportpce-renderer:service-format": "Ethernet",
431 "transportpce-renderer:service-rate": "10",
432 "transportpce-renderer:clli": "nodeSA",
433 "transportpce-renderer:node-id": "SPDR-SA1"
435 "transportpce-renderer:service-z-end": {
436 "transportpce-renderer:service-format": "Ethernet",
437 "transportpce-renderer:service-rate": "10",
438 "transportpce-renderer:clli": "nodeSC",
439 "transportpce-renderer:node-id": "SPDR-SC1"
441 "transportpce-renderer:path-description": {
444 "trib-port-number": 1,
445 "trib-slot-number": 1,
450 "tp-node-id": "SPDR-SA1-XPDR1",
451 "tp-id": "XPDR1-CLIENT1"
458 "tp-node-id": "SPDR-SA1-XPDR1",
459 "tp-id": "XPDR1-NETWORK1"
465 "tp-node-id": "SPDR-SC1-XPDR1",
466 "tp-id": "XPDR1-NETWORK1"
472 "tp-node-id": "SPDR-SC1-XPDR1",
473 "tp-id": "XPDR1-CLIENT1"
478 "transportpce-renderer:zToA-direction": {
480 "trib-port-number": 1,
481 "trib-slot-number": 1,
486 "tp-node-id": "SPDR-SC1-XPDR1",
487 "tp-id": "XPDR1-CLIENT1"
493 "tp-node-id": "SPDR-SC1-XPDR1",
494 "tp-id": "XPDR1-NETWORK1"
500 "tp-node-id": "SPDR-SA1-XPDR1",
501 "tp-id": "XPDR1-NETWORK1"
507 "tp-node-id": "SPDR-SA1-XPDR1",
508 "tp-id": "XPDR1-CLIENT1"
518 response = test_utils.post_request(url, data)
520 self.assertEqual(response.status_code, requests.codes.ok)
521 res = response.json()
522 self.assertIn('Operation Successful',
523 res["output"]["configuration-response-common"]
524 ["response-message"])
526 # Test the interfaces on SPDR-A1
527 def test_12_check_interface_10GE_CLIENT(self):
528 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
529 self.assertEqual(response.status_code, requests.codes.ok)
530 res = response.json()
531 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
532 'administrative-state': 'inService',
533 'supporting-circuit-pack-name': 'CP1-SFP4',
534 'type': 'org-openroadm-interfaces:ethernetCsmacd',
535 'supporting-port': 'CP1-SFP4-P1'
537 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
539 self.assertDictEqual(
541 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
543 def test_13_check_interface_ODU2E_CLIENT(self):
544 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
545 self.assertEqual(response.status_code, requests.codes.ok)
546 res = response.json()
547 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
548 'administrative-state': 'inService',
549 'supporting-circuit-pack-name': 'CP1-SFP4',
550 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
551 'type': 'org-openroadm-interfaces:otnOdu',
552 'supporting-port': 'CP1-SFP4-P1'}
554 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
555 'rate': 'org-openroadm-otn-common-types:ODU2e',
556 'monitoring-mode': 'terminated'}
558 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
560 self.assertDictEqual(dict(input_dict_2,
561 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
562 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
563 self.assertDictEqual(
564 {u'payload-type': u'03', u'exp-payload-type': u'03'},
565 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
567 def test_14_check_ODU2E_connection(self):
568 response = test_utils.check_netconf_node_request(
570 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
571 self.assertEqual(response.status_code, requests.codes.ok)
572 res = response.json()
575 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
576 'direction': 'bidirectional'
579 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
580 res['odu-connection'][0])
581 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
582 res['odu-connection'][0]['destination'])
583 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
584 res['odu-connection'][0]['source'])
586 def test_15_check_interface_ODU2E_NETWORK(self):
587 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
588 self.assertEqual(response.status_code, requests.codes.ok)
589 res = response.json()
590 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
591 'administrative-state': 'inService',
592 'supporting-circuit-pack-name': 'CP1-CFP0',
593 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
594 'type': 'org-openroadm-interfaces:otnOdu',
595 'supporting-port': 'CP1-CFP0-P1'}
597 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
598 'rate': 'org-openroadm-otn-common-types:ODU2e',
599 'monitoring-mode': 'monitored'}
601 input_dict_3 = {'trib-port-number': 1}
603 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
605 self.assertDictEqual(dict(input_dict_2,
606 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
607 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
608 self.assertDictEqual(dict(input_dict_3,
609 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
610 'parent-odu-allocation']),
611 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
612 'parent-odu-allocation'])
615 'org-openroadm-otn-odu-interfaces:odu'][
616 'parent-odu-allocation']['trib-slots'])
618 # Test the interfaces on SPDR-C1
619 def test_16_check_interface_ODU2E_NETWORK(self):
620 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
621 self.assertEqual(response.status_code, requests.codes.ok)
622 res = response.json()
623 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
624 'administrative-state': 'inService',
625 'supporting-circuit-pack-name': 'CP1-CFP0',
626 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
627 'type': 'org-openroadm-interfaces:otnOdu',
628 'supporting-port': 'CP1-CFP0-P1'}
630 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
631 'rate': 'org-openroadm-otn-common-types:ODU2e',
632 'monitoring-mode': 'monitored'}
634 input_dict_3 = {'trib-port-number': 1}
636 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
638 self.assertDictEqual(dict(input_dict_2,
639 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
640 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
641 self.assertDictEqual(dict(input_dict_3,
642 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
643 'parent-odu-allocation']),
644 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
645 'parent-odu-allocation'])
648 'org-openroadm-otn-odu-interfaces:odu'][
649 'parent-odu-allocation']['trib-slots'])
651 def test_17_check_interface_10GE_CLIENT(self):
652 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
653 self.assertEqual(response.status_code, requests.codes.ok)
654 res = response.json()
655 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
656 'administrative-state': 'inService',
657 'supporting-circuit-pack-name': 'CP1-SFP4',
658 'type': 'org-openroadm-interfaces:ethernetCsmacd',
659 'supporting-port': 'CP1-SFP4-P1'
661 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
663 self.assertDictEqual(
665 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
667 def test_18_check_interface_ODU2E_CLIENT(self):
668 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
669 self.assertEqual(response.status_code, requests.codes.ok)
670 res = response.json()
671 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
672 'administrative-state': 'inService',
673 'supporting-circuit-pack-name': 'CP1-SFP4',
674 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
675 'type': 'org-openroadm-interfaces:otnOdu',
676 'supporting-port': 'CP1-SFP4-P1'}
678 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
679 'rate': 'org-openroadm-otn-common-types:ODU2e',
680 'monitoring-mode': 'terminated'}
682 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
684 self.assertDictEqual(dict(input_dict_2,
685 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
686 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
687 self.assertDictEqual(
688 {u'payload-type': u'03', u'exp-payload-type': u'03'},
689 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
691 def test_19_check_ODU2E_connection(self):
692 response = test_utils.check_netconf_node_request(
694 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
695 self.assertEqual(response.status_code, requests.codes.ok)
696 res = response.json()
699 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
700 'direction': 'bidirectional'
703 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
704 res['odu-connection'][0])
705 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
706 res['odu-connection'][0]['destination'])
707 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
708 res['odu-connection'][0]['source'])
710 def test_20_check_interface_ODU2E_NETWORK(self):
711 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
712 self.assertEqual(response.status_code, requests.codes.ok)
713 res = response.json()
714 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
715 'administrative-state': 'inService',
716 'supporting-circuit-pack-name': 'CP1-CFP0',
717 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
718 'type': 'org-openroadm-interfaces:otnOdu',
719 'supporting-port': 'CP1-CFP0-P1'}
721 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
722 'rate': 'org-openroadm-otn-common-types:ODU2e',
723 'monitoring-mode': 'monitored'}
725 input_dict_3 = {'trib-port-number': 1}
727 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
729 self.assertDictEqual(dict(input_dict_2,
730 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
731 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
732 self.assertDictEqual(dict(input_dict_3,
733 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
734 'parent-odu-allocation']),
735 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
736 'parent-odu-allocation'])
739 'org-openroadm-otn-odu-interfaces:odu'][
740 'parent-odu-allocation']['trib-slots'])
742 # TODO: Delete the services (OTU, ODU, LO-ODU)
743 # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
745 def test_21_disconnect_SPDR_SA1(self):
746 response = test_utils.unmount_device("SPDR-SA1")
747 self.assertEqual(response.status_code, requests.codes.ok,
748 test_utils.CODE_SHOULD_BE_200)
750 def test_22_disconnect_SPDR_SC1(self):
751 response = test_utils.unmount_device("SPDR-SC1")
752 self.assertEqual(response.status_code, requests.codes.ok,
753 test_utils.CODE_SHOULD_BE_200)
756 if __name__ == "__main__":
757 unittest.main(verbosity=2)