3 #############################################################################
4 # Copyright (c) 2017 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 #############################################################################
21 from unittest.result import failfast
22 from common import test_utils
25 class TransportPCERendererTesting(unittest.TestCase):
31 cls.processes = test_utils.start_tpce()
32 cls.processes = test_utils.start_sims(['xpdra', 'roadma'])
35 def tearDownClass(cls):
36 for process in cls.processes:
37 test_utils.shutdown_process(process)
38 print("all processes killed")
40 def test_01_rdm_device_connected(self):
41 response = test_utils.mount_device("ROADM-A1", 'roadma')
42 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
44 def test_02_xpdr_device_connected(self):
45 response = test_utils.mount_device("XPDR-A1", 'xpdra')
46 self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
48 def test_03_rdm_portmapping(self):
49 url = ("{}/config/transportpce-portmapping:network/"
51 .format(test_utils.RESTCONF_BASE_URL))
52 headers = {'content-type': 'application/json'}
53 response = requests.request(
54 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
55 self.assertEqual(response.status_code, requests.codes.ok)
58 {'supporting-port': 'L1', 'supporting-circuit-pack-name': '1/0',
59 'logical-connection-point': 'DEG1-TTP-TXRX', 'port-direction': 'bidirectional'},
60 res['nodes'][0]['mapping'])
62 {'supporting-port': 'C3', 'supporting-circuit-pack-name': '3/0',
63 'logical-connection-point': 'SRG1-PP3-TXRX', 'port-direction': 'bidirectional'},
64 res['nodes'][0]['mapping'])
66 def test_04_xpdr_portmapping(self):
67 url = ("{}/config/transportpce-portmapping:network/"
69 .format(test_utils.RESTCONF_BASE_URL))
70 headers = {'content-type': 'application/json'}
71 response = requests.request(
72 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
73 self.assertEqual(response.status_code, requests.codes.ok)
76 {'supported-interface-capability': ['org-openroadm-port-types:if-OCH'],
77 'supporting-port': '1', 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
78 'logical-connection-point': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-network',
79 'port-direction': 'bidirectional', 'connection-map-lcp': 'XPDR1-CLIENT1',
80 'lcp-hash-val': '8e128ba57560403cfd4ffafae38cd941'},
81 res['nodes'][0]['mapping'])
83 {'supported-interface-capability': ['org-openroadm-port-types:if-100GE'],
84 'supporting-port': 'C1',
85 'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
86 'logical-connection-point': 'XPDR1-CLIENT1', 'port-direction': 'bidirectional',
87 'connection-map-lcp': 'XPDR1-NETWORK1', 'port-qual': 'xpdr-client',
88 'lcp-hash-val': '3ed8ed1336784ac7c2f66c22f2f03d8'},
89 res['nodes'][0]['mapping'])
91 def test_05_service_path_create(self):
92 url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
93 data = {"renderer:input": {
94 "renderer:service-name": "service_test",
95 "renderer:wave-number": "7",
96 "renderer:modulation-format": "qpsk",
97 "renderer:operation": "create",
99 {"renderer:node-id": "ROADM-A1",
100 "renderer:src-tp": "SRG1-PP3-TXRX",
101 "renderer:dest-tp": "DEG1-TTP-TXRX"},
102 {"renderer:node-id": "XPDR-A1",
103 "renderer:src-tp": "XPDR1-CLIENT1",
104 "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
105 headers = {'content-type': 'application/json'}
106 response = requests.request(
107 "POST", url, data=json.dumps(data),
108 headers=headers, 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: ROADM-A1', res["output"]["result"])
113 def test_06_service_path_create_rdm_check(self):
114 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
115 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
116 "interface/DEG1-TTP-TXRX-nmc-7"
117 .format(test_utils.RESTCONF_BASE_URL))
118 headers = {'content-type': 'application/json'}
119 response = requests.request(
120 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
121 self.assertEqual(response.status_code, requests.codes.ok)
122 res = response.json()
123 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
124 self.assertDictEqual(
126 'name': 'DEG1-TTP-TXRX-nmc-7',
127 'administrative-state': 'inService',
128 'supporting-circuit-pack-name': '1/0',
129 'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
130 'supporting-port': 'L1'
131 }, **res['interface'][0]),
134 self.assertDictEqual(
135 {u'frequency': 195.8, u'width': 40},
136 res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
138 def test_07_service_path_create_rdm_check(self):
139 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
140 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
141 "interface/DEG1-TTP-TXRX-mc-7"
142 .format(test_utils.RESTCONF_BASE_URL))
143 headers = {'content-type': 'application/json'}
144 response = requests.request(
145 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
146 self.assertEqual(response.status_code, requests.codes.ok)
147 res = response.json()
148 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
149 self.assertDictEqual(
151 'name': 'DEG1-TTP-TXRX-mc-7',
152 'administrative-state': 'inService',
153 'supporting-circuit-pack-name': '1/0',
154 'type': 'org-openroadm-interfaces:mediaChannelTrailTerminationPoint',
155 'supporting-port': 'L1'
156 }, **res['interface'][0]),
159 self.assertDictEqual(
160 {u'min-freq': 195.775, u'max-freq': 195.825},
161 res['interface'][0]['org-openroadm-media-channel-interfaces:mc-ttp'])
163 def test_08_service_path_create_rdm_check(self):
164 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
165 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
166 "interface/SRG1-PP3-TXRX-nmc-7"
167 .format(test_utils.RESTCONF_BASE_URL))
168 headers = {'content-type': 'application/json'}
169 response = requests.request(
170 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
171 self.assertEqual(response.status_code, requests.codes.ok)
172 res = response.json()
173 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
174 self.assertDictEqual(
176 'name': 'SRG1-PP3-TXRX-nmc-7',
177 'administrative-state': 'inService',
178 'supporting-circuit-pack-name': '3/0',
179 'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
180 'supporting-port': 'C3'
181 }, **res['interface'][0]),
184 self.assertDictEqual(
185 {u'frequency': 195.8, u'width': 40},
186 res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
188 # -mc supporting interfaces must not be created for SRG, only degrees
189 def test_09_service_path_create_rdm_check(self):
190 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
191 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
192 "interface/SRG1-PP3-TXRX-mc-7"
193 .format(test_utils.RESTCONF_BASE_URL))
194 headers = {'content-type': 'application/json'}
195 response = requests.request(
196 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
197 self.assertEqual(response.status_code, requests.codes.not_found)
198 res = response.json()
200 {"error-type": "application", "error-tag": "data-missing",
201 "error-message": "Request could not be completed because the relevant data model content does not exist"},
202 res['errors']['error'])
204 def test_10_service_path_create_rdm_check(self):
205 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
206 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
207 "roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7"
208 .format(test_utils.RESTCONF_BASE_URL))
209 headers = {'content-type': 'application/json'}
210 response = requests.request(
211 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
212 self.assertEqual(response.status_code, requests.codes.ok)
213 res = response.json()
214 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
215 self.assertDictEqual(
217 'connection-name': 'SRG1-PP3-TXRX-DEG1-TTP-TXRX-7',
218 'opticalControlMode': 'off'
219 }, **res['roadm-connections'][0]),
220 res['roadm-connections'][0]
222 self.assertDictEqual(
223 {'src-if': 'SRG1-PP3-TXRX-nmc-7'},
224 res['roadm-connections'][0]['source'])
225 self.assertDictEqual(
226 {'dst-if': 'DEG1-TTP-TXRX-nmc-7'},
227 res['roadm-connections'][0]['destination'])
229 def test_11_service_path_create_xpdr_check(self):
230 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
231 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
232 "interface/XPDR1-NETWORK1-7"
233 .format(test_utils.RESTCONF_BASE_URL))
234 headers = {'content-type': 'application/json'}
235 response = requests.request(
236 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
237 self.assertEqual(response.status_code, requests.codes.ok)
238 res = response.json()
239 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
240 self.assertDictEqual(
242 'name': 'XPDR1-NETWORK1-7',
243 'administrative-state': 'inService',
244 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
245 'type': 'org-openroadm-interfaces:opticalChannel',
246 'supporting-port': '1'
247 }, **res['interface'][0]),
250 self.assertDictEqual(
251 {u'rate': u'org-openroadm-common-types:R100G',
252 u'transmit-power': -5,
253 u'frequency': 195.8},
254 res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
256 def test_12_service_path_create_xpdr_check(self):
257 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
258 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
259 "interface/XPDR1-NETWORK1-OTU"
260 .format(test_utils.RESTCONF_BASE_URL))
261 headers = {'content-type': 'application/json'}
262 response = requests.request(
263 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
264 self.assertEqual(response.status_code, requests.codes.ok)
265 res = response.json()
266 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
267 self.assertDictEqual(
269 'name': 'XPDR1-NETWORK1-OTU',
270 'administrative-state': 'inService',
271 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
272 'type': 'org-openroadm-interfaces:otnOtu',
273 'supporting-port': '1',
274 'supporting-interface': 'XPDR1-NETWORK1-7'
275 }, **res['interface'][0]),
278 self.assertDictEqual(
279 {u'rate': u'org-openroadm-otn-common-types:OTU4',
281 res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
283 def test_13_service_path_create_xpdr_check(self):
284 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
285 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
286 "interface/XPDR1-NETWORK1-ODU"
287 .format(test_utils.RESTCONF_BASE_URL))
288 headers = {'content-type': 'application/json'}
289 response = requests.request(
290 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
291 self.assertEqual(response.status_code, requests.codes.ok)
292 res = response.json()
293 # the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
294 self.assertDictEqual(
296 'name': 'XPDR1-NETWORK1-ODU',
297 'administrative-state': 'inService',
298 'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
299 'type': 'org-openroadm-interfaces:otnOdu',
300 'supporting-port': '1',
301 'supporting-interface': 'XPDR1-NETWORK1-OTU'
302 }, **res['interface'][0]),
305 self.assertDictEqual(
307 'rate': 'org-openroadm-otn-common-types:ODU4',
308 u'monitoring-mode': u'terminated'
309 }, **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
310 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
312 self.assertDictEqual({u'exp-payload-type': u'07', u'payload-type': u'07'},
313 res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
315 def test_14_service_path_create_xpdr_check(self):
316 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
317 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
318 "interface/XPDR1-CLIENT1-ETHERNET"
319 .format(test_utils.RESTCONF_BASE_URL))
320 headers = {'content-type': 'application/json'}
321 response = requests.request(
322 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
323 self.assertEqual(response.status_code, requests.codes.ok)
324 res = response.json()
325 # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
326 self.assertDictEqual(
328 'name': 'XPDR1-CLIENT1-ETHERNET',
329 'administrative-state': 'inService',
330 'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
331 'type': 'org-openroadm-interfaces:ethernetCsmacd',
332 'supporting-port': 'C1'
333 }, **res['interface'][0]),
336 self.assertDictEqual(
337 {u'fec': u'off', u'speed': 100000},
338 res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
340 def test_15_service_path_create_xpdr_check(self):
341 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
342 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
343 "circuit-packs/1%2F0%2F1-PLUG-NET"
344 .format(test_utils.RESTCONF_BASE_URL))
345 headers = {'content-type': 'application/json'}
346 response = requests.request(
347 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
348 self.assertEqual(response.status_code, requests.codes.ok)
349 res = response.json()
350 self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
352 def test_16_service_path_create_xpdr_check(self):
353 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
354 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
355 "circuit-packs/1%2F0%2F1-PLUG-CLIENT"
356 .format(test_utils.RESTCONF_BASE_URL))
357 headers = {'content-type': 'application/json'}
358 response = requests.request(
359 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
360 self.assertEqual(response.status_code, requests.codes.ok)
361 res = response.json()
362 self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
364 def test_17_service_path_delete(self):
365 url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
366 data = {"renderer:input": {
367 "renderer:service-name": "service_test",
368 "renderer:wave-number": "7",
369 "renderer:operation": "delete",
371 {"renderer:node-id": "ROADM-A1",
372 "renderer:src-tp": "SRG1-PP3-TXRX",
373 "renderer:dest-tp": "DEG1-TTP-TXRX"},
374 {"renderer:node-id": "XPDR-A1",
375 "renderer:src-tp": "XPDR1-CLIENT1",
376 "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
377 headers = {'content-type': 'application/json'}
378 response = requests.request(
379 "POST", url, data=json.dumps(data),
380 headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
381 self.assertEqual(response.status_code, requests.codes.ok)
382 self.assertEqual(response.json(), {
383 'output': {'result': 'Request processed', 'success': True}})
385 def test_18_service_path_delete_rdm_check(self):
386 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
387 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
388 "interface/DEG1-TTP-TXRX-mc-7"
389 .format(test_utils.RESTCONF_BASE_URL))
390 headers = {'content-type': 'application/json'}
391 response = requests.request(
392 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
393 self.assertEqual(response.status_code, requests.codes.not_found)
394 res = response.json()
396 {"error-type": "application", "error-tag": "data-missing",
397 "error-message": "Request could not be completed because the relevant data model content does not exist"},
398 res['errors']['error'])
400 def test_19_service_path_delete_rdm_check(self):
401 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
402 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
403 "interface/DEG1-TTP-TXRX-nmc-7"
404 .format(test_utils.RESTCONF_BASE_URL))
405 headers = {'content-type': 'application/json'}
406 response = requests.request(
407 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
408 self.assertEqual(response.status_code, requests.codes.not_found)
409 res = response.json()
411 {"error-type": "application", "error-tag": "data-missing",
412 "error-message": "Request could not be completed because the relevant data model content does not exist"},
413 res['errors']['error'])
415 def test_20_service_path_delete_rdm_check(self):
416 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
417 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
418 "interface/SRG1-PP3-TXRX-mc-7"
419 .format(test_utils.RESTCONF_BASE_URL))
420 headers = {'content-type': 'application/json'}
421 response = requests.request(
422 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
423 self.assertEqual(response.status_code, requests.codes.not_found)
424 res = response.json()
426 {"error-type": "application", "error-tag": "data-missing",
427 "error-message": "Request could not be completed because the relevant data model content does not exist"},
428 res['errors']['error'])
430 def test_21_service_path_delete_rdm_check(self):
431 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
432 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
433 "interface/SRG1-PP3-TXRX-nmc-7"
434 .format(test_utils.RESTCONF_BASE_URL))
435 headers = {'content-type': 'application/json'}
436 response = requests.request(
437 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
438 self.assertEqual(response.status_code, requests.codes.not_found)
439 res = response.json()
441 {"error-type": "application", "error-tag": "data-missing",
442 "error-message": "Request could not be completed because the relevant data model content does not exist"},
443 res['errors']['error'])
445 def test_22_service_path_delete_rdm_check(self):
446 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
447 "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
448 "roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7"
449 .format(test_utils.RESTCONF_BASE_URL))
450 headers = {'content-type': 'application/json'}
451 response = requests.request(
452 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
453 self.assertEqual(response.status_code, requests.codes.not_found)
454 res = response.json()
456 {"error-type": "application", "error-tag": "data-missing",
457 "error-message": "Request could not be completed because the relevant data model content does not exist"},
458 res['errors']['error'])
460 def test_23_service_path_delete_xpdr_check(self):
461 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
462 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
463 "interface/XPDR1-NETWORK1-7"
464 .format(test_utils.RESTCONF_BASE_URL))
465 headers = {'content-type': 'application/json'}
466 response = requests.request(
467 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
468 self.assertEqual(response.status_code, requests.codes.not_found)
469 res = response.json()
471 {"error-type": "application", "error-tag": "data-missing",
472 "error-message": "Request could not be completed because the relevant data model content does not exist"},
473 res['errors']['error'])
475 def test_24_service_path_delete_xpdr_check(self):
476 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
477 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
478 "interface/XPDR1-NETWORK1-OTU"
479 .format(test_utils.RESTCONF_BASE_URL))
480 headers = {'content-type': 'application/json'}
481 response = requests.request(
482 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
483 self.assertEqual(response.status_code, requests.codes.not_found)
484 res = response.json()
486 {"error-type": "application", "error-tag": "data-missing",
487 "error-message": "Request could not be completed because the relevant data model content does not exist"},
488 res['errors']['error'])
490 def test_25_service_path_delete_xpdr_check(self):
491 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
492 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
493 "interface/XPDR1-NETWORK1-ODU"
494 .format(test_utils.RESTCONF_BASE_URL))
495 headers = {'content-type': 'application/json'}
496 response = requests.request(
497 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
498 self.assertEqual(response.status_code, requests.codes.not_found)
499 res = response.json()
501 {"error-type": "application", "error-tag": "data-missing",
502 "error-message": "Request could not be completed because the relevant data model content does not exist"},
503 res['errors']['error'])
505 def test_26_service_path_delete_xpdr_check(self):
506 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
507 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
508 "interface/XPDR1-CLIENT1-ETHERNET"
509 .format(test_utils.RESTCONF_BASE_URL))
510 headers = {'content-type': 'application/json'}
511 response = requests.request(
512 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
513 self.assertEqual(response.status_code, requests.codes.not_found)
514 res = response.json()
516 {"error-type": "application", "error-tag": "data-missing",
517 "error-message": "Request could not be completed because the relevant data model content does not exist"},
518 res['errors']['error'])
520 def test_27_service_path_delete_xpdr_check(self):
521 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
522 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
523 "circuit-packs/1%2F0%2F1-PLUG-NET"
524 .format(test_utils.RESTCONF_BASE_URL))
525 headers = {'content-type': 'application/json'}
526 response = requests.request(
527 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
528 self.assertEqual(response.status_code, requests.codes.ok)
529 res = response.json()
530 self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
532 def test_28_service_path_delete_xpdr_check(self):
533 url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
534 "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
535 "circuit-packs/1%2F0%2F1-PLUG-CLIENT"
536 .format(test_utils.RESTCONF_BASE_URL))
537 headers = {'content-type': 'application/json'}
538 response = requests.request(
539 "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
540 self.assertEqual(response.status_code, requests.codes.ok)
541 res = response.json()
542 self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
544 def test_29_rdm_device_disconnected(self):
545 response = test_utils.unmount_device("ROADM-A1")
546 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
548 def test_30_xpdr_device_disconnected(self):
549 response = test_utils.unmount_device("XPDR-A1")
550 self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
553 if __name__ == "__main__":
554 unittest.main(verbosity=2, failfast=True)