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):
24 cls.processes = test_utils.start_tpce()
25 cls.processes = test_utils.start_sims(['spdra', 'spdrc'])
28 def tearDownClass(cls):
29 for process in cls.processes:
30 test_utils.shutdown_process(process)
31 print("all processes killed")
36 def test_01_connect_SPDR_SA1(self):
37 response = test_utils.mount_device("SPDR-SA1", 'spdra')
38 self.assertEqual(response.status_code, requests.codes.created,
39 test_utils.CODE_SHOULD_BE_201)
42 response = test_utils.get_netconf_oper_request("SPDR-SA1")
43 self.assertEqual(response.status_code, requests.codes.ok)
46 res['node'][0]['netconf-node-topology:connection-status'],
49 def test_02_connect_SPDR_SC1(self):
50 response = test_utils.mount_device("SPDR-SC1", 'spdrc')
51 self.assertEqual(response.status_code, requests.codes.created,
52 test_utils.CODE_SHOULD_BE_201)
55 response = test_utils.get_netconf_oper_request("SPDR-SC1")
56 self.assertEqual(response.status_code, requests.codes.ok)
59 res['node'][0]['netconf-node-topology:connection-status'],
62 def test_03_service_create_OTU4(self):
63 url = "{}/operations/transportpce-renderer:service-implementation-request"
65 "transportpce-renderer:input": {
66 "transportpce-renderer:service-name": "SPDRA-SPDRC-OTU4-ODU4",
67 "transportpce-renderer:connection-type": "infrastructure",
68 "transportpce-renderer:service-handler-header": {
69 "transportpce-renderer:request-id": "abcd12-efgh34"
71 "transportpce-renderer:service-a-end": {
72 "transportpce-renderer:service-format": "OTU",
73 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
74 "transportpce-renderer:clli": "nodeSA",
75 "transportpce-renderer:node-id": "SPDR-SA1"
78 "transportpce-renderer:service-z-end": {
79 "transportpce-renderer:service-format": "OTU",
80 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
81 "transportpce-renderer:clli": "nodeSC",
82 "transportpce-renderer:node-id": "SPDR-SC1"
84 "transportpce-renderer:path-description": {
87 "transportpce-renderer:modulation-format": "dp-qpsk",
88 "aToZ-wavelength-number": 1,
93 "tp-node-id": "SPDR-SA1-XPDR1",
100 "tp-node-id": "SPDR-SA1-XPDR1",
101 "tp-id": "XPDR1-NETWORK1"
107 "tp-node-id": "SPDR-SC1-XPDR1",
108 "tp-id": "XPDR1-NETWORK1"
114 "tp-node-id": "SPDR-SC1-XPDR1",
120 "transportpce-renderer:zToA-direction": {
121 "transportpce-renderer:zToA-wavelength-number": "1",
122 "transportpce-renderer:rate": "100",
123 "transportpce-renderer:modulation-format": "dp-qpsk",
128 "tp-node-id": "SPDR-SC1-XPDR1",
135 "tp-node-id": "SPDR-SC1-XPDR1",
136 "tp-id": "XPDR1-NETWORK1"
142 "tp-node-id": "SPDR-SA1-XPDR1",
143 "tp-id": "XPDR1-NETWORK1"
149 "tp-node-id": "SPDR-SA1-XPDR1",
158 response = test_utils.post_request(url, data)
160 self.assertEqual(response.status_code, requests.codes.ok)
161 res = response.json()
162 self.assertIn('Operation Successful',
163 res["output"]["configuration-response-common"]["response-message"])
165 # Test OCH-OTU interfaces on SPDR-A1
166 def test_04_check_interface_och(self):
167 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
168 self.assertEqual(response.status_code, requests.codes.ok)
169 res = response.json()
170 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
171 'administrative-state': 'inService',
172 'supporting-circuit-pack-name': 'CP1-CFP0',
173 'type': 'org-openroadm-interfaces:opticalChannel',
174 'supporting-port': 'CP1-CFP0-P1'
175 }, **res['interface'][0]),
178 self.assertDictEqual(
179 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
180 u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
181 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
183 def test_05_check_interface_OTU(self):
184 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
185 self.assertEqual(response.status_code, requests.codes.ok)
186 res = response.json()
187 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
188 'administrative-state': 'inService',
189 'supporting-circuit-pack-name': 'CP1-CFP0',
190 'supporting-interface': 'XPDR1-NETWORK1-1',
191 'type': 'org-openroadm-interfaces:otnOtu',
192 'supporting-port': 'CP1-CFP0-P1'
194 input_dict_2 = {'tx-dapi': 'fuYZwEO660g=',
195 'expected-sapi': 'fuYZwEO660g=',
196 'tx-sapi': 'Swfw02qXGyI=',
197 'expected-dapi': 'Swfw02qXGyI=',
198 'rate': 'org-openroadm-otn-common-types:OTU4',
201 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
204 self.assertDictEqual(input_dict_2,
206 ['org-openroadm-otn-otu-interfaces:otu'])
208 # Test OCH-OTU interfaces on SPDR-C1
209 def test_06_check_interface_och(self):
210 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-1")
211 self.assertEqual(response.status_code, requests.codes.ok)
212 res = response.json()
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 }, **res['interface'][0]),
221 self.assertDictEqual(
222 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
223 u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
224 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
226 def test_07_check_interface_OTU(self):
227 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
228 self.assertEqual(response.status_code, requests.codes.ok)
229 res = response.json()
230 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
231 'administrative-state': 'inService',
232 'supporting-circuit-pack-name': 'CP1-CFP0',
233 'supporting-interface': 'XPDR1-NETWORK1-1',
234 'type': 'org-openroadm-interfaces:otnOtu',
235 'supporting-port': 'CP1-CFP0-P1'
237 input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
238 'expected-sapi': 'Swfw02qXGyI=',
239 'tx-sapi': 'fuYZwEO660g=',
240 'expected-dapi': 'fuYZwEO660g=',
241 'rate': 'org-openroadm-otn-common-types:OTU4',
245 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
248 self.assertDictEqual(input_dict_2,
250 ['org-openroadm-otn-otu-interfaces:otu'])
252 # Test creation of ODU4 service
253 def test_08_service_create_ODU4(self):
254 url = "{}/operations/transportpce-renderer:service-implementation-request"
257 "transportpce-renderer:input": {
258 "transportpce-renderer:service-name":
259 "SPDRA-SPDRC-OTU4-ODU4",
260 "transportpce-renderer:connection-type": "infrastructure",
261 "transportpce-renderer:service-handler-header": {
262 "transportpce-renderer:request-id": "abcd12-efgh34"
264 "transportpce-renderer:service-a-end": {
265 "transportpce-renderer:service-format": "ODU",
266 "transportpce-renderer:odu-service-rate":
267 "org-openroadm-otn-common-types:ODU4",
268 "transportpce-renderer:clli": "nodeSA",
269 "transportpce-renderer:node-id": "SPDR-SA1"
272 "transportpce-renderer:service-z-end": {
273 "transportpce-renderer:service-format": "ODU",
274 "transportpce-renderer:odu-service-rate":
275 "org-openroadm-otn-common-types:ODU4",
276 "transportpce-renderer:clli": "nodeSC",
277 "transportpce-renderer:node-id": "SPDR-SC1"
279 "transportpce-renderer:path-description": {
286 "tp-node-id": "SPDR-SA1-XPDR1",
293 "tp-node-id": "SPDR-SA1-XPDR1",
294 "tp-id": "XPDR1-NETWORK1"
300 "tp-node-id": "SPDR-SC1-XPDR1",
301 "tp-id": "XPDR1-NETWORK1"
307 "tp-node-id": "SPDR-SC1-XPDR1",
313 "transportpce-renderer:zToA-direction": {
314 "transportpce-renderer:rate": "100",
319 "tp-node-id": "SPDR-SC1-XPDR1",
326 "tp-node-id": "SPDR-SC1-XPDR1",
327 "tp-id": "XPDR1-NETWORK1"
333 "tp-node-id": "SPDR-SA1-XPDR1",
334 "tp-id": "XPDR1-NETWORK1"
340 "tp-node-id": "SPDR-SA1-XPDR1",
349 response = test_utils.post_request(url, data)
351 self.assertEqual(response.status_code, requests.codes.ok)
352 res = response.json()
353 self.assertIn('Operation Successful',
354 res["output"]["configuration-response-common"]
355 ["response-message"])
357 # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
358 def test_09_check_interface_ODU4(self):
359 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
360 self.assertEqual(response.status_code, requests.codes.ok)
361 res = response.json()
362 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
363 'administrative-state': 'inService',
364 'supporting-circuit-pack-name': 'CP1-CFP0',
365 'supporting-interface': 'XPDR1-NETWORK1-OTU',
366 'type': 'org-openroadm-interfaces:otnOdu',
367 'supporting-port': 'CP1-CFP0-P1'}
368 # SAPI/DAPI are added in the Otu4 renderer
369 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
370 'rate': 'org-openroadm-otn-common-types:ODU4',
371 'expected-dapi': 'Swfw02qXGyI=',
372 'expected-sapi': 'fuYZwEO660g=',
373 'tx-dapi': 'fuYZwEO660g=',
374 'tx-sapi': 'Swfw02qXGyI='}
376 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
378 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
380 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
382 self.assertDictEqual(
383 {u'payload-type': u'21', u'exp-payload-type': u'21'},
384 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
386 def test_10_check_interface_ODU4(self):
387 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
388 self.assertEqual(response.status_code, requests.codes.ok)
389 res = response.json()
390 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
391 'administrative-state': 'inService',
392 'supporting-circuit-pack-name': 'CP1-CFP0',
393 'supporting-interface': 'XPDR1-NETWORK1-OTU',
394 'type': 'org-openroadm-interfaces:otnOdu',
395 'supporting-port': 'CP1-CFP0-P1'}
396 # SAPI/DAPI are added in the Otu4 renderer
397 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
398 'rate': 'org-openroadm-otn-common-types:ODU4',
399 'tx-sapi': 'fuYZwEO660g=',
400 'tx-dapi': 'Swfw02qXGyI=',
401 'expected-sapi': 'Swfw02qXGyI=',
402 'expected-dapi': 'fuYZwEO660g='
404 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
406 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
408 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
410 self.assertDictEqual(
411 {u'payload-type': u'21', u'exp-payload-type': u'21'},
412 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
414 # Test creation of 10G service
415 def test_11_service_create_10GE(self):
416 url = "{}/operations/transportpce-renderer:service-implementation-request"
419 "transportpce-renderer:input": {
420 "transportpce-renderer:service-name": "SPDRA-SPDRC-10G",
421 "transportpce-renderer:connection-type": "service",
422 "transportpce-renderer:service-handler-header": {
423 "transportpce-renderer:request-id": "abcd12-efgh34"
425 "transportpce-renderer:service-a-end": {
426 "transportpce-renderer:service-format": "Ethernet",
427 "transportpce-renderer:service-rate": "10",
428 "transportpce-renderer:clli": "nodeSA",
429 "transportpce-renderer:node-id": "SPDR-SA1"
431 "transportpce-renderer:service-z-end": {
432 "transportpce-renderer:service-format": "Ethernet",
433 "transportpce-renderer:service-rate": "10",
434 "transportpce-renderer:clli": "nodeSC",
435 "transportpce-renderer:node-id": "SPDR-SC1"
437 "transportpce-renderer:path-description": {
440 "trib-port-number": 1,
441 "trib-slot-number": 1,
446 "tp-node-id": "SPDR-SA1-XPDR1",
447 "tp-id": "XPDR1-CLIENT1"
454 "tp-node-id": "SPDR-SA1-XPDR1",
455 "tp-id": "XPDR1-NETWORK1"
461 "tp-node-id": "SPDR-SC1-XPDR1",
462 "tp-id": "XPDR1-NETWORK1"
468 "tp-node-id": "SPDR-SC1-XPDR1",
469 "tp-id": "XPDR1-CLIENT1"
474 "transportpce-renderer:zToA-direction": {
476 "trib-port-number": 1,
477 "trib-slot-number": 1,
482 "tp-node-id": "SPDR-SC1-XPDR1",
483 "tp-id": "XPDR1-CLIENT1"
489 "tp-node-id": "SPDR-SC1-XPDR1",
490 "tp-id": "XPDR1-NETWORK1"
496 "tp-node-id": "SPDR-SA1-XPDR1",
497 "tp-id": "XPDR1-NETWORK1"
503 "tp-node-id": "SPDR-SA1-XPDR1",
504 "tp-id": "XPDR1-CLIENT1"
514 response = test_utils.post_request(url, data)
516 self.assertEqual(response.status_code, requests.codes.ok)
517 res = response.json()
518 self.assertIn('Operation Successful',
519 res["output"]["configuration-response-common"]
520 ["response-message"])
522 # Test the interfaces on SPDR-A1
523 def test_12_check_interface_10GE_CLIENT(self):
524 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
525 self.assertEqual(response.status_code, requests.codes.ok)
526 res = response.json()
527 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
528 'administrative-state': 'inService',
529 'supporting-circuit-pack-name': 'CP1-SFP4',
530 'type': 'org-openroadm-interfaces:ethernetCsmacd',
531 'supporting-port': 'CP1-SFP4-P1'
533 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
535 self.assertDictEqual(
537 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
539 def test_13_check_interface_ODU2E_CLIENT(self):
540 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
541 self.assertEqual(response.status_code, requests.codes.ok)
542 res = response.json()
543 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
544 'administrative-state': 'inService',
545 'supporting-circuit-pack-name': 'CP1-SFP4',
546 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
547 'type': 'org-openroadm-interfaces:otnOdu',
548 'supporting-port': 'CP1-SFP4-P1'}
550 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
551 'rate': 'org-openroadm-otn-common-types:ODU2e',
552 'monitoring-mode': 'terminated'}
554 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
556 self.assertDictEqual(dict(input_dict_2,
557 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
558 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
559 self.assertDictEqual(
560 {u'payload-type': u'03', u'exp-payload-type': u'03'},
561 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
563 def test_14_check_ODU2E_connection(self):
564 response = test_utils.check_netconf_node_request(
566 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
567 self.assertEqual(response.status_code, requests.codes.ok)
568 res = response.json()
571 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
572 'direction': 'bidirectional'
575 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
576 res['odu-connection'][0])
577 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
578 res['odu-connection'][0]['destination'])
579 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
580 res['odu-connection'][0]['source'])
582 def test_15_check_interface_ODU2E_NETWORK(self):
583 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
584 self.assertEqual(response.status_code, requests.codes.ok)
585 res = response.json()
586 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
587 'administrative-state': 'inService',
588 'supporting-circuit-pack-name': 'CP1-CFP0',
589 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
590 'type': 'org-openroadm-interfaces:otnOdu',
591 'supporting-port': 'CP1-CFP0-P1'}
593 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
594 'rate': 'org-openroadm-otn-common-types:ODU2e',
595 'monitoring-mode': 'monitored'}
597 input_dict_3 = {'trib-port-number': 1}
599 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
601 self.assertDictEqual(dict(input_dict_2,
602 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
603 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
604 self.assertDictEqual(dict(input_dict_3,
605 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
606 'parent-odu-allocation']),
607 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
608 'parent-odu-allocation'])
611 'org-openroadm-otn-odu-interfaces:odu'][
612 'parent-odu-allocation']['trib-slots'])
614 # Test the interfaces on SPDR-C1
615 def test_16_check_interface_ODU2E_NETWORK(self):
616 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
617 self.assertEqual(response.status_code, requests.codes.ok)
618 res = response.json()
619 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
620 'administrative-state': 'inService',
621 'supporting-circuit-pack-name': 'CP1-CFP0',
622 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
623 'type': 'org-openroadm-interfaces:otnOdu',
624 'supporting-port': 'CP1-CFP0-P1'}
626 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
627 'rate': 'org-openroadm-otn-common-types:ODU2e',
628 'monitoring-mode': 'monitored'}
630 input_dict_3 = {'trib-port-number': 1}
632 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
634 self.assertDictEqual(dict(input_dict_2,
635 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
636 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
637 self.assertDictEqual(dict(input_dict_3,
638 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
639 'parent-odu-allocation']),
640 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
641 'parent-odu-allocation'])
644 'org-openroadm-otn-odu-interfaces:odu'][
645 'parent-odu-allocation']['trib-slots'])
647 def test_17_check_interface_10GE_CLIENT(self):
648 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
649 self.assertEqual(response.status_code, requests.codes.ok)
650 res = response.json()
651 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
652 'administrative-state': 'inService',
653 'supporting-circuit-pack-name': 'CP1-SFP4',
654 'type': 'org-openroadm-interfaces:ethernetCsmacd',
655 'supporting-port': 'CP1-SFP4-P1'
657 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
659 self.assertDictEqual(
661 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
663 def test_18_check_interface_ODU2E_CLIENT(self):
664 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
665 self.assertEqual(response.status_code, requests.codes.ok)
666 res = response.json()
667 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
668 'administrative-state': 'inService',
669 'supporting-circuit-pack-name': 'CP1-SFP4',
670 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
671 'type': 'org-openroadm-interfaces:otnOdu',
672 'supporting-port': 'CP1-SFP4-P1'}
674 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
675 'rate': 'org-openroadm-otn-common-types:ODU2e',
676 'monitoring-mode': 'terminated'}
678 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
680 self.assertDictEqual(dict(input_dict_2,
681 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
682 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
683 self.assertDictEqual(
684 {u'payload-type': u'03', u'exp-payload-type': u'03'},
685 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
687 def test_19_check_ODU2E_connection(self):
688 response = test_utils.check_netconf_node_request(
690 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
691 self.assertEqual(response.status_code, requests.codes.ok)
692 res = response.json()
695 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
696 'direction': 'bidirectional'
699 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
700 res['odu-connection'][0])
701 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
702 res['odu-connection'][0]['destination'])
703 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
704 res['odu-connection'][0]['source'])
706 def test_20_check_interface_ODU2E_NETWORK(self):
707 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
708 self.assertEqual(response.status_code, requests.codes.ok)
709 res = response.json()
710 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
711 'administrative-state': 'inService',
712 'supporting-circuit-pack-name': 'CP1-CFP0',
713 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
714 'type': 'org-openroadm-interfaces:otnOdu',
715 'supporting-port': 'CP1-CFP0-P1'}
717 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
718 'rate': 'org-openroadm-otn-common-types:ODU2e',
719 'monitoring-mode': 'monitored'}
721 input_dict_3 = {'trib-port-number': 1}
723 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
725 self.assertDictEqual(dict(input_dict_2,
726 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
727 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
728 self.assertDictEqual(dict(input_dict_3,
729 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
730 'parent-odu-allocation']),
731 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
732 'parent-odu-allocation'])
735 'org-openroadm-otn-odu-interfaces:odu'][
736 'parent-odu-allocation']['trib-slots'])
738 # TODO: Delete the services (OTU, ODU, LO-ODU)
739 # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
741 def test_21_disconnect_SPDR_SA1(self):
742 response = test_utils.unmount_device("SPDR-SA1")
743 self.assertEqual(response.status_code, requests.codes.ok,
744 test_utils.CODE_SHOULD_BE_200)
746 def test_22_disconnect_SPDR_SC1(self):
747 response = test_utils.unmount_device("SPDR-SC1")
748 self.assertEqual(response.status_code, requests.codes.ok,
749 test_utils.CODE_SHOULD_BE_200)
752 if __name__ == "__main__":
753 unittest.main(verbosity=2)