tests/transportpce_tests/2.2.1/test_renderer_service_path_nominal.py

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