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 requests
  14 import time
  15 import subprocess
  16 import signal
  17 import json
  18 import os
  19 import psutil
  20 import shutil
  21 from unittest.result import failfast
  22 from common import test_utils
  23
  24
  25 class TransportPCERendererTesting(unittest.TestCase):
  26
  27     processes = None
  28
  29     @classmethod
  30     def setUpClass(cls):
  31         cls.processes = test_utils.start_tpce()
  32         cls.processes = test_utils.start_sims(['xpdra', 'roadma'])
  33
  34     @classmethod
  35     def tearDownClass(cls):
  36         for process in cls.processes:
  37             test_utils.shutdown_process(process)
  38         print("all processes killed")
  39
  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)
  43
  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)
  47
  48     def test_03_rdm_portmapping(self):
  49         url = ("{}/config/transportpce-portmapping:network/"
  50                "nodes/ROADM-A1"
  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)
  56         res = response.json()
  57         self.assertIn(
  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'])
  61         self.assertIn(
  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'])
  65
  66     def test_04_xpdr_portmapping(self):
  67         url = ("{}/config/transportpce-portmapping:network/"
  68                "nodes/XPDR-A1"
  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)
  74         res = response.json()
  75         self.assertIn(
  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'])
  82         self.assertIn(
  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'])
  90
  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",
  98             "renderer:nodes": [
  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"])
 112
 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(
 125             dict({
 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]),
 132             res['interface'][0]
 133         )
 134         self.assertDictEqual(
 135             {u'frequency': 195.8, u'width': 40},
 136             res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
 137
 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(
 150             dict({
 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]),
 157             res['interface'][0]
 158         )
 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'])
 162
 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(
 175             dict({
 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]),
 182             res['interface'][0]
 183         )
 184         self.assertDictEqual(
 185             {u'frequency': 195.8, u'width': 40},
 186             res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
 187
 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()
 199         self.assertIn(
 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'])
 203
 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(
 216             dict({
 217                  'connection-name': 'SRG1-PP3-TXRX-DEG1-TTP-TXRX-7',
 218                  'opticalControlMode': 'off'
 219                  }, **res['roadm-connections'][0]),
 220             res['roadm-connections'][0]
 221         )
 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'])
 228
 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(
 241             dict({
 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]),
 248             res['interface'][0]
 249         )
 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'])
 255
 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(
 268             dict({
 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]),
 276             res['interface'][0]
 277         )
 278         self.assertDictEqual(
 279             {u'rate': u'org-openroadm-otn-common-types:OTU4',
 280              u'fec': u'scfec'},
 281             res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 282
 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(
 295             dict({
 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]),
 303             res['interface'][0]
 304         )
 305         self.assertDictEqual(
 306             dict({
 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']
 311         )
 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'])
 314
 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(
 327             dict({
 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]),
 334             res['interface'][0]
 335         )
 336         self.assertDictEqual(
 337             {u'fec': u'off', u'speed': 100000},
 338             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 339
 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"])
 351
 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"])
 363
 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",
 370             "renderer:nodes": [
 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}})
 384
 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()
 395         self.assertIn(
 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'])
 399
 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()
 410         self.assertIn(
 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'])
 414
 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()
 425         self.assertIn(
 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'])
 429
 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()
 440         self.assertIn(
 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'])
 444
 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()
 455         self.assertIn(
 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'])
 459
 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()
 470         self.assertIn(
 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'])
 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", "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'])
 489
 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()
 500         self.assertIn(
 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'])
 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", "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'])
 519
 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'])
 531
 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'])
 543
 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)
 547
 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)
 551
 552
 553 if __name__ == "__main__":
 554     unittest.main(verbosity=2, failfast=True)