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 ##############################################################################
16 from common import test_utils
19 class TransportPCEtesting(unittest.TestCase):
25 cls.processes = test_utils.start_tpce()
26 cls.processes = test_utils.start_sims(['spdrav2'])
29 def tearDownClass(cls):
30 for process in cls.processes:
31 test_utils.shutdown_process(process)
32 print("all processes killed")
37 def test_01_connect_SPDR_SA1(self):
38 response = test_utils.mount_device("SPDR-SA1", 'spdrav2')
39 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
42 url = ("{}/operational/network-topology:"
43 "network-topology/topology/topology-netconf/node/SPDR-SA1"
44 .format(test_utils.RESTCONF_BASE_URL))
45 response = requests.request(
46 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
47 self.assertEqual(response.status_code, requests.codes.ok)
50 res['node'][0]['netconf-node-topology:connection-status'],
53 def test_02_get_portmapping_CLIENT1(self):
54 url = ("{}/config/transportpce-portmapping:network/"
55 "nodes/SPDR-SA1/mapping/XPDR1-CLIENT1"
56 .format(test_utils.RESTCONF_BASE_URL))
57 response = requests.request(
58 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
59 self.assertEqual(response.status_code, requests.codes.ok)
62 {'supported-interface-capability': [
63 'org-openroadm-port-types:if-10GE-ODU2e',
64 'org-openroadm-port-types:if-10GE-ODU2',
65 'org-openroadm-port-types:if-10GE'],
66 'supporting-port': 'CP1-SFP4-P1',
67 'supporting-circuit-pack-name': 'CP1-SFP4',
68 'logical-connection-point': 'XPDR1-CLIENT1',
69 'port-direction': 'bidirectional',
70 'port-qual': 'xpdr-client',
71 'lcp-hash-val': 'FqlcrxV7p30='},
74 def test_03_get_portmapping_NETWORK1(self):
75 url = ("{}/config/transportpce-portmapping:network/"
76 "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
77 .format(test_utils.RESTCONF_BASE_URL))
78 response = requests.request(
79 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
80 self.assertEqual(response.status_code, requests.codes.ok)
83 {"logical-connection-point": "XPDR1-NETWORK1",
84 "supporting-port": "CP1-CFP0-P1",
85 "supported-interface-capability": [
86 "org-openroadm-port-types:if-OCH-OTU4-ODU4"
88 "port-direction": "bidirectional",
89 "port-qual": "xpdr-network",
90 "supporting-circuit-pack-name": "CP1-CFP0",
91 "xponder-type": "mpdr",
92 'lcp-hash-val': 'Swfw02qXGyI='},
95 def test_04_service_path_create_OCH_OTU4(self):
96 url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
97 data = {"renderer:input": {
98 "service-name": "service_ODU4",
100 "modulation-format": "qpsk",
101 "operation": "create",
103 {"node-id": "SPDR-SA1",
104 "dest-tp": "XPDR1-NETWORK1"}]}}
105 response = requests.request(
106 "POST", url, data=json.dumps(data),
107 headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
109 self.assertEqual(response.status_code, requests.codes.ok)
110 res = response.json()
111 self.assertIn('Roadm-connection successfully created for nodes: ', res["output"]["result"])
112 self.assertTrue(res["output"]["success"])
114 {'node-id': 'SPDR-SA1',
115 'otu-interface-id': ['XPDR1-NETWORK1-OTU'],
116 'och-interface-id': ['XPDR1-NETWORK1-1']}, res["output"]['node-interface'])
118 def test_05_get_portmapping_NETWORK1(self):
119 url = ("{}/config/transportpce-portmapping:network/"
120 "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
121 .format(test_utils.RESTCONF_BASE_URL))
122 response = requests.request(
123 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
124 self.assertEqual(response.status_code, requests.codes.ok)
125 res = response.json()
127 {"logical-connection-point": "XPDR1-NETWORK1",
128 "supporting-port": "CP1-CFP0-P1",
129 "supported-interface-capability": [
130 "org-openroadm-port-types:if-OCH-OTU4-ODU4"
132 "port-direction": "bidirectional",
133 "port-qual": "xpdr-network",
134 "supporting-circuit-pack-name": "CP1-CFP0",
135 "xponder-type": "mpdr",
136 "lcp-hash-val": "Swfw02qXGyI="},
139 def test_06_check_interface_och(self):
140 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
141 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
142 "interface/XPDR1-NETWORK1-1"
143 .format(test_utils.RESTCONF_BASE_URL))
144 response = requests.request(
145 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
146 self.assertEqual(response.status_code, requests.codes.ok)
147 res = response.json()
149 self.assertDictEqual(dict(res['interface'][0], **{'name': 'XPDR1-NETWORK1-1',
150 'administrative-state': 'inService',
151 'supporting-circuit-pack-name': 'CP1-CFP0',
152 'type': 'org-openroadm-interfaces:opticalChannel',
153 'supporting-port': 'CP1-CFP0-P1'
157 self.assertDictEqual(
158 {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
159 u'transmit-power': -5},
160 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
162 def test_07_check_interface_OTU(self):
163 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
164 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
165 "interface/XPDR1-NETWORK1-OTU"
166 .format(test_utils.RESTCONF_BASE_URL))
167 response = requests.request(
168 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
169 self.assertEqual(response.status_code, requests.codes.ok)
170 res = response.json()
171 input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
172 'administrative-state': 'inService',
173 'supporting-circuit-pack-name': 'CP1-CFP0',
174 'supporting-interface': 'XPDR1-NETWORK1-1',
175 'type': 'org-openroadm-interfaces:otnOtu',
176 'supporting-port': 'CP1-CFP0-P1'
179 input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
180 'expected-sapi': 'Swfw02qXGyI=',
181 'tx-sapi': 'Swfw02qXGyI=',
182 'expected-dapi': 'Swfw02qXGyI=',
183 'rate': 'org-openroadm-otn-common-types:OTU4',
187 self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
190 self.assertDictEqual(input_dict_2,
191 res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
193 def test_08_otn_service_path_create_ODU4(self):
194 url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
195 data = {"renderer:input": {
196 "service-name": "service_ODU4",
197 "operation": "create",
198 "service-rate": "100G",
199 "service-type": "ODU",
201 {"node-id": "SPDR-SA1",
202 "network-tp": "XPDR1-NETWORK1"}]}}
203 response = requests.request(
204 "POST", url, data=json.dumps(data),
205 headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
207 self.assertEqual(response.status_code, requests.codes.ok)
208 res = response.json()
209 self.assertIn('Otn Service path was set up successfully for node :SPDR-SA1', res["output"]["result"])
210 self.assertTrue(res["output"]["success"])
212 {'node-id': 'SPDR-SA1',
213 'odu-interface-id': ['XPDR1-NETWORK1-ODU4']}, res["output"]['node-interface'])
215 def test_09_get_portmapping_NETWORK1(self):
216 url = ("{}/config/transportpce-portmapping:network/"
217 "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
218 .format(test_utils.RESTCONF_BASE_URL))
219 response = requests.request(
220 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
221 self.assertEqual(response.status_code, requests.codes.ok)
222 res = response.json()
224 {"logical-connection-point": "XPDR1-NETWORK1",
225 "supporting-port": "CP1-CFP0-P1",
226 "supported-interface-capability": [
227 "org-openroadm-port-types:if-OCH-OTU4-ODU4"
229 "port-direction": "bidirectional",
230 "port-qual": "xpdr-network",
231 "supporting-circuit-pack-name": "CP1-CFP0",
232 "xponder-type": "mpdr",
233 "supporting-odu4": "XPDR1-NETWORK1-ODU4",
234 "lcp-hash-val": "Swfw02qXGyI="
238 def test_10_check_interface_ODU4(self):
239 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
240 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
241 "interface/XPDR1-NETWORK1-ODU4"
242 .format(test_utils.RESTCONF_BASE_URL))
243 response = requests.request(
244 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
245 self.assertEqual(response.status_code, requests.codes.ok)
246 res = response.json()
247 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService',
248 'supporting-circuit-pack-name': 'CP1-CFP0', 'supporting-interface': 'XPDR1-NETWORK1-OTU',
249 'type': 'org-openroadm-interfaces:otnOdu',
250 'supporting-port': 'CP1-CFP0-P1'}
251 input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
252 'rate': 'org-openroadm-otn-common-types:ODU4',
253 'expected-dapi': 'Swfw02qXGyI=',
254 'expected-sapi': 'Swfw02qXGyI=',
255 'tx-dapi': 'Swfw02qXGyI=',
256 'tx-sapi': 'Swfw02qXGyI='}
258 self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
260 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
263 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
265 self.assertDictEqual(
266 {u'payload-type': u'21', u'exp-payload-type': u'21'},
267 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
269 def test_11_otn_service_path_create_10GE(self):
270 url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
271 data = {"renderer:input": {
272 "service-name": "service1",
273 "operation": "create",
274 "service-rate": "10G",
275 "service-type": "Ethernet",
276 "ethernet-encoding": "eth encode",
278 "trib-port-number": "1",
280 {"node-id": "SPDR-SA1",
281 "client-tp": "XPDR1-CLIENT1",
282 "network-tp": "XPDR1-NETWORK1"}]}}
283 response = requests.request(
284 "POST", url, data=json.dumps(data),
285 headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
287 self.assertEqual(response.status_code, requests.codes.ok)
288 res = response.json()
289 self.assertIn('Otn Service path was set up successfully for node :SPDR-SA1', res["output"]["result"])
290 self.assertTrue(res["output"]["success"])
292 {'node-id': 'SPDR-SA1',
293 'connection-id': ['XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1'],
294 'odu-interface-id': ['XPDR1-NETWORK1-ODU2e-service1', 'XPDR1-CLIENT1-ODU2e-service1'],
295 'eth-interface-id': ['XPDR1-CLIENT1-ETHERNET10G']}, res["output"]['node-interface'])
297 def test_12_check_interface_10GE_CLIENT(self):
298 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
299 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
300 "interface/XPDR1-CLIENT1-ETHERNET10G"
301 .format(test_utils.RESTCONF_BASE_URL))
302 response = requests.request(
303 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
304 self.assertEqual(response.status_code, requests.codes.ok)
305 res = response.json()
306 input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
307 'administrative-state': 'inService',
308 'supporting-circuit-pack-name': 'CP1-SFP4',
309 'type': 'org-openroadm-interfaces:ethernetCsmacd',
310 'supporting-port': 'CP1-SFP4-P1'
312 self.assertDictEqual(dict(res['interface'][0], **input_dict),
314 self.assertDictEqual(
316 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
318 def test_13_check_interface_ODU2E_CLIENT(self):
319 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
320 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
321 "interface/XPDR1-CLIENT1-ODU2e-service1"
322 .format(test_utils.RESTCONF_BASE_URL))
323 response = requests.request(
324 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
325 self.assertEqual(response.status_code, requests.codes.ok)
326 res = response.json()
328 input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1',
329 'administrative-state': 'inService',
330 'supporting-circuit-pack-name': 'CP1-SFP4',
331 'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
332 'type': 'org-openroadm-interfaces:otnOdu',
333 'supporting-port': 'CP1-SFP4-P1'}
335 'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
336 'rate': 'org-openroadm-otn-common-types:ODU2e',
337 'monitoring-mode': 'terminated'}
339 self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
341 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
343 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
344 self.assertDictEqual(
345 {u'payload-type': u'03', u'exp-payload-type': u'03'},
346 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
348 def test_14_check_interface_ODU2E_NETWORK(self):
349 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
350 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
351 "interface/XPDR1-NETWORK1-ODU2e-service1"
352 .format(test_utils.RESTCONF_BASE_URL))
353 response = requests.request(
354 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
355 self.assertEqual(response.status_code, requests.codes.ok)
356 res = response.json()
357 input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1', 'administrative-state': 'inService',
358 'supporting-circuit-pack-name': 'CP1-CFP0',
359 'supporting-interface': 'XPDR1-NETWORK1-ODU4',
360 'type': 'org-openroadm-interfaces:otnOdu',
361 'supporting-port': 'CP1-CFP0-P1'}
363 'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
364 'rate': 'org-openroadm-otn-common-types:ODU2e',
365 'monitoring-mode': 'monitored'}
367 input_dict_3 = {'trib-port-number': 1}
369 self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
371 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
373 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
374 self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
375 'parent-odu-allocation'], **input_dict_3
377 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
378 'parent-odu-allocation'])
381 'org-openroadm-otn-odu-interfaces:odu'][
382 'parent-odu-allocation']['trib-slots'])
384 def test_15_check_ODU2E_connection(self):
385 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
386 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
387 "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
388 .format(test_utils.RESTCONF_BASE_URL))
389 response = requests.request(
390 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
391 self.assertEqual(response.status_code, requests.codes.ok)
392 res = response.json()
395 'XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1',
396 'direction': 'bidirectional'
399 self.assertDictEqual(dict(res['odu-connection'][0], **input_dict_1),
400 res['odu-connection'][0])
401 self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1'},
402 res['odu-connection'][0]['destination'])
403 self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1'},
404 res['odu-connection'][0]['source'])
406 def test_16_otn_service_path_delete_10GE(self):
407 url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
408 data = {"renderer:input": {
409 "service-name": "service1",
410 "operation": "delete",
411 "service-rate": "10G",
412 "service-type": "Ethernet",
413 "ethernet-encoding": "eth encode",
415 "trib-port-number": "1",
417 {"node-id": "SPDR-SA1",
418 "client-tp": "XPDR1-CLIENT1",
419 "network-tp": "XPDR1-NETWORK1"}]}}
420 response = requests.request(
421 "POST", url, data=json.dumps(data),
422 headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
424 self.assertEqual(response.status_code, requests.codes.ok)
425 res = response.json()
426 self.assertIn('Request processed', res["output"]["result"])
427 self.assertTrue(res["output"]["success"])
429 def test_17_check_no_ODU2E_connection(self):
430 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
431 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
432 "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
433 .format(test_utils.RESTCONF_BASE_URL))
434 response = requests.request(
435 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
436 self.assertEqual(response.status_code, requests.codes.not_found)
438 def test_18_check_no_interface_ODU2E_NETWORK(self):
439 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
440 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
441 "interface/XPDR1-NETWORK1-ODU2e-service1"
442 .format(test_utils.RESTCONF_BASE_URL))
443 response = requests.request(
444 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
445 self.assertEqual(response.status_code, requests.codes.not_found)
447 def test_19_check_no_interface_ODU2E_CLIENT(self):
448 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
449 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
450 "interface/XPDR1-CLIENT1-ODU2e-service1"
451 .format(test_utils.RESTCONF_BASE_URL))
452 response = requests.request(
453 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
454 self.assertEqual(response.status_code, requests.codes.not_found)
456 def test_20_check_no_interface_10GE_CLIENT(self):
457 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
458 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
459 "interface/XPDR1-CLIENT1-ETHERNET10G"
460 .format(test_utils.RESTCONF_BASE_URL))
461 response = requests.request(
462 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
463 self.assertEqual(response.status_code, requests.codes.not_found)
465 def test_21_otn_service_path_delete_ODU4(self):
466 url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
467 data = {"renderer:input": {
468 "service-name": "service_ODU4",
469 "operation": "delete",
470 "service-rate": "100G",
471 "service-type": "ODU",
473 {"node-id": "SPDR-SA1",
474 "network-tp": "XPDR1-NETWORK1"}]}}
475 response = requests.request(
476 "POST", url, data=json.dumps(data),
477 headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
479 self.assertEqual(response.status_code, requests.codes.ok)
480 res = response.json()
481 self.assertIn('Request processed', res["output"]["result"])
482 self.assertTrue(res["output"]["success"])
484 def test_22_check_no_interface_ODU4(self):
485 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
486 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
487 "interface/XPDR1-NETWORK1-ODU4"
488 .format(test_utils.RESTCONF_BASE_URL))
489 response = requests.request(
490 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
491 self.assertEqual(response.status_code, requests.codes.not_found)
493 def test_23_service_path_delete_OCH_OTU4(self):
494 url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
495 data = {"renderer:input": {
496 "service-name": "service_OTU4",
498 "modulation-format": "qpsk",
499 "operation": "delete",
501 {"node-id": "SPDR-SA1",
502 "dest-tp": "XPDR1-NETWORK1"}]}}
503 response = requests.request(
504 "POST", url, data=json.dumps(data),
505 headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
507 self.assertEqual(response.status_code, requests.codes.ok)
508 res = response.json()
509 self.assertIn('Request processed', res["output"]["result"])
510 self.assertTrue(res["output"]["success"])
512 def test_24_check_no_interface_OTU4(self):
513 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
514 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
515 "interface/XPDR1-NETWORK1-OTU"
516 .format(test_utils.RESTCONF_BASE_URL))
517 response = requests.request(
518 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
519 self.assertEqual(response.status_code, requests.codes.not_found)
521 def test_25_check_no_interface_OCH(self):
522 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
523 "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
524 "interface/XPDR1-NETWORK1-1"
525 .format(test_utils.RESTCONF_BASE_URL))
526 response = requests.request(
527 "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
528 self.assertEqual(response.status_code, requests.codes.not_found)
530 def test_26_disconnect_SPDR_SA1(self):
531 response = test_utils.unmount_device("SPDR-SA1")
532 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
535 if __name__ == "__main__":
536 unittest.main(verbosity=2)