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
19 sys.path.append('transportpce_tests/common/')
23 class TransportPCEtesting(unittest.TestCase):
26 NODE_VERSION = '2.2.1'
30 cls.processes = test_utils.start_tpce()
31 cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION),
32 ('spdrc', cls.NODE_VERSION)])
35 def tearDownClass(cls):
36 # pylint: disable=not-an-iterable
37 for process in cls.processes:
38 test_utils.shutdown_process(process)
39 print("all processes killed")
44 def test_01_connect_SPDR_SA1(self):
45 response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
46 self.assertEqual(response.status_code, requests.codes.created,
47 test_utils.CODE_SHOULD_BE_201)
50 response = test_utils.get_netconf_oper_request("SPDR-SA1")
51 self.assertEqual(response.status_code, requests.codes.ok)
54 res['node'][0]['netconf-node-topology:connection-status'],
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.get_netconf_oper_request("SPDR-SC1")
64 self.assertEqual(response.status_code, requests.codes.ok)
67 res['node'][0]['netconf-node-topology:connection-status'],
70 def test_03_service_create_OTU4(self):
71 url = "{}/operations/transportpce-renderer:service-implementation-request"
73 "transportpce-renderer:input": {
74 "transportpce-renderer:service-name": "SPDRA-SPDRC-OTU4-ODU4",
75 "transportpce-renderer:connection-type": "infrastructure",
76 "transportpce-renderer:service-handler-header": {
77 "transportpce-renderer:request-id": "abcd12-efgh34"
79 "transportpce-renderer:service-a-end": {
80 "transportpce-renderer:service-format": "OTU",
81 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
82 "transportpce-renderer:clli": "nodeSA",
83 "transportpce-renderer:node-id": "SPDR-SA1"
86 "transportpce-renderer:service-z-end": {
87 "transportpce-renderer:service-format": "OTU",
88 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
89 "transportpce-renderer:clli": "nodeSC",
90 "transportpce-renderer:node-id": "SPDR-SC1"
92 "transportpce-renderer:path-description": {
95 "transportpce-renderer:modulation-format": "dp-qpsk",
96 "aToZ-wavelength-number": 1,
101 "tp-node-id": "SPDR-SA1-XPDR1",
108 "tp-node-id": "SPDR-SA1-XPDR1",
109 "tp-id": "XPDR1-NETWORK1"
115 "tp-node-id": "SPDR-SC1-XPDR1",
116 "tp-id": "XPDR1-NETWORK1"
122 "tp-node-id": "SPDR-SC1-XPDR1",
127 "transportpce-renderer:aToZ-min-frequency": 196.075,
128 "transportpce-renderer:aToZ-max-frequency": 196.125
130 "transportpce-renderer:zToA-direction": {
131 "transportpce-renderer:zToA-wavelength-number": "1",
132 "transportpce-renderer:rate": "100",
133 "transportpce-renderer:modulation-format": "dp-qpsk",
138 "tp-node-id": "SPDR-SC1-XPDR1",
145 "tp-node-id": "SPDR-SC1-XPDR1",
146 "tp-id": "XPDR1-NETWORK1"
152 "tp-node-id": "SPDR-SA1-XPDR1",
153 "tp-id": "XPDR1-NETWORK1"
159 "tp-node-id": "SPDR-SA1-XPDR1",
164 "transportpce-renderer:zToA-min-frequency": 196.075,
165 "transportpce-renderer:zToA-max-frequency": 196.125
170 response = test_utils.post_request(url, data)
172 print(response.json())
173 self.assertEqual(response.status_code, requests.codes.ok)
174 res = response.json()
175 self.assertIn('Operation Successful',
176 res["output"]["configuration-response-common"]["response-message"])
178 # Test OCH-OTU interfaces on SPDR-A1
179 def test_04_check_interface_och(self):
180 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-761:768")
181 self.assertEqual(response.status_code, requests.codes.ok)
182 res = response.json()
183 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
184 'administrative-state': 'inService',
185 'supporting-circuit-pack-name': 'CP1-CFP0',
186 'type': 'org-openroadm-interfaces:opticalChannel',
187 'supporting-port': 'CP1-CFP0-P1'
188 }, **res['interface'][0]),
191 self.assertDictEqual(
192 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
193 u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
194 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
196 def test_05_check_interface_OTU(self):
197 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
198 self.assertEqual(response.status_code, requests.codes.ok)
199 res = response.json()
200 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
201 'administrative-state': 'inService',
202 'supporting-circuit-pack-name': 'CP1-CFP0',
203 'supporting-interface': 'XPDR1-NETWORK1-1',
204 'type': 'org-openroadm-interfaces:otnOtu',
205 'supporting-port': 'CP1-CFP0-P1'
207 input_dict_2 = {'tx-dapi': 'fuYZwEO660g=',
208 'expected-sapi': 'fuYZwEO660g=',
209 'tx-sapi': 'Swfw02qXGyI=',
210 'expected-dapi': 'Swfw02qXGyI=',
211 'rate': 'org-openroadm-otn-common-types:OTU4',
214 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
217 self.assertDictEqual(input_dict_2,
219 ['org-openroadm-otn-otu-interfaces:otu'])
221 # Test OCH-OTU interfaces on SPDR-C1
222 def test_06_check_interface_och(self):
223 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-761:768")
224 self.assertEqual(response.status_code, requests.codes.ok)
225 res = response.json()
226 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
227 'administrative-state': 'inService',
228 'supporting-circuit-pack-name': 'CP1-CFP0',
229 'type': 'org-openroadm-interfaces:opticalChannel',
230 'supporting-port': 'CP1-CFP0-P1'
231 }, **res['interface'][0]),
234 self.assertDictEqual(
235 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
236 u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
237 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
239 def test_07_check_interface_OTU(self):
240 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
241 self.assertEqual(response.status_code, requests.codes.ok)
242 res = response.json()
243 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
244 'administrative-state': 'inService',
245 'supporting-circuit-pack-name': 'CP1-CFP0',
246 'supporting-interface': 'XPDR1-NETWORK1-1',
247 'type': 'org-openroadm-interfaces:otnOtu',
248 'supporting-port': 'CP1-CFP0-P1'
250 input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
251 'expected-sapi': 'Swfw02qXGyI=',
252 'tx-sapi': 'fuYZwEO660g=',
253 'expected-dapi': 'fuYZwEO660g=',
254 'rate': 'org-openroadm-otn-common-types:OTU4',
258 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
261 self.assertDictEqual(input_dict_2,
263 ['org-openroadm-otn-otu-interfaces:otu'])
265 # Test creation of ODU4 service
266 def test_08_service_create_ODU4(self):
267 url = "{}/operations/transportpce-renderer:service-implementation-request"
270 "transportpce-renderer:input": {
271 "transportpce-renderer:service-name":
272 "SPDRA-SPDRC-OTU4-ODU4",
273 "transportpce-renderer:connection-type": "infrastructure",
274 "transportpce-renderer:service-handler-header": {
275 "transportpce-renderer:request-id": "abcd12-efgh34"
277 "transportpce-renderer:service-a-end": {
278 "transportpce-renderer:service-format": "ODU",
279 "transportpce-renderer:odu-service-rate":
280 "org-openroadm-otn-common-types:ODU4",
281 "transportpce-renderer:clli": "nodeSA",
282 "transportpce-renderer:node-id": "SPDR-SA1"
285 "transportpce-renderer:service-z-end": {
286 "transportpce-renderer:service-format": "ODU",
287 "transportpce-renderer:odu-service-rate":
288 "org-openroadm-otn-common-types:ODU4",
289 "transportpce-renderer:clli": "nodeSC",
290 "transportpce-renderer:node-id": "SPDR-SC1"
292 "transportpce-renderer:path-description": {
299 "tp-node-id": "SPDR-SA1-XPDR1",
306 "tp-node-id": "SPDR-SA1-XPDR1",
307 "tp-id": "XPDR1-NETWORK1"
313 "tp-node-id": "SPDR-SC1-XPDR1",
314 "tp-id": "XPDR1-NETWORK1"
320 "tp-node-id": "SPDR-SC1-XPDR1",
326 "transportpce-renderer:zToA-direction": {
327 "transportpce-renderer:rate": "100",
332 "tp-node-id": "SPDR-SC1-XPDR1",
339 "tp-node-id": "SPDR-SC1-XPDR1",
340 "tp-id": "XPDR1-NETWORK1"
346 "tp-node-id": "SPDR-SA1-XPDR1",
347 "tp-id": "XPDR1-NETWORK1"
353 "tp-node-id": "SPDR-SA1-XPDR1",
362 response = test_utils.post_request(url, data)
364 self.assertEqual(response.status_code, requests.codes.ok)
365 res = response.json()
366 self.assertIn('Operation Successful',
367 res["output"]["configuration-response-common"]
368 ["response-message"])
370 # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
371 def test_09_check_interface_ODU4(self):
372 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
373 self.assertEqual(response.status_code, requests.codes.ok)
374 res = response.json()
375 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
376 'administrative-state': 'inService',
377 'supporting-circuit-pack-name': 'CP1-CFP0',
378 'supporting-interface': 'XPDR1-NETWORK1-OTU',
379 'type': 'org-openroadm-interfaces:otnOdu',
380 'supporting-port': 'CP1-CFP0-P1'}
381 # SAPI/DAPI are added in the Otu4 renderer
382 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
383 'rate': 'org-openroadm-otn-common-types:ODU4',
384 'expected-dapi': 'Swfw02qXGyI=',
385 'expected-sapi': 'fuYZwEO660g=',
386 'tx-dapi': 'fuYZwEO660g=',
387 'tx-sapi': 'Swfw02qXGyI='}
389 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
391 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
393 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
395 self.assertDictEqual(
396 {u'payload-type': u'21', u'exp-payload-type': u'21'},
397 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
399 def test_10_check_interface_ODU4(self):
400 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
401 self.assertEqual(response.status_code, requests.codes.ok)
402 res = response.json()
403 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
404 'administrative-state': 'inService',
405 'supporting-circuit-pack-name': 'CP1-CFP0',
406 'supporting-interface': 'XPDR1-NETWORK1-OTU',
407 'type': 'org-openroadm-interfaces:otnOdu',
408 'supporting-port': 'CP1-CFP0-P1'}
409 # SAPI/DAPI are added in the Otu4 renderer
410 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
411 'rate': 'org-openroadm-otn-common-types:ODU4',
412 'tx-sapi': 'fuYZwEO660g=',
413 'tx-dapi': 'Swfw02qXGyI=',
414 'expected-sapi': 'Swfw02qXGyI=',
415 'expected-dapi': 'fuYZwEO660g='
417 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
419 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
421 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
423 self.assertDictEqual(
424 {u'payload-type': u'21', u'exp-payload-type': u'21'},
425 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
427 # Test creation of 10G service
428 def test_11_service_create_10GE(self):
429 url = "{}/operations/transportpce-renderer:service-implementation-request"
432 "transportpce-renderer:input": {
433 "transportpce-renderer:service-name": "SPDRA-SPDRC-10G",
434 "transportpce-renderer:connection-type": "service",
435 "transportpce-renderer:service-handler-header": {
436 "transportpce-renderer:request-id": "abcd12-efgh34"
438 "transportpce-renderer:service-a-end": {
439 "transportpce-renderer:service-format": "Ethernet",
440 "transportpce-renderer:service-rate": "10",
441 "transportpce-renderer:clli": "nodeSA",
442 "transportpce-renderer:node-id": "SPDR-SA1"
444 "transportpce-renderer:service-z-end": {
445 "transportpce-renderer:service-format": "Ethernet",
446 "transportpce-renderer:service-rate": "10",
447 "transportpce-renderer:clli": "nodeSC",
448 "transportpce-renderer:node-id": "SPDR-SC1"
450 "transportpce-renderer:path-description": {
453 "min-trib-slot": "1.1",
454 "max-trib-slot": "1.8",
459 "tp-node-id": "SPDR-SA1-XPDR1",
460 "tp-id": "XPDR1-CLIENT1"
467 "tp-node-id": "SPDR-SA1-XPDR1",
468 "tp-id": "XPDR1-NETWORK1"
474 "tp-node-id": "SPDR-SC1-XPDR1",
475 "tp-id": "XPDR1-NETWORK1"
481 "tp-node-id": "SPDR-SC1-XPDR1",
482 "tp-id": "XPDR1-CLIENT1"
487 "transportpce-renderer:zToA-direction": {
489 "min-trib-slot": "1.1",
490 "max-trib-slot": "1.8",
495 "tp-node-id": "SPDR-SC1-XPDR1",
496 "tp-id": "XPDR1-CLIENT1"
502 "tp-node-id": "SPDR-SC1-XPDR1",
503 "tp-id": "XPDR1-NETWORK1"
509 "tp-node-id": "SPDR-SA1-XPDR1",
510 "tp-id": "XPDR1-NETWORK1"
516 "tp-node-id": "SPDR-SA1-XPDR1",
517 "tp-id": "XPDR1-CLIENT1"
527 response = test_utils.post_request(url, data)
529 self.assertEqual(response.status_code, requests.codes.ok)
530 res = response.json()
531 self.assertIn('Operation Successful',
532 res["output"]["configuration-response-common"]
533 ["response-message"])
535 # Test the interfaces on SPDR-A1
536 def test_12_check_interface_10GE_CLIENT(self):
537 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
538 self.assertEqual(response.status_code, requests.codes.ok)
539 res = response.json()
540 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
541 'administrative-state': 'inService',
542 'supporting-circuit-pack-name': 'CP1-SFP4',
543 'type': 'org-openroadm-interfaces:ethernetCsmacd',
544 'supporting-port': 'CP1-SFP4-P1'
546 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
548 self.assertDictEqual(
550 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
552 def test_13_check_interface_ODU2E_CLIENT(self):
553 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
554 self.assertEqual(response.status_code, requests.codes.ok)
555 res = response.json()
556 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
557 'administrative-state': 'inService',
558 'supporting-circuit-pack-name': 'CP1-SFP4',
559 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
560 'type': 'org-openroadm-interfaces:otnOdu',
561 'supporting-port': 'CP1-SFP4-P1'}
563 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
564 'rate': 'org-openroadm-otn-common-types:ODU2e',
565 'monitoring-mode': 'terminated'}
567 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
569 self.assertDictEqual(dict(input_dict_2,
570 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
571 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
572 self.assertDictEqual(
573 {u'payload-type': u'03', u'exp-payload-type': u'03'},
574 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
576 def test_14_check_ODU2E_connection(self):
577 response = test_utils.check_netconf_node_request(
579 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
580 self.assertEqual(response.status_code, requests.codes.ok)
581 res = response.json()
584 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
585 'direction': 'bidirectional'
588 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
589 res['odu-connection'][0])
590 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
591 res['odu-connection'][0]['destination'])
592 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
593 res['odu-connection'][0]['source'])
595 def test_15_check_interface_ODU2E_NETWORK(self):
596 response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
597 self.assertEqual(response.status_code, requests.codes.ok)
598 res = response.json()
599 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
600 'administrative-state': 'inService',
601 'supporting-circuit-pack-name': 'CP1-CFP0',
602 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
603 'type': 'org-openroadm-interfaces:otnOdu',
604 'supporting-port': 'CP1-CFP0-P1'}
606 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
607 'rate': 'org-openroadm-otn-common-types:ODU2e',
608 'monitoring-mode': 'monitored'}
610 input_dict_3 = {'trib-port-number': 1}
612 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
614 self.assertDictEqual(dict(input_dict_2,
615 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
616 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
617 self.assertDictEqual(dict(input_dict_3,
618 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
619 'parent-odu-allocation']),
620 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
621 'parent-odu-allocation'])
624 'org-openroadm-otn-odu-interfaces:odu'][
625 'parent-odu-allocation']['trib-slots'])
627 # Test the interfaces on SPDR-C1
628 def test_16_check_interface_ODU2E_NETWORK(self):
629 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
630 self.assertEqual(response.status_code, requests.codes.ok)
631 res = response.json()
632 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
633 'administrative-state': 'inService',
634 'supporting-circuit-pack-name': 'CP1-CFP0',
635 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
636 'type': 'org-openroadm-interfaces:otnOdu',
637 'supporting-port': 'CP1-CFP0-P1'}
639 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
640 'rate': 'org-openroadm-otn-common-types:ODU2e',
641 'monitoring-mode': 'monitored'}
643 input_dict_3 = {'trib-port-number': 1}
645 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
647 self.assertDictEqual(dict(input_dict_2,
648 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
649 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
650 self.assertDictEqual(dict(input_dict_3,
651 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
652 'parent-odu-allocation']),
653 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
654 'parent-odu-allocation'])
657 'org-openroadm-otn-odu-interfaces:odu'][
658 'parent-odu-allocation']['trib-slots'])
660 def test_17_check_interface_10GE_CLIENT(self):
661 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
662 self.assertEqual(response.status_code, requests.codes.ok)
663 res = response.json()
664 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
665 'administrative-state': 'inService',
666 'supporting-circuit-pack-name': 'CP1-SFP4',
667 'type': 'org-openroadm-interfaces:ethernetCsmacd',
668 'supporting-port': 'CP1-SFP4-P1'
670 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
672 self.assertDictEqual(
674 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
676 def test_18_check_interface_ODU2E_CLIENT(self):
677 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
678 self.assertEqual(response.status_code, requests.codes.ok)
679 res = response.json()
680 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
681 'administrative-state': 'inService',
682 'supporting-circuit-pack-name': 'CP1-SFP4',
683 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
684 'type': 'org-openroadm-interfaces:otnOdu',
685 'supporting-port': 'CP1-SFP4-P1'}
687 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
688 'rate': 'org-openroadm-otn-common-types:ODU2e',
689 'monitoring-mode': 'terminated'}
691 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
693 self.assertDictEqual(dict(input_dict_2,
694 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
695 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
696 self.assertDictEqual(
697 {u'payload-type': u'03', u'exp-payload-type': u'03'},
698 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
700 def test_19_check_ODU2E_connection(self):
701 response = test_utils.check_netconf_node_request(
703 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
704 self.assertEqual(response.status_code, requests.codes.ok)
705 res = response.json()
708 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
709 'direction': 'bidirectional'
712 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
713 res['odu-connection'][0])
714 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
715 res['odu-connection'][0]['destination'])
716 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
717 res['odu-connection'][0]['source'])
719 def test_20_check_interface_ODU2E_NETWORK(self):
720 response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
721 self.assertEqual(response.status_code, requests.codes.ok)
722 res = response.json()
723 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
724 'administrative-state': 'inService',
725 'supporting-circuit-pack-name': 'CP1-CFP0',
726 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
727 'type': 'org-openroadm-interfaces:otnOdu',
728 'supporting-port': 'CP1-CFP0-P1'}
730 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
731 'rate': 'org-openroadm-otn-common-types:ODU2e',
732 'monitoring-mode': 'monitored'}
734 input_dict_3 = {'trib-port-number': 1}
736 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
738 self.assertDictEqual(dict(input_dict_2,
739 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
740 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
741 self.assertDictEqual(dict(input_dict_3,
742 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
743 'parent-odu-allocation']),
744 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
745 'parent-odu-allocation'])
748 'org-openroadm-otn-odu-interfaces:odu'][
749 'parent-odu-allocation']['trib-slots'])
751 # TODO: Delete the services (OTU, ODU, LO-ODU)
752 # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
754 def test_21_disconnect_SPDR_SA1(self):
755 response = test_utils.unmount_device("SPDR-SA1")
756 self.assertEqual(response.status_code, requests.codes.ok,
757 test_utils.CODE_SHOULD_BE_200)
759 def test_22_disconnect_SPDR_SC1(self):
760 response = test_utils.unmount_device("SPDR-SC1")
761 self.assertEqual(response.status_code, requests.codes.ok,
762 test_utils.CODE_SHOULD_BE_200)
765 if __name__ == "__main__":
766 unittest.main(verbosity=2)