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': 'AMkDwQ7xTmRI'},
  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': 'AJUUr6I5fALj'},
  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         input_dict_2 = {'tx-sapi': 'AMkDwQ7xTmRI',
 273                         'expected-dapi': 'AMkDwQ7xTmRI',
 274                         'rate': 'org-openroadm-otn-common-types:OTU4',
 275                         'fec': 'scfec'}
 276         self.assertDictEqual(input_dict_2,
 277             res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 278
 279     def test_13_service_path_create_xpdr_check(self):
 280         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 281                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 282                "interface/XPDR1-NETWORK1-ODU"
 283                .format(test_utils.RESTCONF_BASE_URL))
 284         headers = {'content-type': 'application/json'}
 285         response = requests.request(
 286             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 287         self.assertEqual(response.status_code, requests.codes.ok)
 288         res = response.json()
 289         # the 2 following statements replace self.assertDictContainsSubset deprecated in python 3.2
 290         self.assertDictEqual(
 291             dict({
 292                  'name': 'XPDR1-NETWORK1-ODU',
 293                  'administrative-state': 'inService',
 294                  'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
 295                  'type': 'org-openroadm-interfaces:otnOdu',
 296                  'supporting-port': '1',
 297                  'supporting-interface': 'XPDR1-NETWORK1-OTU'
 298                  }, **res['interface'][0]),
 299             res['interface'][0]
 300         )
 301         self.assertDictEqual(
 302             dict({
 303                  'rate': 'org-openroadm-otn-common-types:ODU4',
 304                  u'monitoring-mode': u'terminated'
 305                  }, **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 306             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 307         )
 308         self.assertDictEqual({u'exp-payload-type': u'07', u'payload-type': u'07'},
 309                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 310
 311     def test_14_service_path_create_xpdr_check(self):
 312         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 313                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 314                "interface/XPDR1-CLIENT1-ETHERNET"
 315                .format(test_utils.RESTCONF_BASE_URL))
 316         headers = {'content-type': 'application/json'}
 317         response = requests.request(
 318             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 319         self.assertEqual(response.status_code, requests.codes.ok)
 320         res = response.json()
 321         # the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
 322         self.assertDictEqual(
 323             dict({
 324                  'name': 'XPDR1-CLIENT1-ETHERNET',
 325                  'administrative-state': 'inService',
 326                  'supporting-circuit-pack-name': '1/0/1-PLUG-CLIENT',
 327                  'type': 'org-openroadm-interfaces:ethernetCsmacd',
 328                  'supporting-port': 'C1'
 329                  }, **res['interface'][0]),
 330             res['interface'][0]
 331         )
 332         self.assertDictEqual(
 333             {u'fec': u'off', u'speed': 100000},
 334             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 335
 336     def test_15_service_path_create_xpdr_check(self):
 337         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 338                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 339                "circuit-packs/1%2F0%2F1-PLUG-NET"
 340                .format(test_utils.RESTCONF_BASE_URL))
 341         headers = {'content-type': 'application/json'}
 342         response = requests.request(
 343             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 344         self.assertEqual(response.status_code, requests.codes.ok)
 345         res = response.json()
 346         self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
 347
 348     def test_16_service_path_create_xpdr_check(self):
 349         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 350                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 351                "circuit-packs/1%2F0%2F1-PLUG-CLIENT"
 352                .format(test_utils.RESTCONF_BASE_URL))
 353         headers = {'content-type': 'application/json'}
 354         response = requests.request(
 355             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 356         self.assertEqual(response.status_code, requests.codes.ok)
 357         res = response.json()
 358         self.assertIn('not-reserved-inuse', res['circuit-packs'][0]["equipment-state"])
 359
 360     def test_17_service_path_delete(self):
 361         url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
 362         data = {"renderer:input": {
 363             "renderer:service-name": "service_test",
 364             "renderer:wave-number": "7",
 365             "renderer:operation": "delete",
 366             "renderer:nodes": [
 367                 {"renderer:node-id": "ROADM-A1",
 368                  "renderer:src-tp": "SRG1-PP3-TXRX",
 369                  "renderer:dest-tp": "DEG1-TTP-TXRX"},
 370                 {"renderer:node-id": "XPDR-A1",
 371                  "renderer:src-tp": "XPDR1-CLIENT1",
 372                  "renderer:dest-tp": "XPDR1-NETWORK1"}]}}
 373         headers = {'content-type': 'application/json'}
 374         response = requests.request(
 375             "POST", url, data=json.dumps(data),
 376             headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 377         self.assertEqual(response.status_code, requests.codes.ok)
 378         self.assertEqual(response.json(), {
 379             'output': {'result': 'Request processed', 'success': True}})
 380
 381     def test_18_service_path_delete_rdm_check(self):
 382         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 383                "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 384                "interface/DEG1-TTP-TXRX-mc-7"
 385                .format(test_utils.RESTCONF_BASE_URL))
 386         headers = {'content-type': 'application/json'}
 387         response = requests.request(
 388             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 389         self.assertEqual(response.status_code, requests.codes.not_found)
 390         res = response.json()
 391         self.assertIn(
 392             {"error-type": "application", "error-tag": "data-missing",
 393              "error-message": "Request could not be completed because the relevant data model content does not exist"},
 394             res['errors']['error'])
 395
 396     def test_19_service_path_delete_rdm_check(self):
 397         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 398                "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 399                "interface/DEG1-TTP-TXRX-nmc-7"
 400                .format(test_utils.RESTCONF_BASE_URL))
 401         headers = {'content-type': 'application/json'}
 402         response = requests.request(
 403             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 404         self.assertEqual(response.status_code, requests.codes.not_found)
 405         res = response.json()
 406         self.assertIn(
 407             {"error-type": "application", "error-tag": "data-missing",
 408              "error-message": "Request could not be completed because the relevant data model content does not exist"},
 409             res['errors']['error'])
 410
 411     def test_20_service_path_delete_rdm_check(self):
 412         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 413                "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 414                "interface/SRG1-PP3-TXRX-mc-7"
 415                .format(test_utils.RESTCONF_BASE_URL))
 416         headers = {'content-type': 'application/json'}
 417         response = requests.request(
 418             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 419         self.assertEqual(response.status_code, requests.codes.not_found)
 420         res = response.json()
 421         self.assertIn({
 422             "error-type": "application",
 423             "error-tag": "data-missing",
 424             "error-message": "Request could not be completed because the relevant data model content does not exist"},
 425             res['errors']['error'])
 426
 427     def test_21_service_path_delete_rdm_check(self):
 428         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 429                "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 430                "interface/SRG1-PP3-TXRX-nmc-7"
 431                .format(test_utils.RESTCONF_BASE_URL))
 432         headers = {'content-type': 'application/json'}
 433         response = requests.request(
 434             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 435         self.assertEqual(response.status_code, requests.codes.not_found)
 436         res = response.json()
 437         self.assertIn({
 438             "error-type": "application",
 439             "error-tag": "data-missing",
 440             "error-message": "Request could not be completed because the relevant data model content does not exist"},
 441             res['errors']['error'])
 442
 443     def test_22_service_path_delete_rdm_check(self):
 444         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 445                "node/ROADM-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 446                "roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7"
 447                .format(test_utils.RESTCONF_BASE_URL))
 448         headers = {'content-type': 'application/json'}
 449         response = requests.request(
 450             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 451         self.assertEqual(response.status_code, requests.codes.not_found)
 452         res = response.json()
 453         self.assertIn({
 454             "error-type": "application",
 455             "error-tag": "data-missing",
 456             "error-message": "Request could not be completed because the relevant data model content does not exist"},
 457             res['errors']['error'])
 458
 459     def test_23_service_path_delete_xpdr_check(self):
 460         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 461                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 462                "interface/XPDR1-NETWORK1-7"
 463                .format(test_utils.RESTCONF_BASE_URL))
 464         headers = {'content-type': 'application/json'}
 465         response = requests.request(
 466             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 467         self.assertEqual(response.status_code, requests.codes.not_found)
 468         res = response.json()
 469         self.assertIn({
 470             "error-type": "application",
 471             "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'])
 474
 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()
 485         self.assertIn({
 486             "error-type": "application",
 487             "error-tag": "data-missing",
 488             "error-message": "Request could not be completed because the relevant data model content does not exist"},
 489             res['errors']['error'])
 490
 491     def test_25_service_path_delete_xpdr_check(self):
 492         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 493                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 494                "interface/XPDR1-NETWORK1-ODU"
 495                .format(test_utils.RESTCONF_BASE_URL))
 496         headers = {'content-type': 'application/json'}
 497         response = requests.request(
 498             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 499         self.assertEqual(response.status_code, requests.codes.not_found)
 500         res = response.json()
 501         self.assertIn({
 502             "error-type": "application",
 503             "error-tag": "data-missing",
 504             "error-message": "Request could not be completed because the relevant data model content does not exist"},
 505             res['errors']['error'])
 506
 507     def test_26_service_path_delete_xpdr_check(self):
 508         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 509                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 510                "interface/XPDR1-CLIENT1-ETHERNET"
 511                .format(test_utils.RESTCONF_BASE_URL))
 512         headers = {'content-type': 'application/json'}
 513         response = requests.request(
 514             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 515         self.assertEqual(response.status_code, requests.codes.not_found)
 516         res = response.json()
 517         self.assertIn({
 518             "error-type": "application",
 519             "error-tag": "data-missing",
 520             "error-message": "Request could not be completed because the relevant data model content does not exist"},
 521             res['errors']['error'])
 522
 523     def test_27_service_path_delete_xpdr_check(self):
 524         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 525                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 526                "circuit-packs/1%2F0%2F1-PLUG-NET"
 527                .format(test_utils.RESTCONF_BASE_URL))
 528         headers = {'content-type': 'application/json'}
 529         response = requests.request(
 530             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 531         self.assertEqual(response.status_code, requests.codes.ok)
 532         res = response.json()
 533         self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
 534
 535     def test_28_service_path_delete_xpdr_check(self):
 536         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 537                "node/XPDR-A1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
 538                "circuit-packs/1%2F0%2F1-PLUG-CLIENT"
 539                .format(test_utils.RESTCONF_BASE_URL))
 540         headers = {'content-type': 'application/json'}
 541         response = requests.request(
 542             "GET", url, headers=headers, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 543         self.assertEqual(response.status_code, requests.codes.ok)
 544         res = response.json()
 545         self.assertEqual('not-reserved-available', res["circuit-packs"][0]['equipment-state'])
 546
 547     def test_29_rdm_device_disconnected(self):
 548         response = test_utils.unmount_device("ROADM-A1")
 549         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 550
 551     def test_30_xpdr_device_disconnected(self):
 552         response = test_utils.unmount_device("XPDR-A1")
 553         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 554
 555
 556 if __name__ == "__main__":
 557     unittest.main(verbosity=2, failfast=True)