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