tests/transportpce_tests/1.2.1/test_olm.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 time
  14 import json
  15 import requests
  16 from common import test_utils
  17
  18
  19 class TransportOlmTesting(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-full', 'roadmc-full', 'xpdrc'])
  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 setUp(self):
  35         print("execution of {}".format(self.id().split(".")[-1]))
  36         time.sleep(1)
  37
  38     def test_01_xpdrA_device_connected(self):
  39         response = test_utils.mount_device("XPDRA01", 'xpdra')
  40         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  41
  42     def test_02_xpdrC_device_connected(self):
  43         response = test_utils.mount_device("XPDRC01", 'xpdrc')
  44         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  45
  46     def test_03_rdmA_device_connected(self):
  47         response = test_utils.mount_device("ROADMA01", 'roadma-full')
  48         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  49
  50     def test_04_rdmC_device_connected(self):
  51         response = test_utils.mount_device("ROADMC01", 'roadmc-full')
  52         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  53
  54     def test_05_connect_xprdA_to_roadmA(self):
  55         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
  56                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
  57         self.assertEqual(response.status_code, requests.codes.ok)
  58         res = response.json()
  59         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
  60
  61     def test_06_connect_roadmA_to_xpdrA(self):
  62         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
  63                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
  64         self.assertEqual(response.status_code, requests.codes.ok)
  65         res = response.json()
  66         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
  67
  68     def test_07_connect_xprdC_to_roadmC(self):
  69         response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "1",
  70                                                           "ROADMC01", "1", "SRG1-PP1-TXRX")
  71         self.assertEqual(response.status_code, requests.codes.ok)
  72         res = response.json()
  73         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
  74
  75     def test_08_connect_roadmC_to_xpdrC(self):
  76         response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "1",
  77                                                           "ROADMC01", "1", "SRG1-PP1-TXRX")
  78         self.assertEqual(response.status_code, requests.codes.ok)
  79         res = response.json()
  80         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
  81
  82     def test_09_create_OTS_ROADMA(self):
  83         url = "{}/operations/transportpce-device-renderer:create-ots-oms"
  84         data = {
  85             "input": {
  86                 "node-id": "ROADMA01",
  87                 "logical-connection-point": "DEG1-TTP-TXRX"
  88             }
  89         }
  90         response = test_utils.post_request(url, data)
  91         self.assertEqual(response.status_code, requests.codes.ok)
  92         res = response.json()
  93         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADMA01',
  94                       res["output"]["result"])
  95
  96     def test_10_create_OTS_ROADMC(self):
  97         url = "{}/operations/transportpce-device-renderer:create-ots-oms"
  98         data = {
  99             "input": {
 100                 "node-id": "ROADMC01",
 101                 "logical-connection-point": "DEG2-TTP-TXRX"
 102             }
 103         }
 104         response = test_utils.post_request(url, data)
 105         self.assertEqual(response.status_code, requests.codes.ok)
 106         res = response.json()
 107         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADMC01',
 108                       res["output"]["result"])
 109
 110     def test_11_get_PM_ROADMA(self):
 111         url = "{}/operations/transportpce-olm:get-pm"
 112         data = {
 113             "input": {
 114                 "node-id": "ROADMA01",
 115                 "resource-type": "interface",
 116                 "granularity": "15min",
 117                 "resource-identifier": {
 118                     "resource-name": "OTS-DEG1-TTP-TXRX"
 119                 }
 120             }
 121         }
 122         response = test_utils.post_request(url, data)
 123         self.assertEqual(response.status_code, requests.codes.ok)
 124         res = response.json()
 125         self.assertIn({
 126             "pmparameter-name": "OpticalPowerOutput",
 127             "pmparameter-value": "2.5"
 128         }, res["output"]["measurements"])
 129         self.assertIn({
 130             "pmparameter-name": "OpticalReturnLoss",
 131             "pmparameter-value": "49.9"
 132         }, res["output"]["measurements"])
 133         self.assertIn({
 134             "pmparameter-name": "OpticalPowerInput",
 135             "pmparameter-value": "3"
 136         }, res["output"]["measurements"])
 137
 138     def test_12_get_PM_ROADMC(self):
 139         url = "{}/operations/transportpce-olm:get-pm"
 140         data = {
 141             "input": {
 142                 "node-id": "ROADMC01",
 143                 "resource-type": "interface",
 144                 "granularity": "15min",
 145                 "resource-identifier": {
 146                     "resource-name": "OTS-DEG2-TTP-TXRX"
 147                 }
 148             }
 149         }
 150         response = test_utils.post_request(url, data)
 151         self.assertEqual(response.status_code, requests.codes.ok)
 152         res = response.json()
 153         self.assertIn({
 154             "pmparameter-name": "OpticalPowerOutput",
 155             "pmparameter-value": "18.1"
 156         }, res["output"]["measurements"])
 157         self.assertIn({
 158             "pmparameter-name": "OpticalReturnLoss",
 159             "pmparameter-value": "48.8"
 160         }, res["output"]["measurements"])
 161         self.assertIn({
 162             "pmparameter-name": "OpticalPowerInput",
 163             "pmparameter-value": "-3.2"
 164         }, res["output"]["measurements"])
 165
 166     def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
 167         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
 168         data = {
 169             "input": {
 170                 "src-type": "link",
 171                 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
 172             }
 173         }
 174         response = test_utils.post_request(url, data)
 175         self.assertEqual(response.status_code, requests.codes.ok)
 176         res = response.json()
 177         self.assertIn('Success',
 178                       res["output"]["result"])
 179         self.assertIn({
 180             "spanloss": "5.7",
 181             "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
 182         }, res["output"]["spans"])
 183         time.sleep(5)
 184
 185     def test_14_calculate_span_loss_base_all(self):
 186         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
 187         data = {
 188             "input": {
 189                 "src-type": "all"
 190             }
 191         }
 192         response = test_utils.post_request(url, data)
 193         self.assertEqual(response.status_code, requests.codes.ok)
 194         res = response.json()
 195         self.assertIn('Success',
 196                       res["output"]["result"])
 197         self.assertIn({
 198             "spanloss": "15.1",
 199             "link-id": "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX"
 200         }, res["output"]["spans"])
 201         self.assertIn({
 202             "spanloss": "5.7",
 203             "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
 204         }, res["output"]["spans"])
 205         time.sleep(5)
 206
 207     def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
 208         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 209                "node/ROADMA01/yang-ext:mount/org-openroadm-device:org-openroadm-device/interface/OTS-DEG1-TTP-TXRX/"
 210                "org-openroadm-optical-transport-interfaces:ots")
 211         response = test_utils.get_request(url)
 212         self.assertEqual(response.status_code, requests.codes.ok)
 213         res = response.json()
 214         self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
 215         self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
 216
 217     def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
 218         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
 219                "node/ROADMC01/yang-ext:mount/org-openroadm-device:org-openroadm-device/interface/OTS-DEG2-TTP-TXRX/"
 220                "org-openroadm-optical-transport-interfaces:ots")
 221         response = test_utils.get_request(url)
 222         self.assertEqual(response.status_code, requests.codes.ok)
 223         res = response.json()
 224         self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
 225         self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
 226
 227     def test_17_servicePath_create_AToZ(self):
 228         url = "{}/operations/transportpce-device-renderer:service-path"
 229         data = {
 230             "input": {
 231                 "service-name": "test",
 232                 "wave-number": "1",
 233                 "modulation-format": "qpsk",
 234                 "operation": "create",
 235                 "nodes": [
 236                     {
 237                         "dest-tp": "XPDR1-NETWORK1",
 238                         "src-tp": "XPDR1-CLIENT1",
 239                         "node-id": "XPDRA01"
 240                     },
 241                     {
 242                         "dest-tp": "DEG1-TTP-TXRX",
 243                         "src-tp": "SRG1-PP1-TXRX",
 244                         "node-id": "ROADMA01"
 245                     },
 246                     {
 247                         "dest-tp": "SRG1-PP1-TXRX",
 248                         "src-tp": "DEG2-TTP-TXRX",
 249                         "node-id": "ROADMC01"
 250                     },
 251                     {
 252                         "dest-tp": "XPDR1-CLIENT1",
 253                         "src-tp": "XPDR1-NETWORK1",
 254                         "node-id": "XPDRC01"
 255                     }
 256                 ]
 257             }
 258         }
 259         response = test_utils.post_request(url, data)
 260         self.assertEqual(response.status_code, requests.codes.ok)
 261         res = response.json()
 262         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 263         # time.sleep(40)
 264         time.sleep(10)
 265
 266     def test_18_servicePath_create_ZToA(self):
 267         url = "{}/operations/transportpce-device-renderer:service-path"
 268         data = {
 269             "input": {
 270                 "service-name": "test",
 271                 "wave-number": "1",
 272                 "modulation-format": "qpsk",
 273                 "operation": "create",
 274                 "nodes": [
 275                     {
 276                         "dest-tp": "XPDR1-NETWORK1",
 277                         "src-tp": "XPDR1-CLIENT1",
 278                         "node-id": "XPDRC01"
 279                     },
 280                     {
 281                         "dest-tp": "DEG2-TTP-TXRX",
 282                         "src-tp": "SRG1-PP1-TXRX",
 283                         "node-id": "ROADMC01"
 284                     },
 285                     {
 286                         "src-tp": "DEG1-TTP-TXRX",
 287                         "dest-tp": "SRG1-PP1-TXRX",
 288                         "node-id": "ROADMA01"
 289                     },
 290                     {
 291                         "src-tp": "XPDR1-NETWORK1",
 292                         "dest-tp": "XPDR1-CLIENT1",
 293                         "node-id": "XPDRA01"
 294                     }
 295                 ]
 296             }
 297         }
 298         response = test_utils.post_request(url, data)
 299         self.assertEqual(response.status_code, requests.codes.ok)
 300         res = response.json()
 301         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 302         # time.sleep(40)
 303         time.sleep(10)
 304
 305     def test_19_service_power_setup_XPDRA_XPDRC(self):
 306         url = "{}/operations/transportpce-olm:service-power-setup"
 307         data = {
 308             "input": {
 309                 "service-name": "test",
 310                 "wave-number": 1,
 311                 "nodes": [
 312                     {
 313                         "dest-tp": "XPDR1-NETWORK1",
 314                         "src-tp": "XPDR1-CLIENT1",
 315                         "node-id": "XPDRA01"
 316                     },
 317                     {
 318                         "dest-tp": "DEG1-TTP-TXRX",
 319                         "src-tp": "SRG1-PP1-TXRX",
 320                         "node-id": "ROADMA01"
 321                     },
 322                     {
 323                         "dest-tp": "SRG1-PP1-TXRX",
 324                         "src-tp": "DEG2-TTP-TXRX",
 325                         "node-id": "ROADMC01"
 326                     },
 327                     {
 328                         "dest-tp": "XPDR1-CLIENT1",
 329                         "src-tp": "XPDR1-NETWORK1",
 330                         "node-id": "XPDRC01"
 331                     }
 332                 ]
 333             }
 334         }
 335         response = test_utils.post_request(url, data)
 336         self.assertEqual(response.status_code, requests.codes.ok)
 337         res = response.json()
 338         self.assertIn('Success', res["output"]["result"])
 339
 340     def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
 341         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDRA01/yang-ext:mount/"
 342                "org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK1-1/"
 343                "org-openroadm-optical-channel-interfaces:och")
 344         response = test_utils.get_request(url)
 345         self.assertEqual(response.status_code, requests.codes.ok)
 346         res = response.json()
 347         self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 348         self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 349
 350     def test_21_get_roadmconnection_ROADMA(self):
 351         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMA01/yang-ext:mount/"
 352                "org-openroadm-device:org-openroadm-device/roadm-connections/"
 353                "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
 354         response = test_utils.get_request(url)
 355         self.assertEqual(response.status_code, requests.codes.ok)
 356         res = response.json()
 357         self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
 358         self.assertEqual(-3.3, res['roadm-connections'][0]['target-output-power'])
 359
 360     def test_22_get_roadmconnection_ROADMC(self):
 361         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMC01/yang-ext:mount/"
 362                "org-openroadm-device:org-openroadm-device/roadm-connections/"
 363                "DEG2-TTP-TXRX-SRG1-PP1-TXRX-1")
 364         response = test_utils.get_request(url)
 365         self.assertEqual(response.status_code, requests.codes.ok)
 366         res = response.json()
 367         self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
 368
 369     def test_23_service_power_setup_XPDRC_XPDRA(self):
 370         url = "{}/operations/transportpce-olm:service-power-setup"
 371         data = {
 372             "input": {
 373                 "service-name": "test",
 374                 "wave-number": 1,
 375                 "nodes": [
 376                     {
 377                         "dest-tp": "XPDR1-NETWORK1",
 378                         "src-tp": "XPDR1-CLIENT1",
 379                         "node-id": "XPDRC01"
 380                     },
 381                     {
 382                         "dest-tp": "DEG2-TTP-TXRX",
 383                         "src-tp": "SRG1-PP1-TXRX",
 384                         "node-id": "ROADMC01"
 385                     },
 386                     {
 387                         "src-tp": "DEG1-TTP-TXRX",
 388                         "dest-tp": "SRG1-PP1-TXRX",
 389                         "node-id": "ROADMA01"
 390                     },
 391                     {
 392                         "src-tp": "XPDR1-NETWORK1",
 393                         "dest-tp": "XPDR1-CLIENT1",
 394                         "node-id": "XPDRA01"
 395                     }
 396                 ]
 397             }
 398         }
 399         response = test_utils.post_request(url, data)
 400         self.assertEqual(response.status_code, requests.codes.ok)
 401         res = response.json()
 402         self.assertIn('Success', res["output"]["result"])
 403
 404     def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
 405         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDRC01/yang-ext:mount/"
 406                "org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK1-1/"
 407                "org-openroadm-optical-channel-interfaces:och")
 408         response = test_utils.get_request(url)
 409         self.assertEqual(response.status_code, requests.codes.ok)
 410         res = response.json()
 411         self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 412         self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 413
 414     def test_25_get_roadmconnection_ROADMC(self):
 415         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMC01/yang-ext:mount/"
 416                "org-openroadm-device:org-openroadm-device/roadm-connections/"
 417                "SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
 418         response = test_utils.get_request(url)
 419         self.assertEqual(response.status_code, requests.codes.ok)
 420         res = response.json()
 421         self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
 422         self.assertEqual(2, res['roadm-connections'][0]['target-output-power'])
 423
 424     def test_26_service_power_turndown_XPDRA_XPDRC(self):
 425         url = "{}/operations/transportpce-olm:service-power-turndown"
 426         data = {
 427             "input": {
 428                 "service-name": "test",
 429                 "wave-number": 1,
 430                 "nodes": [
 431                     {
 432                         "dest-tp": "XPDR1-NETWORK1",
 433                         "src-tp": "XPDR1-CLIENT1",
 434                         "node-id": "XPDRA01"
 435                     },
 436                     {
 437                         "dest-tp": "DEG1-TTP-TXRX",
 438                         "src-tp": "SRG1-PP1-TXRX",
 439                         "node-id": "ROADMA01"
 440                     },
 441                     {
 442                         "dest-tp": "SRG1-PP1-TXRX",
 443                         "src-tp": "DEG2-TTP-TXRX",
 444                         "node-id": "ROADMC01"
 445                     },
 446                     {
 447                         "dest-tp": "XPDR1-CLIENT1",
 448                         "src-tp": "XPDR1-NETWORK1",
 449                         "node-id": "XPDRC01"
 450                     }
 451                 ]
 452             }
 453         }
 454         response = test_utils.post_request(url, data)
 455         self.assertEqual(response.status_code, requests.codes.ok)
 456         res = response.json()
 457         self.assertIn('Success', res["output"]["result"])
 458
 459     def test_27_get_roadmconnection_ROADMA(self):
 460         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMA01/yang-ext:mount/"
 461                "org-openroadm-device:org-openroadm-device/roadm-connections/"
 462                "SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
 463         response = test_utils.get_request(url)
 464         self.assertEqual(response.status_code, requests.codes.ok)
 465         res = response.json()
 466         self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
 467         self.assertEqual(-60, res['roadm-connections'][0]['target-output-power'])
 468
 469     def test_28_get_roadmconnection_ROADMC(self):
 470         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/ROADMC01/yang-ext:mount/"
 471                "org-openroadm-device:org-openroadm-device/roadm-connections/"
 472                "DEG2-TTP-TXRX-SRG1-PP1-TXRX-1")
 473         response = test_utils.get_request(url)
 474         self.assertEqual(response.status_code, requests.codes.ok)
 475         res = response.json()
 476         self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
 477
 478     def test_29_servicePath_delete_AToZ(self):
 479         url = "{}/operations/transportpce-device-renderer:service-path"
 480         data = {
 481             "input": {
 482                 "service-name": "test",
 483                 "wave-number": "1",
 484                 "modulation-format": "qpsk",
 485                 "operation": "delete",
 486                 "nodes": [
 487                     {
 488                         "dest-tp": "XPDR1-NETWORK1",
 489                         "src-tp": "XPDR1-CLIENT1",
 490                         "node-id": "XPDRA01"
 491                     },
 492                     {
 493                         "dest-tp": "DEG1-TTP-TXRX",
 494                         "src-tp": "SRG1-PP1-TXRX",
 495                         "node-id": "ROADMA01"
 496                     },
 497                     {
 498                         "dest-tp": "SRG1-PP1-TXRX",
 499                         "src-tp": "DEG2-TTP-TXRX",
 500                         "node-id": "ROADMC01"
 501                     },
 502                     {
 503                         "dest-tp": "XPDR1-CLIENT1",
 504                         "src-tp": "XPDR1-NETWORK1",
 505                         "node-id": "XPDRC01"
 506                     }
 507                 ]
 508             }
 509         }
 510         response = test_utils.post_request(url, data)
 511         self.assertEqual(response.status_code, requests.codes.ok)
 512         res = response.json()
 513         self.assertIn('Request processed', res["output"]["result"])
 514         time.sleep(10)
 515
 516     def test_30_servicePath_delete_ZToA(self):
 517         url = "{}/operations/transportpce-device-renderer:service-path"
 518         data = {
 519             "input": {
 520                 "service-name": "test",
 521                 "wave-number": "1",
 522                 "modulation-format": "qpsk",
 523                 "operation": "delete",
 524                 "nodes": [
 525                     {
 526                         "dest-tp": "XPDR1-NETWORK1",
 527                         "src-tp": "XPDR1-CLIENT1",
 528                         "node-id": "XPDRC01"
 529                     },
 530                     {
 531                         "dest-tp": "DEG2-TTP-TXRX",
 532                         "src-tp": "SRG1-PP1-TXRX",
 533                         "node-id": "ROADMC01"
 534                     },
 535                     {
 536                         "src-tp": "DEG1-TTP-TXRX",
 537                         "dest-tp": "SRG1-PP1-TXRX",
 538                         "node-id": "ROADMA01"
 539                     },
 540                     {
 541                         "src-tp": "XPDR1-NETWORK1",
 542                         "dest-tp": "XPDR1-CLIENT1",
 543                         "node-id": "XPDRA01"
 544                     }
 545                 ]
 546             }
 547         }
 548         response = test_utils.post_request(url, data)
 549         self.assertEqual(response.status_code, requests.codes.ok)
 550         res = response.json()
 551         self.assertIn('Request processed', res["output"]["result"])
 552         time.sleep(10)
 553
 554     """to test case where SRG where the xpdr is connected to has no optical range data"""
 555
 556     def test_31_connect_xprdA_to_roadmA(self):
 557         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "2",
 558                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 559         self.assertEqual(response.status_code, requests.codes.ok)
 560         res = response.json()
 561         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
 562
 563     def test_32_connect_roadmA_to_xpdrA(self):
 564         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2",
 565                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 566         self.assertEqual(response.status_code, requests.codes.ok)
 567         res = response.json()
 568         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
 569
 570     def test_33_servicePath_create_AToZ(self):
 571         url = "{}/operations/transportpce-device-renderer:service-path"
 572         data = {
 573             "input": {
 574                 "service-name": "test2",
 575                 "wave-number": "2",
 576                 "modulation-format": "qpsk",
 577                 "operation": "create",
 578                 "nodes": [
 579                     {
 580                         "dest-tp": "XPDR1-NETWORK2",
 581                         "src-tp": "XPDR1-CLIENT2",
 582                         "node-id": "XPDRA01"
 583                     },
 584                     {
 585                         "dest-tp": "DEG1-TTP-TXRX",
 586                         "src-tp": "SRG1-PP2-TXRX",
 587                         "node-id": "ROADMA01"
 588                     }
 589                 ]
 590             }
 591         }
 592         response = test_utils.post_request(url, data)
 593         self.assertEqual(response.status_code, requests.codes.ok)
 594         res = response.json()
 595         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 596         # time.sleep(40)
 597         time.sleep(10)
 598
 599     def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
 600         url = ("{}/config/network-topology:network-topology/topology/topology-netconf/node/XPDRA01/yang-ext:mount/"
 601                "org-openroadm-device:org-openroadm-device/interface/XPDR1-NETWORK2-2/"
 602                "org-openroadm-optical-channel-interfaces:och")
 603         response = test_utils.get_request(url)
 604         self.assertEqual(response.status_code, requests.codes.ok)
 605         res = response.json()
 606         self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 607         self.assertEqual(2, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 608
 609     def test_35_servicePath_delete_AToZ(self):
 610         url = "{}/operations/transportpce-device-renderer:service-path"
 611         data = {
 612             "input": {
 613                 "service-name": "test",
 614                 "wave-number": "1",
 615                 "modulation-format": "qpsk",
 616                 "operation": "delete",
 617                 "nodes": [
 618                     {
 619                         "dest-tp": "XPDR1-NETWORK2",
 620                         "src-tp": "XPDR1-CLIENT2",
 621                         "node-id": "XPDRA01"
 622                     },
 623                     {
 624                         "dest-tp": "DEG1-TTP-TXRX",
 625                         "src-tp": "SRG1-PP2-TXRX",
 626                         "node-id": "ROADMA01"
 627                     }
 628                 ]
 629             }
 630         }
 631         response = test_utils.post_request(url, data)
 632         self.assertEqual(response.status_code, requests.codes.ok)
 633         res = response.json()
 634         self.assertIn('Request processed', res["output"]["result"])
 635         time.sleep(10)
 636
 637     def test_36_xpdrA_device_disconnected(self):
 638         response = test_utils.unmount_device("XPDRA01")
 639         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 640
 641     def test_37_xpdrC_device_disconnected(self):
 642         response = test_utils.unmount_device("XPDRC01")
 643         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 644
 645     def test_38_calculate_span_loss_current(self):
 646         url = "{}/operations/transportpce-olm:calculate-spanloss-current"
 647         response = test_utils.post_request(url, None)
 648         self.assertEqual(response.status_code, requests.codes.ok)
 649         res = response.json()
 650         self.assertIn('Success',
 651                       res["output"]["result"])
 652         time.sleep(5)
 653
 654     def test_39_rdmA_device_disconnected(self):
 655         response = test_utils.unmount_device("ROADMA01")
 656         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 657
 658     def test_40_rdmC_device_disconnected(self):
 659         response = test_utils.unmount_device("ROADMC01")
 660         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 661
 662
 663 if __name__ == "__main__":
 664     unittest.main(verbosity=2)