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 # pylint: disable=no-member
  13 # pylint: disable=too-many-public-methods
  14
  15 import unittest
  16 import time
  17 import requests
  18 from common import test_utils
  19
  20
  21 class TransportOlmTesting(unittest.TestCase):
  22
  23     processes = None
  24
  25     @classmethod
  26     def setUpClass(cls):
  27         cls.processes = test_utils.start_tpce()
  28         cls.processes = test_utils.start_sims(['xpdra', 'roadma-full', 'roadmc-full', 'xpdrc'])
  29
  30     @classmethod
  31     def tearDownClass(cls):
  32         # pylint: disable=not-an-iterable
  33         for process in cls.processes:
  34             test_utils.shutdown_process(process)
  35         print("all processes killed")
  36
  37     def setUp(self):
  38         print("execution of {}".format(self.id().split(".")[-1]))
  39         time.sleep(1)
  40
  41     def test_01_xpdrA_device_connected(self):
  42         response = test_utils.mount_device("XPDRA01", 'xpdra')
  43         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  44
  45     def test_02_xpdrC_device_connected(self):
  46         response = test_utils.mount_device("XPDRC01", 'xpdrc')
  47         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  48
  49     def test_03_rdmA_device_connected(self):
  50         response = test_utils.mount_device("ROADMA01", 'roadma-full')
  51         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  52
  53     def test_04_rdmC_device_connected(self):
  54         response = test_utils.mount_device("ROADMC01", 'roadmc-full')
  55         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  56
  57     def test_05_connect_xprdA_to_roadmA(self):
  58         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
  59                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
  60         self.assertEqual(response.status_code, requests.codes.ok)
  61         res = response.json()
  62         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
  63
  64     def test_06_connect_roadmA_to_xpdrA(self):
  65         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
  66                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
  67         self.assertEqual(response.status_code, requests.codes.ok)
  68         res = response.json()
  69         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
  70
  71     def test_07_connect_xprdC_to_roadmC(self):
  72         response = test_utils.connect_xpdr_to_rdm_request("XPDRC01", "1", "1",
  73                                                           "ROADMC01", "1", "SRG1-PP1-TXRX")
  74         self.assertEqual(response.status_code, requests.codes.ok)
  75         res = response.json()
  76         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
  77
  78     def test_08_connect_roadmC_to_xpdrC(self):
  79         response = test_utils.connect_rdm_to_xpdr_request("XPDRC01", "1", "1",
  80                                                           "ROADMC01", "1", "SRG1-PP1-TXRX")
  81         self.assertEqual(response.status_code, requests.codes.ok)
  82         res = response.json()
  83         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
  84
  85     def test_09_create_OTS_ROADMA(self):
  86         response = test_utils.create_ots_oms_request("ROADMA01", "DEG1-TTP-TXRX")
  87         self.assertEqual(response.status_code, requests.codes.ok)
  88         res = response.json()
  89         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADMA01',
  90                       res["output"]["result"])
  91
  92     def test_10_create_OTS_ROADMC(self):
  93         response = test_utils.create_ots_oms_request("ROADMC01", "DEG2-TTP-TXRX")
  94         self.assertEqual(response.status_code, requests.codes.ok)
  95         res = response.json()
  96         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADMC01',
  97                       res["output"]["result"])
  98
  99     def test_11_get_PM_ROADMA(self):
 100         url = "{}/operations/transportpce-olm:get-pm"
 101         data = {
 102             "input": {
 103                 "node-id": "ROADMA01",
 104                 "resource-type": "interface",
 105                 "granularity": "15min",
 106                 "resource-identifier": {
 107                     "resource-name": "OTS-DEG1-TTP-TXRX"
 108                 }
 109             }
 110         }
 111         response = test_utils.post_request(url, data)
 112         self.assertEqual(response.status_code, requests.codes.ok)
 113         res = response.json()
 114         self.assertIn({
 115             "pmparameter-name": "OpticalPowerOutput",
 116             "pmparameter-value": "2.5"
 117         }, res["output"]["measurements"])
 118         self.assertIn({
 119             "pmparameter-name": "OpticalReturnLoss",
 120             "pmparameter-value": "49.9"
 121         }, res["output"]["measurements"])
 122         self.assertIn({
 123             "pmparameter-name": "OpticalPowerInput",
 124             "pmparameter-value": "3"
 125         }, res["output"]["measurements"])
 126
 127     def test_12_get_PM_ROADMC(self):
 128         url = "{}/operations/transportpce-olm:get-pm"
 129         data = {
 130             "input": {
 131                 "node-id": "ROADMC01",
 132                 "resource-type": "interface",
 133                 "granularity": "15min",
 134                 "resource-identifier": {
 135                     "resource-name": "OTS-DEG2-TTP-TXRX"
 136                 }
 137             }
 138         }
 139         response = test_utils.post_request(url, data)
 140         self.assertEqual(response.status_code, requests.codes.ok)
 141         res = response.json()
 142         self.assertIn({
 143             "pmparameter-name": "OpticalPowerOutput",
 144             "pmparameter-value": "18.1"
 145         }, res["output"]["measurements"])
 146         self.assertIn({
 147             "pmparameter-name": "OpticalReturnLoss",
 148             "pmparameter-value": "48.8"
 149         }, res["output"]["measurements"])
 150         self.assertIn({
 151             "pmparameter-name": "OpticalPowerInput",
 152             "pmparameter-value": "-3.2"
 153         }, res["output"]["measurements"])
 154
 155     def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
 156         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
 157         data = {
 158             "input": {
 159                 "src-type": "link",
 160                 "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
 161             }
 162         }
 163         response = test_utils.post_request(url, data)
 164         self.assertEqual(response.status_code, requests.codes.ok)
 165         res = response.json()
 166         self.assertIn('Success',
 167                       res["output"]["result"])
 168         self.assertIn({
 169             "spanloss": "5.7",
 170             "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
 171         }, res["output"]["spans"])
 172         time.sleep(5)
 173
 174     def test_14_calculate_span_loss_base_all(self):
 175         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
 176         data = {
 177             "input": {
 178                 "src-type": "all"
 179             }
 180         }
 181         response = test_utils.post_request(url, data)
 182         self.assertEqual(response.status_code, requests.codes.ok)
 183         res = response.json()
 184         self.assertIn('Success',
 185                       res["output"]["result"])
 186         self.assertIn({
 187             "spanloss": "15.1",
 188             "link-id": "ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX"
 189         }, res["output"]["spans"])
 190         self.assertIn({
 191             "spanloss": "5.7",
 192             "link-id": "ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX"
 193         }, res["output"]["spans"])
 194         time.sleep(5)
 195
 196     def test_15_get_OTS_DEG1_TTP_TXRX_ROADMA(self):
 197         response = test_utils.check_netconf_node_request(
 198             "ROADMA01",
 199             "interface/OTS-DEG1-TTP-TXRX/org-openroadm-optical-transport-interfaces:ots")
 200         self.assertEqual(response.status_code, requests.codes.ok)
 201         res = response.json()
 202         self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
 203         self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
 204
 205     def test_16_get_OTS_DEG2_TTP_TXRX_ROADMC(self):
 206         response = test_utils.check_netconf_node_request(
 207             "ROADMC01",
 208             "interface/OTS-DEG2-TTP-TXRX/org-openroadm-optical-transport-interfaces:ots")
 209         self.assertEqual(response.status_code, requests.codes.ok)
 210         res = response.json()
 211         self.assertEqual(15.1, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
 212         self.assertEqual(5.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
 213
 214     def test_17_servicePath_create_AToZ(self):
 215         response = test_utils.service_path_request("create", "test", "1",
 216                                                    [{"node-id": "XPDRA01",
 217                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 218                                                     {"node-id": "ROADMA01",
 219                                                      "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 220                                                     {"node-id": "ROADMC01",
 221                                                      "dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG2-TTP-TXRX"},
 222                                                     {"node-id": "XPDRC01",
 223                                                      "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
 224                                                     196.1, 40, 196.075, 196.125, 761,
 225                                                     768)
 226         self.assertEqual(response.status_code, requests.codes.ok)
 227         res = response.json()
 228         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 229         # time.sleep(40)
 230         time.sleep(10)
 231
 232     def test_18_servicePath_create_ZToA(self):
 233         response = test_utils.service_path_request("create", "test", "1",
 234                                                    [{"node-id": "XPDRC01",
 235                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 236                                                     {"node-id": "ROADMC01",
 237                                                      "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 238                                                     {"node-id": "ROADMA01",
 239                                                      "src-tp": "DEG1-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
 240                                                     {"node-id": "XPDRA01",
 241                                                      "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
 242                                                     196.1, 40, 196.075, 196.125, 761,
 243                                                     768)
 244         self.assertEqual(response.status_code, requests.codes.ok)
 245         res = response.json()
 246         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 247         # time.sleep(40)
 248         time.sleep(10)
 249
 250     def test_19_service_power_setup_XPDRA_XPDRC(self):
 251         url = "{}/operations/transportpce-olm:service-power-setup"
 252         data = {
 253             "input": {
 254                 "service-name": "test",
 255                 "wave-number": 1,
 256                 "nodes": [
 257                     {
 258                         "dest-tp": "XPDR1-NETWORK1",
 259                         "src-tp": "XPDR1-CLIENT1",
 260                         "node-id": "XPDRA01"
 261                     },
 262                     {
 263                         "dest-tp": "DEG1-TTP-TXRX",
 264                         "src-tp": "SRG1-PP1-TXRX",
 265                         "node-id": "ROADMA01"
 266                     },
 267                     {
 268                         "dest-tp": "SRG1-PP1-TXRX",
 269                         "src-tp": "DEG2-TTP-TXRX",
 270                         "node-id": "ROADMC01"
 271                     },
 272                     {
 273                         "dest-tp": "XPDR1-CLIENT1",
 274                         "src-tp": "XPDR1-NETWORK1",
 275                         "node-id": "XPDRC01"
 276                     }
 277                 ],
 278                 "center-freq": 196.1,
 279                 "width": 40,
 280                 "min-freq": 196.075,
 281                 "max-freq": 196.125,
 282                 "lower-spectral-slot-number": 761,
 283                 "higher-spectral-slot-number": 768
 284             }
 285         }
 286         response = test_utils.post_request(url, data)
 287         self.assertEqual(response.status_code, requests.codes.ok)
 288         res = response.json()
 289         self.assertIn('Success', res["output"]["result"])
 290
 291     def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
 292         response = test_utils.check_netconf_node_request(
 293             "XPDRA01",
 294             "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
 295         self.assertEqual(response.status_code, requests.codes.ok)
 296         res = response.json()
 297         self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 298         self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 299
 300     def test_21_get_roadmconnection_ROADMA(self):
 301         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
 302         self.assertEqual(response.status_code, requests.codes.ok)
 303         res = response.json()
 304         self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
 305         self.assertEqual(-3.3, res['roadm-connections'][0]['target-output-power'])
 306
 307     def test_22_get_roadmconnection_ROADMC(self):
 308         response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768")
 309         self.assertEqual(response.status_code, requests.codes.ok)
 310         res = response.json()
 311         self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
 312
 313     def test_23_service_power_setup_XPDRC_XPDRA(self):
 314         url = "{}/operations/transportpce-olm:service-power-setup"
 315         data = {
 316             "input": {
 317                 "service-name": "test",
 318                 "wave-number": 1,
 319                 "nodes": [
 320                     {
 321                         "dest-tp": "XPDR1-NETWORK1",
 322                         "src-tp": "XPDR1-CLIENT1",
 323                         "node-id": "XPDRC01"
 324                     },
 325                     {
 326                         "dest-tp": "DEG2-TTP-TXRX",
 327                         "src-tp": "SRG1-PP1-TXRX",
 328                         "node-id": "ROADMC01"
 329                     },
 330                     {
 331                         "src-tp": "DEG1-TTP-TXRX",
 332                         "dest-tp": "SRG1-PP1-TXRX",
 333                         "node-id": "ROADMA01"
 334                     },
 335                     {
 336                         "src-tp": "XPDR1-NETWORK1",
 337                         "dest-tp": "XPDR1-CLIENT1",
 338                         "node-id": "XPDRA01"
 339                     }
 340                 ],
 341                 "center-freq": 196.1,
 342                 "width": 40,
 343                 "min-freq": 196.075,
 344                 "max-freq": 196.125,
 345                 "lower-spectral-slot-number": 761,
 346                 "higher-spectral-slot-number": 768
 347             }
 348         }
 349         response = test_utils.post_request(url, data)
 350         self.assertEqual(response.status_code, requests.codes.ok)
 351         res = response.json()
 352         self.assertIn('Success', res["output"]["result"])
 353
 354     def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
 355         response = test_utils.check_netconf_node_request(
 356             "XPDRC01",
 357             "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
 358         self.assertEqual(response.status_code, requests.codes.ok)
 359         res = response.json()
 360         self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 361         self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 362
 363     def test_25_get_roadmconnection_ROADMC(self):
 364         response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
 365         self.assertEqual(response.status_code, requests.codes.ok)
 366         res = response.json()
 367         self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
 368         self.assertEqual(2, res['roadm-connections'][0]['target-output-power'])
 369
 370     def test_26_service_power_turndown_XPDRA_XPDRC(self):
 371         url = "{}/operations/transportpce-olm:service-power-turndown"
 372         data = {
 373             "input": {
 374                 "service-name": "test",
 375                 "wave-number": 1,
 376                 "nodes": [
 377                     {
 378                         "dest-tp": "XPDR1-NETWORK1",
 379                         "src-tp": "XPDR1-CLIENT1",
 380                         "node-id": "XPDRA01"
 381                     },
 382                     {
 383                         "dest-tp": "DEG1-TTP-TXRX",
 384                         "src-tp": "SRG1-PP1-TXRX",
 385                         "node-id": "ROADMA01"
 386                     },
 387                     {
 388                         "dest-tp": "SRG1-PP1-TXRX",
 389                         "src-tp": "DEG2-TTP-TXRX",
 390                         "node-id": "ROADMC01"
 391                     },
 392                     {
 393                         "dest-tp": "XPDR1-CLIENT1",
 394                         "src-tp": "XPDR1-NETWORK1",
 395                         "node-id": "XPDRC01"
 396                     }
 397                 ],
 398                 "center-freq": 196.1,
 399                 "width": 40,
 400                 "min-freq": 196.075,
 401                 "max-freq": 196.125,
 402                 "lower-spectral-slot-number": 761,
 403                 "higher-spectral-slot-number": 768
 404             }
 405         }
 406         response = test_utils.post_request(url, data)
 407         print(response.json())
 408         self.assertEqual(response.status_code, requests.codes.ok)
 409         res = response.json()
 410         self.assertIn('Success', res["output"]["result"])
 411
 412     def test_27_get_roadmconnection_ROADMA(self):
 413         response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
 414         self.assertEqual(response.status_code, requests.codes.ok)
 415         res = response.json()
 416         self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
 417         self.assertEqual(-60, res['roadm-connections'][0]['target-output-power'])
 418
 419     def test_28_get_roadmconnection_ROADMC(self):
 420         response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768")
 421         self.assertEqual(response.status_code, requests.codes.ok)
 422         res = response.json()
 423         self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
 424
 425     def test_29_servicePath_delete_AToZ(self):
 426         response = test_utils.service_path_request("delete", "test", "1",
 427                                                    [{"node-id": "XPDRA01",
 428                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 429                                                     {"node-id": "ROADMA01",
 430                                                      "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 431                                                     {"node-id": "ROADMC01",
 432                                                      "dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG2-TTP-TXRX"},
 433                                                     {"node-id": "XPDRC01",
 434                                                      "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
 435                                                     196.1, 40, 196.075, 196.125, 761,
 436                                                     768)
 437         self.assertEqual(response.status_code, requests.codes.ok)
 438         res = response.json()
 439         self.assertIn('Request processed', res["output"]["result"])
 440         time.sleep(10)
 441
 442     def test_30_servicePath_delete_ZToA(self):
 443         response = test_utils.service_path_request("delete", "test", "1",
 444                                                    [{"node-id": "XPDRC01",
 445                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 446                                                     {"node-id": "ROADMC01",
 447                                                      "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 448                                                     {"node-id": "ROADMA01",
 449                                                      "src-tp": "DEG1-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
 450                                                     {"node-id": "XPDRA01",
 451                                                      "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
 452                                                     196.1, 40, 196.075, 196.125, 761,
 453                                                     768)
 454         self.assertEqual(response.status_code, requests.codes.ok)
 455         res = response.json()
 456         self.assertIn('Request processed', res["output"]["result"])
 457         time.sleep(10)
 458
 459     #"""to test case where SRG where the xpdr is connected to has no optical range data"""
 460
 461     def test_31_connect_xprdA_to_roadmA(self):
 462         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "2",
 463                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 464         self.assertEqual(response.status_code, requests.codes.ok)
 465         res = response.json()
 466         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
 467
 468     def test_32_connect_roadmA_to_xpdrA(self):
 469         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "2",
 470                                                           "ROADMA01", "1", "SRG1-PP2-TXRX")
 471         self.assertEqual(response.status_code, requests.codes.ok)
 472         res = response.json()
 473         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
 474
 475     def test_33_servicePath_create_AToZ(self):
 476         response = test_utils.service_path_request("create", "test2", "2",
 477                                                    [{"node-id": "XPDRA01",
 478                                                      "dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
 479                                                     {"node-id": "ROADMA01",
 480                                                      "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
 481                                                     196.05, 40, 196.025, 196.075, 753,
 482                                                     760)
 483         self.assertEqual(response.status_code, requests.codes.ok)
 484         res = response.json()
 485         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 486         # time.sleep(40)
 487         time.sleep(10)
 488
 489     def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
 490         response = test_utils.check_netconf_node_request(
 491             "XPDRA01",
 492             "interface/XPDR1-NETWORK2-753:760/org-openroadm-optical-channel-interfaces:och")
 493         self.assertEqual(response.status_code, requests.codes.ok)
 494         res = response.json()
 495         self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 496         self.assertEqual(2, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 497
 498     def test_35_servicePath_delete_AToZ(self):
 499         response = test_utils.service_path_request("delete", "test", "1",
 500                                                    [{"node-id": "XPDRA01",
 501                                                      "dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
 502                                                     {"node-id": "ROADMA01",
 503                                                      "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
 504                                                     196.1, 40, 196.075, 196.125, 761,
 505                                                     768)
 506         self.assertEqual(response.status_code, requests.codes.ok)
 507         res = response.json()
 508         self.assertIn('Request processed', res["output"]["result"])
 509         time.sleep(10)
 510
 511     def test_36_xpdrA_device_disconnected(self):
 512         response = test_utils.unmount_device("XPDRA01")
 513         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 514
 515     def test_37_xpdrC_device_disconnected(self):
 516         response = test_utils.unmount_device("XPDRC01")
 517         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 518
 519     def test_38_calculate_span_loss_current(self):
 520         url = "{}/operations/transportpce-olm:calculate-spanloss-current"
 521         response = test_utils.post_request(url, None)
 522         self.assertEqual(response.status_code, requests.codes.ok)
 523         res = response.json()
 524         self.assertIn('Success',
 525                       res["output"]["result"])
 526         time.sleep(5)
 527
 528     def test_39_rdmA_device_disconnected(self):
 529         response = test_utils.unmount_device("ROADMA01")
 530         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 531
 532     def test_40_rdmC_device_disconnected(self):
 533         response = test_utils.unmount_device("ROADMC01")
 534         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 535
 536
 537 if __name__ == "__main__":
 538     unittest.main(verbosity=2)