tests/transportpce_tests/1.2.1/test_pce.py

   1 #!/usr/bin/env python
   2 ##############################################################################
   3 # Copyright (c) 2017 Orange, Inc. and others.  All rights reserved.
   4 #
   5 # All rights reserved. This program and the accompanying materials
   6 # are made available under the terms of the Apache License, Version 2.0
   7 # which accompanies this distribution, and is available at
   8 # http://www.apache.org/licenses/LICENSE-2.0
   9 ##############################################################################
  10
  11 import unittest
  12 import json
  13 import os
  14 import time
  15 import requests
  16 from common import test_utils
  17
  18
  19 class TransportPCEtesting(unittest.TestCase):
  20
  21     simple_topo_bi_dir_data = None
  22     simple_topo_uni_dir_data = None
  23     complex_topo_uni_dir_data = None
  24
  25     @classmethod
  26     def _get_file(cls):
  27         topo_bi_dir_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
  28                                         "..", "..", "sample_configs", "honeynode-topo.xml")
  29         if os.path.isfile(topo_bi_dir_file):
  30             with open(topo_bi_dir_file, 'r') as topo_bi_dir:
  31                 cls.simple_topo_bi_dir_data = topo_bi_dir.read()
  32         topo_uni_dir_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
  33                                          "..", "..", "sample_configs", "NW-simple-topology.xml")
  34         if os.path.isfile(topo_uni_dir_file):
  35             with open(topo_uni_dir_file, 'r') as topo_uni_dir:
  36                 cls.simple_topo_uni_dir_data = topo_uni_dir.read()
  37         topo_uni_dir_complex_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
  38                                                  "..", "..", "sample_configs", "NW-for-test-5-4.xml")
  39         if os.path.isfile(topo_uni_dir_complex_file):
  40             with open(topo_uni_dir_complex_file, 'r') as topo_uni_dir_complex:
  41                 cls.complex_topo_uni_dir_data = topo_uni_dir_complex.read()
  42
  43     processes = None
  44
  45     @classmethod
  46     def setUpClass(cls):
  47         cls._get_file()
  48         cls.processes = test_utils.start_tpce()
  49
  50     @classmethod
  51     def tearDownClass(cls):
  52         for process in cls.processes:
  53             test_utils.shutdown_process(process)
  54         print("all processes killed")
  55
  56     def setUp(self):  # instruction executed before each test method
  57         time.sleep(1)
  58
  59      # Load simple bidirectional topology
  60     def test_01_load_simple_topology_bi(self):
  61         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
  62                .format(test_utils.RESTCONF_BASE_URL))
  63         body = self.simple_topo_bi_dir_data
  64         response = requests.request(
  65             "PUT", url, data=body, headers=test_utils.TYPE_APPLICATION_XML,
  66             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
  67         self.assertEqual(response.status_code, requests.codes.ok)
  68         time.sleep(2)
  69
  70     # Get existing nodeId
  71     def test_02_get_nodeId(self):
  72         url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
  73                .format(test_utils.RESTCONF_BASE_URL))
  74         response = requests.request(
  75             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
  76         self.assertEqual(response.status_code, requests.codes.ok)
  77         res = response.json()
  78         self.assertEqual(
  79             res['node'][0]['node-id'], 'ROADMA01-SRG1')
  80         time.sleep(1)
  81
  82     # Get existing linkId
  83     def test_03_get_linkId(self):
  84         url = ("{}/config/ietf-network:networks/network/openroadm-topology/link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
  85                .format(test_utils.RESTCONF_BASE_URL))
  86         response = requests.request(
  87             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
  88         self.assertEqual(response.status_code, requests.codes.ok)
  89         res = response.json()
  90         self.assertEqual(
  91             res['ietf-network-topology:link'][0]['link-id'],
  92             'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX')
  93         time.sleep(1)
  94
  95     # Path Computation success
  96     def test_04_path_computation_xpdr_bi(self):
  97         url = ("{}/operations/transportpce-pce:path-computation-request"
  98                .format(test_utils.RESTCONF_BASE_URL))
  99         body = {"input": {
 100                 "service-name": "service-1",
 101                 "resource-reserve": "true",
 102                 "pce-metric": "hop-count",
 103                 "service-handler-header": {
 104                     "request-id": "request-1"
 105                 },
 106                 "service-a-end": {
 107                     "node-id": "XPDRA01",
 108                     "service-rate": "100",
 109                     "service-format": "Ethernet",
 110                     "clli": "nodeA"
 111                 },
 112                 "service-z-end": {
 113                     "node-id": "XPDRC01",
 114                     "service-rate": "100",
 115                     "service-format": "Ethernet",
 116                     "clli": "nodeC"
 117                 }
 118                 }
 119                 }
 120         response = requests.request(
 121             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 122             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 123         self.assertEqual(response.status_code, requests.codes.ok)
 124         res = response.json()
 125         self.assertIn('Path is calculated',
 126                       res['output']['configuration-response-common']['response-message'])
 127         time.sleep(5)
 128
 129     # Path Computation success
 130     def test_05_path_computation_rdm_bi(self):
 131         url = ("{}/operations/transportpce-pce:path-computation-request"
 132                .format(test_utils.RESTCONF_BASE_URL))
 133         body = {"input": {
 134                 "service-name": "service-1",
 135                 "resource-reserve": "true",
 136                 "pce-metric": "hop-count",
 137                 "service-handler-header": {
 138                     "request-id": "request-1"
 139                 },
 140                 "service-a-end": {
 141                     "node-id": "ROADMA01",
 142                     "service-rate": "100",
 143                     "service-format": "Ethernet",
 144                     "clli": "NodeA"
 145                 },
 146                 "service-z-end": {
 147                     "node-id": "ROADMC01",
 148                     "service-rate": "100",
 149                     "service-format": "Ethernet",
 150                     "clli": "NodeC"
 151                 }
 152                 }
 153                 }
 154         response = requests.request(
 155             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 156             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 157         self.assertEqual(response.status_code, requests.codes.ok)
 158         res = response.json()
 159         self.assertIn('Path is calculated',
 160                       res['output']['configuration-response-common']['response-message'])
 161         time.sleep(5)
 162
 163     # Delete topology
 164     def test_06_delete_simple_topology_bi(self):
 165         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 166                .format(test_utils.RESTCONF_BASE_URL))
 167         response = requests.request(
 168             "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 169         self.assertEqual(response.status_code, requests.codes.ok)
 170         time.sleep(2)
 171
 172     # Test deleted topology
 173     def test_07_test_topology_simple_bi_deleted(self):
 174         url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
 175                .format(test_utils.RESTCONF_BASE_URL))
 176         response = requests.request(
 177             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 178         self.assertEqual(response.status_code, 404)
 179         time.sleep(1)
 180
 181     # Load simple bidirectional topology
 182     def test_08_load_simple_topology_uni(self):
 183         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 184                .format(test_utils.RESTCONF_BASE_URL))
 185         body = self.simple_topo_uni_dir_data
 186         response = requests.request(
 187             "PUT", url, data=body, headers=test_utils.TYPE_APPLICATION_XML,
 188             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 189         self.assertEqual(response.status_code, 201)
 190         time.sleep(2)
 191
 192     # Get existing nodeId
 193     def test_09_get_nodeId(self):
 194         url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-1-2"
 195                .format(test_utils.RESTCONF_BASE_URL))
 196         response = requests.request(
 197             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 198         self.assertEqual(response.status_code, requests.codes.ok)
 199         res = response.json()
 200         self.assertEqual(
 201             res['node'][0]['node-id'],
 202             'XPONDER-1-2')
 203         time.sleep(1)
 204
 205     # Get existing linkId
 206     def test_10_get_linkId(self):
 207         url = ("{}/config/ietf-network:networks/network/openroadm-topology/link/XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX"
 208                .format(test_utils.RESTCONF_BASE_URL))
 209         response = requests.request(
 210             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 211         self.assertEqual(response.status_code, requests.codes.ok)
 212         res = response.json()
 213         self.assertEqual(
 214             res['ietf-network-topology:link'][0]['link-id'],
 215             'XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX')
 216         time.sleep(1)
 217
 218     # Path Computation success
 219     def test_11_path_computation_xpdr_uni(self):
 220         url = ("{}/operations/transportpce-pce:path-computation-request"
 221                .format(test_utils.RESTCONF_BASE_URL))
 222         body = {"input": {
 223                 "service-name": "service-1",
 224                 "resource-reserve": "true",
 225                 "pce-metric": "hop-count",
 226                 "service-handler-header": {
 227                     "request-id": "request-1"
 228                 },
 229                 "service-a-end": {
 230                     "node-id": "XPONDER-1-2",
 231                     "service-rate": "100",
 232                     "service-format": "Ethernet",
 233                     "clli": "ORANGE1"
 234                 },
 235                 "service-z-end": {
 236                     "node-id": "XPONDER-3-2",
 237                     "service-rate": "100",
 238                     "service-format": "Ethernet",
 239                     "clli": "ORANGE3"
 240                 }
 241                 }
 242                 }
 243         response = requests.request(
 244             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 245             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 246         self.assertEqual(response.status_code, requests.codes.ok)
 247         res = response.json()
 248         self.assertIn('Path is calculated',
 249                       res['output']['configuration-response-common']['response-message'])
 250         time.sleep(5)
 251
 252     # Path Computation success
 253     def test_12_path_computation_rdm_uni(self):
 254         url = ("{}/operations/transportpce-pce:path-computation-request"
 255                .format(test_utils.RESTCONF_BASE_URL))
 256         body = {"input": {
 257                 "service-name": "service1",
 258                 "resource-reserve": "true",
 259                 "service-handler-header": {
 260                     "request-id": "request1"
 261                 },
 262                 "service-a-end": {
 263                     "service-rate": "100",
 264                     "service-format": "Ethernet",
 265                     "clli": "cll21",
 266                     "node-id": "OpenROADM-2-1"
 267                 },
 268                 "service-z-end": {
 269                     "service-rate": "100",
 270                     "service-format": "Ethernet",
 271                     "clli": "ncli22",
 272                     "node-id": "OpenROADM-2-2"
 273                 },
 274                 "pce-metric": "hop-count"
 275                 }
 276                 }
 277         response = requests.request(
 278             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 279             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 280         self.assertEqual(response.status_code, requests.codes.ok)
 281         res = response.json()
 282         self.assertIn('Path is calculated',
 283                       res['output']['configuration-response-common']['response-message'])
 284         # ZtoA path test
 285         atozList = len(res['output']['response-parameters']['path-description']['aToZ-direction']['aToZ'])
 286         ztoaList = len(res['output']['response-parameters']['path-description']['zToA-direction']['zToA'])
 287         self.assertEqual(atozList, 15)
 288         self.assertEqual(ztoaList, 15)
 289         for i in range(0, 15):
 290             atoz = res['output']['response-parameters']['path-description']['aToZ-direction']['aToZ'][i]
 291             ztoa = res['output']['response-parameters']['path-description']['zToA-direction']['zToA'][i]
 292             if (atoz['id'] == '14'):
 293                 self.assertEqual(atoz['resource']['tp-id'], 'SRG1-PP1-TX')
 294             if (ztoa['id'] == '0'):
 295                 self.assertEqual(ztoa['resource']['tp-id'], 'SRG1-PP1-RX')
 296         time.sleep(5)
 297
 298     # Delete topology
 299     def test_13_delete_simple_topology(self):
 300         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 301                .format(test_utils.RESTCONF_BASE_URL))
 302         response = requests.request(
 303             "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 304         self.assertEqual(response.status_code, requests.codes.ok)
 305         time.sleep(2)
 306
 307     # Test deleted topology
 308     def test_14_test_topology_simple_deleted(self):
 309         url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-1-2"
 310                .format(test_utils.RESTCONF_BASE_URL))
 311         response = requests.request(
 312             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 313         self.assertEqual(response.status_code, 404)
 314         time.sleep(1)
 315
 316     # Load complex topology
 317     def test_15_load_complex_topology(self):
 318         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 319                .format(test_utils.RESTCONF_BASE_URL))
 320         body = self.complex_topo_uni_dir_data
 321         response = requests.request(
 322             "PUT", url, data=body, headers=test_utils.TYPE_APPLICATION_XML,
 323             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 324         self.assertEqual(response.status_code, 201)
 325         time.sleep(2)
 326
 327     # Get existing nodeId
 328     def test_16_get_nodeId(self):
 329         url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
 330                .format(test_utils.RESTCONF_BASE_URL))
 331         response = requests.request(
 332             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 333         self.assertEqual(response.status_code, requests.codes.ok)
 334         res = response.json()
 335         self.assertEqual(
 336             res['node'][0]['node-id'],
 337             'XPONDER-3-2')
 338         time.sleep(1)
 339
 340     # Test failed path computation
 341     def test_17_fail_path_computation(self):
 342         url = ("{}/operations/transportpce-pce:path-computation-request"
 343                .format(test_utils.RESTCONF_BASE_URL))
 344         body = {"input": {
 345                 "service-handler-header": {
 346                     "request-id": "request-1"
 347                 }
 348                 }
 349                 }
 350         response = requests.request(
 351             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 352             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 353         self.assertEqual(response.status_code, requests.codes.ok)
 354         res = response.json()
 355         self.assertIn('Service Name is not set',
 356                       res['output']['configuration-response-common']['response-message'])
 357         time.sleep(2)
 358
 359     # Test1 success path computation
 360     def test_18_success1_path_computation(self):
 361         url = ("{}/operations/transportpce-pce:path-computation-request"
 362                .format(test_utils.RESTCONF_BASE_URL))
 363         body = {"input": {
 364                 "service-name": "service1",
 365                 "resource-reserve": "true",
 366                 "service-handler-header": {
 367                     "request-id": "request1"
 368                 },
 369                 "service-a-end": {
 370                     "service-format": "Ethernet",
 371                     "service-rate": "100",
 372                     "clli": "ORANGE2",
 373                     "node-id": "XPONDER-2-2",
 374                     "tx-direction": {
 375                         "port": {
 376                             "port-device-name": "Some port-device-name",
 377                             "port-type": "Some port-type",
 378                             "port-name": "Some port-name",
 379                             "port-rack": "Some port-rack",
 380                             "port-shelf": "Some port-shelf",
 381                             "port-slot": "Some port-slot",
 382                             "port-sub-slot": "Some port-sub-slot"
 383                         }
 384                     },
 385                     "rx-direction": {
 386                         "port": {
 387                             "port-device-name": "Some port-device-name",
 388                             "port-type": "Some port-type",
 389                             "port-name": "Some port-name",
 390                             "port-rack": "Some port-rack",
 391                             "port-shelf": "Some port-shelf",
 392                             "port-slot": "Some port-slot",
 393                             "port-sub-slot": "Some port-sub-slot"
 394                         }
 395                     }
 396                 },
 397                 "service-z-end": {
 398                     "service-format": "Ethernet",
 399                     "service-rate": "100",
 400                     "clli": "ORANGE1",
 401                     "node-id": "XPONDER-1-2",
 402                     "tx-direction": {
 403                         "port": {
 404                             "port-device-name": "Some port-device-name",
 405                             "port-type": "Some port-type",
 406                             "port-name": "Some port-name",
 407                             "port-rack": "Some port-rack",
 408                             "port-shelf": "Some port-shelf",
 409                             "port-slot": "Some port-slot",
 410                             "port-sub-slot": "Some port-sub-slot"
 411                         }
 412                     },
 413                     "rx-direction": {
 414                         "port": {
 415                             "port-device-name": "Some port-device-name",
 416                             "port-type": "Some port-type",
 417                             "port-name": "Some port-name",
 418                             "port-rack": "Some port-rack",
 419                             "port-shelf": "Some port-shelf",
 420                             "port-slot": "Some port-slot",
 421                             "port-sub-slot": "Some port-sub-slot"
 422                         }
 423                     }
 424                 },
 425                 "hard-constraints": {
 426                     "customer-code": [
 427                         "Some customer-code"
 428                     ],
 429                     "co-routing": {
 430                         "existing-service": [
 431                             "Some existing-service"
 432                         ]
 433                     }
 434                 },
 435                 "soft-constraints": {
 436                     "customer-code": [
 437                         "Some customer-code"
 438                     ],
 439                     "co-routing": {
 440                         "existing-service": [
 441                             "Some existing-service"
 442                         ]
 443                     }
 444                 },
 445                 "pce-metric": "hop-count",
 446                 "locally-protected-links": "true"
 447                 }
 448                 }
 449         response = requests.request(
 450             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 451             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 452         self.assertEqual(response.status_code, requests.codes.ok)
 453         res = response.json()
 454         self.assertIn('Path is calculated',
 455                       res['output']['configuration-response-common']['response-message'])
 456         time.sleep(5)
 457
 458     # Test2 success path computation with path description
 459     def test_19_success2_path_computation(self):
 460         url = ("{}/operations/transportpce-pce:path-computation-request"
 461                .format(test_utils.RESTCONF_BASE_URL))
 462         body = {"input": {
 463                 "service-name": "service 1",
 464                 "resource-reserve": "true",
 465                 "service-handler-header": {
 466                     "request-id": "request 1"
 467                 },
 468                 "service-a-end": {
 469                     "service-rate": "100",
 470                     "service-format": "Ethernet",
 471                     "node-id": "XPONDER-1-2",
 472                     "clli": "ORANGE1"
 473                 },
 474                 "service-z-end": {
 475                     "service-rate": "100",
 476                     "service-format": "Ethernet",
 477                     "node-id": "XPONDER-3-2",
 478                     "clli": "ORANGE3"
 479                 },
 480                 "pce-metric": "hop-count"
 481                 }
 482                 }
 483         response = requests.request(
 484             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 485             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 486         self.assertEqual(response.status_code, requests.codes.ok)
 487         res = response.json()
 488         self.assertIn('Path is calculated',
 489                       res['output']['configuration-response-common']['response-message'])
 490         self.assertEqual(5, res['output']['response-parameters']['path-description']
 491                          ['aToZ-direction']['aToZ-wavelength-number'])
 492         self.assertEqual(5, res['output']['response-parameters']['path-description']
 493                          ['zToA-direction']['zToA-wavelength-number'])
 494         time.sleep(5)
 495
 496     # Test3 success path computation with hard-constraints exclude
 497     def test_20_success3_path_computation(self):
 498         url = ("{}/operations/transportpce-pce:path-computation-request"
 499                .format(test_utils.RESTCONF_BASE_URL))
 500         body = {"input": {
 501                 "service-name": "service 1",
 502                 "resource-reserve": "true",
 503                 "service-handler-header": {
 504                     "request-id": "request 1"
 505                 },
 506                 "service-a-end": {
 507                     "service-rate": "100",
 508                     "service-format": "Ethernet",
 509                     "node-id": "XPONDER-1-2",
 510                     "clli": "ORANGE1"
 511                 },
 512                 "service-z-end": {
 513                     "service-rate": "100",
 514                     "service-format": "Ethernet",
 515                     "node-id": "XPONDER-3-2",
 516                     "clli": "ORANGE3"
 517                 },
 518                 "hard-constraints": {
 519                     "exclude_": {
 520                         "node-id": ["OpenROADM-2-1", "OpenROADM-2-2"]
 521                     }
 522                 },
 523                 "pce-metric": "hop-count"
 524                 }
 525                 }
 526         response = requests.request(
 527             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 528             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 529         self.assertEqual(response.status_code, requests.codes.ok)
 530         res = response.json()
 531         self.assertIn('Path is calculated',
 532                       res['output']['configuration-response-common']['response-message'])
 533         self.assertEqual(9, res['output']['response-parameters']['path-description']
 534                          ['aToZ-direction']['aToZ-wavelength-number'])
 535         self.assertEqual(9, res['output']['response-parameters']['path-description']
 536                          ['zToA-direction']['zToA-wavelength-number'])
 537         time.sleep(5)
 538
 539     # Path computation before deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
 540     def test_21_path_computation_before_oms_attribute_deletion(self):
 541         url = ("{}/operations/transportpce-pce:path-computation-request"
 542                .format(test_utils.RESTCONF_BASE_URL))
 543         body = {"input": {
 544                 "service-name": "service 1",
 545                 "resource-reserve": "true",
 546                 "service-handler-header": {
 547                     "request-id": "request 1"
 548                 },
 549                 "service-a-end": {
 550                     "service-rate": "100",
 551                     "service-format": "Ethernet",
 552                     "node-id": "XPONDER-2-2",
 553                     "clli": "ORANGE2"
 554                 },
 555                 "service-z-end": {
 556                     "service-rate": "100",
 557                     "service-format": "Ethernet",
 558                     "node-id": "XPONDER-1-2",
 559                     "clli": "ORANGE1"
 560                 },
 561                 "pce-metric": "hop-count"
 562                 }
 563                 }
 564         response = requests.request(
 565             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 566             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 567         self.assertEqual(response.status_code, requests.codes.ok)
 568         res = response.json()
 569         self.assertIn('Path is calculated',
 570                       res['output']['configuration-response-common']['response-message'])
 571         nbElmPath = len(res['output']['response-parameters']['path-description']
 572                         ['aToZ-direction']['aToZ'])
 573         self.assertEqual(31, nbElmPath)
 574         link = {"link-id": "OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2"}
 575         find = False
 576         for i in range(0, nbElmPath):
 577             resource_i = res['output']['response-parameters']['path-description']['aToZ-direction']['aToZ'][i]['resource']
 578             if(resource_i == link):
 579                 find = True
 580         self.assertEqual(find, True)
 581         time.sleep(5)
 582
 583     # Delete oms-attribute in the link :openroadm1-3 to openroadm1-2
 584     def test_22_delete_oms_attribute_in_openroadm13toopenroadm12_link(self):
 585         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
 586                "OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2/org-openroadm-network-topology:OMS-attributes/span"
 587                .format(test_utils.RESTCONF_BASE_URL))
 588         response = requests.request(
 589             "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 590         self.assertEqual(response.status_code, requests.codes.ok)
 591         time.sleep(2)
 592
 593     # Path computation after deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
 594     def test_23_path_computation_after_oms_attribute_deletion(self):
 595         url = ("{}/operations/transportpce-pce:path-computation-request"
 596                .format(test_utils.RESTCONF_BASE_URL))
 597         body = {"input": {
 598                 "service-name": "service 1",
 599                 "resource-reserve": "true",
 600                 "service-handler-header": {
 601                     "request-id": "request 1"
 602                 },
 603                 "service-a-end": {
 604                     "service-rate": "100",
 605                     "service-format": "Ethernet",
 606                     "node-id": "XPONDER-2-2",
 607                     "clli": "ORANGE2"
 608                 },
 609                 "service-z-end": {
 610                     "service-rate": "100",
 611                     "service-format": "Ethernet",
 612                     "node-id": "XPONDER-1-2",
 613                     "clli": "ORANGE1"
 614                 },
 615                 "pce-metric": "hop-count"
 616                 }
 617                 }
 618         response = requests.request(
 619             "POST", url, data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
 620             auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 621         self.assertEqual(response.status_code, requests.codes.ok)
 622         res = response.json()
 623         self.assertIn('Path is calculated',
 624                       res['output']['configuration-response-common']['response-message'])
 625         nbElmPath = len(res['output']['response-parameters']['path-description']
 626                         ['aToZ-direction']['aToZ'])
 627         self.assertEqual(47, nbElmPath)
 628         link = {"link-id": "OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2"}
 629         find = False
 630         for i in range(0, nbElmPath):
 631             resource_i = res['output']['response-parameters']['path-description']['aToZ-direction']['aToZ'][i]['resource']
 632             if (resource_i == link):
 633                 find = True
 634         self.assertNotEqual(find, True)
 635         time.sleep(5)
 636
 637     # Delete complex topology
 638     def test_24_delete_complex_topology(self):
 639         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
 640                .format(test_utils.RESTCONF_BASE_URL))
 641         response = requests.request(
 642             "DELETE", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 643         self.assertEqual(response.status_code, requests.codes.ok)
 644         time.sleep(2)
 645
 646     # Test deleted complex topology
 647     def test_25_test_topology_complex_deleted(self):
 648         url = ("{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
 649                .format(test_utils.RESTCONF_BASE_URL))
 650         response = requests.request(
 651             "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
 652         self.assertEqual(response.status_code, 404)
 653         time.sleep(1)
 654
 655
 656 if __name__ == "__main__":
 657     unittest.main(verbosity=2)