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 url = "{}/operational/network-topology:network-topology/topology/topology-netconf/node/SPDR-SA1"
43 response = test_utils.get_request(url)
44 self.assertEqual(response.status_code, requests.codes.ok)
47 res['node'][0]['netconf-node-topology:connection-status'],
50 def test_02_connect_SPDR_SC1(self):
51 response = test_utils.mount_device("SPDR-SC1", 'spdrc')
52 self.assertEqual(response.status_code, requests.codes.created,
53 test_utils.CODE_SHOULD_BE_201)
56 url = "{}/operational/network-topology:network-topology/topology/topology-netconf/node/SPDR-SC1"
57 response = test_utils.get_request(url)
58 self.assertEqual(response.status_code, requests.codes.ok)
61 res['node'][0]['netconf-node-topology:connection-status'],
64 def test_03_service_create_OTU4(self):
65 url = "{}/operations/transportpce-renderer:service-implementation-request"
67 "transportpce-renderer:input": {
68 "transportpce-renderer:service-name": "SPDRA-SPDRC-OTU4-ODU4",
69 "transportpce-renderer:connection-type": "infrastructure",
70 "transportpce-renderer:service-handler-header": {
71 "transportpce-renderer:request-id": "abcd12-efgh34"
73 "transportpce-renderer:service-a-end": {
74 "transportpce-renderer:service-format": "OTU",
75 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
76 "transportpce-renderer:clli": "nodeSA",
77 "transportpce-renderer:node-id": "SPDR-SA1"
80 "transportpce-renderer:service-z-end": {
81 "transportpce-renderer:service-format": "OTU",
82 "transportpce-renderer:otu-service-rate": "org-openroadm-otn-common-types:OTU4",
83 "transportpce-renderer:clli": "nodeSC",
84 "transportpce-renderer:node-id": "SPDR-SC1"
86 "transportpce-renderer:path-description": {
89 "transportpce-renderer:modulation-format": "dp-qpsk",
90 "aToZ-wavelength-number": 1,
95 "tp-node-id": "SPDR-SA1-XPDR1",
102 "tp-node-id": "SPDR-SA1-XPDR1",
103 "tp-id": "XPDR1-NETWORK1"
109 "tp-node-id": "SPDR-SC1-XPDR1",
110 "tp-id": "XPDR1-NETWORK1"
116 "tp-node-id": "SPDR-SC1-XPDR1",
122 "transportpce-renderer:zToA-direction": {
123 "transportpce-renderer:zToA-wavelength-number": "1",
124 "transportpce-renderer:rate": "100",
125 "transportpce-renderer:modulation-format": "dp-qpsk",
130 "tp-node-id": "SPDR-SC1-XPDR1",
137 "tp-node-id": "SPDR-SC1-XPDR1",
138 "tp-id": "XPDR1-NETWORK1"
144 "tp-node-id": "SPDR-SA1-XPDR1",
145 "tp-id": "XPDR1-NETWORK1"
151 "tp-node-id": "SPDR-SA1-XPDR1",
160 response = test_utils.post_request(url, data)
162 self.assertEqual(response.status_code, requests.codes.ok)
163 res = response.json()
164 self.assertIn('Operation Successful',
165 res["output"]["configuration-response-common"]["response-message"])
167 # Test OCH-OTU interfaces on SPDR-A1
168 def test_04_check_interface_och(self):
169 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
170 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
171 "interface/XPDR1-NETWORK1-1"
173 response = test_utils.get_request(url)
174 self.assertEqual(response.status_code, requests.codes.ok)
175 res = response.json()
176 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
177 'administrative-state': 'inService',
178 'supporting-circuit-pack-name': 'CP1-CFP0',
179 'type': 'org-openroadm-interfaces:opticalChannel',
180 'supporting-port': 'CP1-CFP0-P1'
181 }, **res['interface'][0]),
184 self.assertDictEqual(
185 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
186 u'transmit-power': -5},
187 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
189 def test_05_check_interface_OTU(self):
190 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
191 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
192 "interface/XPDR1-NETWORK1-OTU"
194 response = test_utils.get_request(url)
195 self.assertEqual(response.status_code, requests.codes.ok)
196 res = response.json()
197 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
198 'administrative-state': 'inService',
199 'supporting-circuit-pack-name': 'CP1-CFP0',
200 'supporting-interface': 'XPDR1-NETWORK1-1',
201 'type': 'org-openroadm-interfaces:otnOtu',
202 'supporting-port': 'CP1-CFP0-P1'
204 input_dict_2 = {'tx-dapi': 'fuYZwEO660g=',
205 'expected-sapi': 'fuYZwEO660g=',
206 'tx-sapi': 'Swfw02qXGyI=',
207 'expected-dapi': 'Swfw02qXGyI=',
208 'rate': 'org-openroadm-otn-common-types:OTU4',
211 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
214 self.assertDictEqual(input_dict_2,
216 ['org-openroadm-otn-otu-interfaces:otu'])
218 # Test OCH-OTU interfaces on SPDR-C1
219 def test_06_check_interface_och(self):
220 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
221 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
222 "interface/XPDR1-NETWORK1-1"
224 response = test_utils.get_request(url)
225 self.assertEqual(response.status_code, requests.codes.ok)
226 res = response.json()
227 self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
228 'administrative-state': 'inService',
229 'supporting-circuit-pack-name': 'CP1-CFP0',
230 'type': 'org-openroadm-interfaces:opticalChannel',
231 'supporting-port': 'CP1-CFP0-P1'
232 }, **res['interface'][0]),
235 self.assertDictEqual(
236 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
237 u'transmit-power': -5},
238 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
240 def test_07_check_interface_OTU(self):
241 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
242 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
243 "interface/XPDR1-NETWORK1-OTU"
245 response = test_utils.get_request(url)
246 self.assertEqual(response.status_code, requests.codes.ok)
247 res = response.json()
248 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
249 'administrative-state': 'inService',
250 'supporting-circuit-pack-name': 'CP1-CFP0',
251 'supporting-interface': 'XPDR1-NETWORK1-1',
252 'type': 'org-openroadm-interfaces:otnOtu',
253 'supporting-port': 'CP1-CFP0-P1'
255 input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
256 'expected-sapi': 'Swfw02qXGyI=',
257 'tx-sapi': 'fuYZwEO660g=',
258 'expected-dapi': 'fuYZwEO660g=',
259 'rate': 'org-openroadm-otn-common-types:OTU4',
263 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
266 self.assertDictEqual(input_dict_2,
268 ['org-openroadm-otn-otu-interfaces:otu'])
270 # Test creation of ODU4 service
271 def test_08_service_create_ODU4(self):
272 url = "{}/operations/transportpce-renderer:service-implementation-request"
275 "transportpce-renderer:input": {
276 "transportpce-renderer:service-name":
277 "SPDRA-SPDRC-OTU4-ODU4",
278 "transportpce-renderer:connection-type": "infrastructure",
279 "transportpce-renderer:service-handler-header": {
280 "transportpce-renderer:request-id": "abcd12-efgh34"
282 "transportpce-renderer:service-a-end": {
283 "transportpce-renderer:service-format": "ODU",
284 "transportpce-renderer:odu-service-rate":
285 "org-openroadm-otn-common-types:ODU4",
286 "transportpce-renderer:clli": "nodeSA",
287 "transportpce-renderer:node-id": "SPDR-SA1"
290 "transportpce-renderer:service-z-end": {
291 "transportpce-renderer:service-format": "ODU",
292 "transportpce-renderer:odu-service-rate":
293 "org-openroadm-otn-common-types:ODU4",
294 "transportpce-renderer:clli": "nodeSC",
295 "transportpce-renderer:node-id": "SPDR-SC1"
297 "transportpce-renderer:path-description": {
304 "tp-node-id": "SPDR-SA1-XPDR1",
311 "tp-node-id": "SPDR-SA1-XPDR1",
312 "tp-id": "XPDR1-NETWORK1"
318 "tp-node-id": "SPDR-SC1-XPDR1",
319 "tp-id": "XPDR1-NETWORK1"
325 "tp-node-id": "SPDR-SC1-XPDR1",
331 "transportpce-renderer:zToA-direction": {
332 "transportpce-renderer:rate": "100",
337 "tp-node-id": "SPDR-SC1-XPDR1",
344 "tp-node-id": "SPDR-SC1-XPDR1",
345 "tp-id": "XPDR1-NETWORK1"
351 "tp-node-id": "SPDR-SA1-XPDR1",
352 "tp-id": "XPDR1-NETWORK1"
358 "tp-node-id": "SPDR-SA1-XPDR1",
367 response = test_utils.post_request(url, data)
369 self.assertEqual(response.status_code, requests.codes.ok)
370 res = response.json()
371 self.assertIn('Operation Successful',
372 res["output"]["configuration-response-common"]
373 ["response-message"])
375 # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
376 def test_09_check_interface_ODU4(self):
377 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
378 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
379 "interface/XPDR1-NETWORK1-ODU4"
381 response = test_utils.get_request(url)
382 self.assertEqual(response.status_code, requests.codes.ok)
383 res = response.json()
384 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
385 'administrative-state': 'inService',
386 'supporting-circuit-pack-name': 'CP1-CFP0',
387 'supporting-interface': 'XPDR1-NETWORK1-OTU',
388 'type': 'org-openroadm-interfaces:otnOdu',
389 'supporting-port': 'CP1-CFP0-P1'}
390 # SAPI/DAPI are added in the Otu4 renderer
391 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
392 'rate': 'org-openroadm-otn-common-types:ODU4',
393 'expected-dapi': 'Swfw02qXGyI=',
394 'expected-sapi': 'fuYZwEO660g=',
395 'tx-dapi': 'fuYZwEO660g=',
396 'tx-sapi': 'Swfw02qXGyI='}
398 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
400 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
402 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
404 self.assertDictEqual(
405 {u'payload-type': u'21', u'exp-payload-type': u'21'},
406 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
408 def test_10_check_interface_ODU4(self):
409 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
410 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
411 "interface/XPDR1-NETWORK1-ODU4"
413 response = test_utils.get_request(url)
414 self.assertEqual(response.status_code, requests.codes.ok)
415 res = response.json()
416 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
417 'administrative-state': 'inService',
418 'supporting-circuit-pack-name': 'CP1-CFP0',
419 'supporting-interface': 'XPDR1-NETWORK1-OTU',
420 'type': 'org-openroadm-interfaces:otnOdu',
421 'supporting-port': 'CP1-CFP0-P1'}
422 # SAPI/DAPI are added in the Otu4 renderer
423 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
424 'rate': 'org-openroadm-otn-common-types:ODU4',
425 'tx-sapi': 'fuYZwEO660g=',
426 'tx-dapi': 'Swfw02qXGyI=',
427 'expected-sapi': 'Swfw02qXGyI=',
428 'expected-dapi': 'fuYZwEO660g='
430 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
432 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
434 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
436 self.assertDictEqual(
437 {u'payload-type': u'21', u'exp-payload-type': u'21'},
438 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
440 # Test creation of 10G service
441 def test_11_service_create_10GE(self):
442 url = "{}/operations/transportpce-renderer:service-implementation-request"
445 "transportpce-renderer:input": {
446 "transportpce-renderer:service-name": "SPDRA-SPDRC-10G",
447 "transportpce-renderer:connection-type": "service",
448 "transportpce-renderer:service-handler-header": {
449 "transportpce-renderer:request-id": "abcd12-efgh34"
451 "transportpce-renderer:service-a-end": {
452 "transportpce-renderer:service-format": "Ethernet",
453 "transportpce-renderer:service-rate": "10",
454 "transportpce-renderer:clli": "nodeSA",
455 "transportpce-renderer:node-id": "SPDR-SA1"
457 "transportpce-renderer:service-z-end": {
458 "transportpce-renderer:service-format": "Ethernet",
459 "transportpce-renderer:service-rate": "10",
460 "transportpce-renderer:clli": "nodeSC",
461 "transportpce-renderer:node-id": "SPDR-SC1"
463 "transportpce-renderer:path-description": {
466 "trib-port-number": 1,
467 "trib-slot-number": 1,
472 "tp-node-id": "SPDR-SA1-XPDR1",
473 "tp-id": "XPDR1-CLIENT1"
480 "tp-node-id": "SPDR-SA1-XPDR1",
481 "tp-id": "XPDR1-NETWORK1"
487 "tp-node-id": "SPDR-SC1-XPDR1",
488 "tp-id": "XPDR1-NETWORK1"
494 "tp-node-id": "SPDR-SC1-XPDR1",
495 "tp-id": "XPDR1-CLIENT1"
500 "transportpce-renderer:zToA-direction": {
502 "trib-port-number": 1,
503 "trib-slot-number": 1,
508 "tp-node-id": "SPDR-SC1-XPDR1",
509 "tp-id": "XPDR1-CLIENT1"
515 "tp-node-id": "SPDR-SC1-XPDR1",
516 "tp-id": "XPDR1-NETWORK1"
522 "tp-node-id": "SPDR-SA1-XPDR1",
523 "tp-id": "XPDR1-NETWORK1"
529 "tp-node-id": "SPDR-SA1-XPDR1",
530 "tp-id": "XPDR1-CLIENT1"
540 response = test_utils.post_request(url, data)
542 self.assertEqual(response.status_code, requests.codes.ok)
543 res = response.json()
544 self.assertIn('Operation Successful',
545 res["output"]["configuration-response-common"]
546 ["response-message"])
548 # Test the interfaces on SPDR-A1
549 def test_12_check_interface_10GE_CLIENT(self):
550 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
551 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
552 "interface/XPDR1-CLIENT1-ETHERNET10G"
554 response = test_utils.get_request(url)
555 self.assertEqual(response.status_code, requests.codes.ok)
556 res = response.json()
557 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
558 'administrative-state': 'inService',
559 'supporting-circuit-pack-name': 'CP1-SFP4',
560 'type': 'org-openroadm-interfaces:ethernetCsmacd',
561 'supporting-port': 'CP1-SFP4-P1'
563 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
565 self.assertDictEqual(
567 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
569 def test_13_check_interface_ODU2E_CLIENT(self):
570 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
571 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
572 "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G"
574 response = test_utils.get_request(url)
575 self.assertEqual(response.status_code, requests.codes.ok)
576 res = response.json()
577 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
578 'administrative-state': 'inService',
579 'supporting-circuit-pack-name': 'CP1-SFP4',
580 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
581 'type': 'org-openroadm-interfaces:otnOdu',
582 'supporting-port': 'CP1-SFP4-P1'}
584 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
585 'rate': 'org-openroadm-otn-common-types:ODU2e',
586 'monitoring-mode': 'terminated'}
588 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
590 self.assertDictEqual(dict(input_dict_2,
591 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
592 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
593 self.assertDictEqual(
594 {u'payload-type': u'03', u'exp-payload-type': u'03'},
595 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
597 def test_14_check_ODU2E_connection(self):
598 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
599 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
600 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G"
602 response = test_utils.get_request(url)
603 self.assertEqual(response.status_code, requests.codes.ok)
604 res = response.json()
607 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
608 'direction': 'bidirectional'
611 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
612 res['odu-connection'][0])
613 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
614 res['odu-connection'][0]['destination'])
615 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
616 res['odu-connection'][0]['source'])
618 def test_15_check_interface_ODU2E_NETWORK(self):
619 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
620 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
621 "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G"
623 response = test_utils.get_request(url)
624 self.assertEqual(response.status_code, requests.codes.ok)
625 res = response.json()
626 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
627 'administrative-state': 'inService',
628 'supporting-circuit-pack-name': 'CP1-CFP0',
629 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
630 'type': 'org-openroadm-interfaces:otnOdu',
631 'supporting-port': 'CP1-CFP0-P1'}
633 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
634 'rate': 'org-openroadm-otn-common-types:ODU2e',
635 'monitoring-mode': 'monitored'}
637 input_dict_3 = {'trib-port-number': 1}
639 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
641 self.assertDictEqual(dict(input_dict_2,
642 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
643 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
644 self.assertDictEqual(dict(input_dict_3,
645 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
646 'parent-odu-allocation']),
647 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
648 'parent-odu-allocation'])
651 'org-openroadm-otn-odu-interfaces:odu'][
652 'parent-odu-allocation']['trib-slots'])
654 # Test the interfaces on SPDR-C1
655 def test_16_check_interface_ODU2E_NETWORK(self):
656 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
657 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
658 "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G"
660 response = test_utils.get_request(url)
661 self.assertEqual(response.status_code, requests.codes.ok)
662 res = response.json()
663 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
664 'administrative-state': 'inService',
665 'supporting-circuit-pack-name': 'CP1-CFP0',
666 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
667 'type': 'org-openroadm-interfaces:otnOdu',
668 'supporting-port': 'CP1-CFP0-P1'}
670 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
671 'rate': 'org-openroadm-otn-common-types:ODU2e',
672 'monitoring-mode': 'monitored'}
674 input_dict_3 = {'trib-port-number': 1}
676 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
678 self.assertDictEqual(dict(input_dict_2,
679 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
680 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
681 self.assertDictEqual(dict(input_dict_3,
682 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
683 'parent-odu-allocation']),
684 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
685 'parent-odu-allocation'])
688 'org-openroadm-otn-odu-interfaces:odu'][
689 'parent-odu-allocation']['trib-slots'])
691 def test_17_check_interface_10GE_CLIENT(self):
692 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
693 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
694 "interface/XPDR1-CLIENT1-ETHERNET10G"
696 response = test_utils.get_request(url)
697 self.assertEqual(response.status_code, requests.codes.ok)
698 res = response.json()
699 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
700 'administrative-state': 'inService',
701 'supporting-circuit-pack-name': 'CP1-SFP4',
702 'type': 'org-openroadm-interfaces:ethernetCsmacd',
703 'supporting-port': 'CP1-SFP4-P1'
705 self.assertDictEqual(dict(input_dict, **res['interface'][0]),
707 self.assertDictEqual(
709 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
711 def test_18_check_interface_ODU2E_CLIENT(self):
712 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
713 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
714 "interface/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G"
716 response = test_utils.get_request(url)
717 self.assertEqual(response.status_code, requests.codes.ok)
718 res = response.json()
719 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
720 'administrative-state': 'inService',
721 'supporting-circuit-pack-name': 'CP1-SFP4',
722 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
723 'type': 'org-openroadm-interfaces:otnOdu',
724 'supporting-port': 'CP1-SFP4-P1'}
726 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
727 'rate': 'org-openroadm-otn-common-types:ODU2e',
728 'monitoring-mode': 'terminated'}
730 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
732 self.assertDictEqual(dict(input_dict_2,
733 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
734 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
735 self.assertDictEqual(
736 {u'payload-type': u'03', u'exp-payload-type': u'03'},
737 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
739 def test_19_check_ODU2E_connection(self):
740 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
741 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
742 "odu-connection/XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G"
744 response = test_utils.get_request(url)
745 self.assertEqual(response.status_code, requests.codes.ok)
746 res = response.json()
749 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
750 'direction': 'bidirectional'
753 self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
754 res['odu-connection'][0])
755 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
756 res['odu-connection'][0]['destination'])
757 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
758 res['odu-connection'][0]['source'])
760 def test_20_check_interface_ODU2E_NETWORK(self):
761 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
762 "node/SPDR-SC1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
763 "interface/XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G"
765 response = test_utils.get_request(url)
766 self.assertEqual(response.status_code, requests.codes.ok)
767 res = response.json()
768 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
769 'administrative-state': 'inService',
770 'supporting-circuit-pack-name': 'CP1-CFP0',
771 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
772 'type': 'org-openroadm-interfaces:otnOdu',
773 'supporting-port': 'CP1-CFP0-P1'}
775 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
776 'rate': 'org-openroadm-otn-common-types:ODU2e',
777 'monitoring-mode': 'monitored'}
779 input_dict_3 = {'trib-port-number': 1}
781 self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
783 self.assertDictEqual(dict(input_dict_2,
784 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
785 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
786 self.assertDictEqual(dict(input_dict_3,
787 **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
788 'parent-odu-allocation']),
789 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
790 'parent-odu-allocation'])
793 'org-openroadm-otn-odu-interfaces:odu'][
794 'parent-odu-allocation']['trib-slots'])
796 # TODO: Delete the services (OTU, ODU, LO-ODU)
797 # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
799 def test_21_disconnect_SPDR_SA1(self):
800 response = test_utils.unmount_device("SPDR-SA1")
801 self.assertEqual(response.status_code, requests.codes.ok,
802 test_utils.CODE_SHOULD_BE_200)
804 def test_22_disconnect_SPDR_SC1(self):
805 response = test_utils.unmount_device("SPDR-SC1")
806 self.assertEqual(response.status_code, requests.codes.ok,
807 test_utils.CODE_SHOULD_BE_200)
810 if __name__ == "__main__":
811 unittest.main(verbosity=2)