tests/transportpce_tests/2.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', 'roadmc', '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("XPDR-A1", '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("XPDR-C1", '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("ROADM-A1", 'roadma')
  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("ROADM-C1", 'roadmc')
  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("XPDR-A1", "1", "1",
  56                                                           "ROADM-A1", "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("XPDR-A1", "1", "1",
  63                                                           "ROADM-A1", "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("XPDR-C1", "1", "1",
  70                                                           "ROADM-C1", "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("XPDR-C1", "1", "1",
  77                                                           "ROADM-C1", "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         response = test_utils.create_ots_oms_request("ROADM-A1", "DEG1-TTP-TXRX")
  84         time.sleep(10)
  85         self.assertEqual(response.status_code, requests.codes.ok)
  86         res = response.json()
  87         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-A1',
  88                       res["output"]["result"])
  89
  90     def test_10_create_OTS_ROADMC(self):
  91         response = test_utils.create_ots_oms_request("ROADM-C1", "DEG2-TTP-TXRX")
  92         self.assertEqual(response.status_code, requests.codes.ok)
  93         res = response.json()
  94         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1',
  95                       res["output"]["result"])
  96
  97     def test_11_get_PM_ROADMA(self):
  98         url = "{}/operations/transportpce-olm:get-pm"
  99         data = {
 100             "input": {
 101                 "node-id": "ROADM-A1",
 102                 "resource-type": "interface",
 103                 "granularity": "15min",
 104                 "resource-identifier": {
 105                     "resource-name": "OTS-DEG2-TTP-TXRX"
 106                 }
 107             }
 108         }
 109         response = test_utils.post_request(url, data)
 110         self.assertEqual(response.status_code, requests.codes.ok)
 111         res = response.json()
 112         self.assertIn({
 113             "pmparameter-name": "OpticalPowerOutput",
 114             "pmparameter-value": "2.5"
 115         }, res["output"]["measurements"])
 116         self.assertIn({
 117             "pmparameter-name": "OpticalReturnLoss",
 118             "pmparameter-value": "40"
 119         }, res["output"]["measurements"])
 120         self.assertIn({
 121             "pmparameter-name": "OpticalPowerInput",
 122             "pmparameter-value": "-21.1"
 123         }, res["output"]["measurements"])
 124
 125     def test_12_get_PM_ROADMC(self):
 126         url = "{}/operations/transportpce-olm:get-pm"
 127         data = {
 128             "input": {
 129                 "node-id": "ROADM-C1",
 130                 "resource-type": "interface",
 131                 "granularity": "15min",
 132                 "resource-identifier": {
 133                     "resource-name": "OTS-DEG1-TTP-TXRX"
 134                 }
 135             }
 136         }
 137         response = test_utils.post_request(url, data)
 138         self.assertEqual(response.status_code, requests.codes.ok)
 139         res = response.json()
 140         self.assertIn({
 141             "pmparameter-name": "OpticalPowerOutput",
 142             "pmparameter-value": "4.6"
 143         }, res["output"]["measurements"])
 144         self.assertIn({
 145             "pmparameter-name": "OpticalReturnLoss",
 146             "pmparameter-value": "49.1"
 147         }, res["output"]["measurements"])
 148         self.assertIn({
 149             "pmparameter-name": "OpticalPowerInput",
 150             "pmparameter-value": "-15.1"
 151         }, res["output"]["measurements"])
 152
 153     def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
 154         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
 155         data = {
 156             "input": {
 157                 "src-type": "link",
 158                 "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
 159             }
 160         }
 161         response = test_utils.post_request(url, data)
 162         self.assertEqual(response.status_code, requests.codes.ok)
 163         res = response.json()
 164         self.assertIn('Success',
 165                       res["output"]["result"])
 166         self.assertIn({
 167             "spanloss": "17.6",
 168             "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
 169         }, res["output"]["spans"])
 170         time.sleep(5)
 171
 172     def test_14_calculate_span_loss_base_all(self):
 173         url = "{}/operations/transportpce-olm:calculate-spanloss-base"
 174         data = {
 175             "input": {
 176                 "src-type": "all"
 177             }
 178         }
 179         response = test_utils.post_request(url, data)
 180         self.assertEqual(response.status_code, requests.codes.ok)
 181         res = response.json()
 182         self.assertIn('Success',
 183                       res["output"]["result"])
 184         self.assertIn({
 185             "spanloss": "25.7",
 186             "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX"
 187         }, res["output"]["spans"])
 188         self.assertIn({
 189             "spanloss": "17.6",
 190             "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
 191         }, res["output"]["spans"])
 192         time.sleep(5)
 193
 194     def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
 195         response = test_utils.check_netconf_node_request(
 196             "ROADM-A1",
 197             "interface/OTS-DEG2-TTP-TXRX/org-openroadm-optical-transport-interfaces:ots")
 198         self.assertEqual(response.status_code, requests.codes.ok)
 199         res = response.json()
 200         self.assertEqual(17.6, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
 201         self.assertEqual(25.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
 202
 203     def test_16_get_OTS_DEG1_TTP_TXRX_ROADMC(self):
 204         response = test_utils.check_netconf_node_request(
 205             "ROADM-C1",
 206             "interface/OTS-DEG1-TTP-TXRX/org-openroadm-optical-transport-interfaces:ots")
 207         self.assertEqual(response.status_code, requests.codes.ok)
 208         res = response.json()
 209         self.assertEqual(25.7, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit'])
 210         self.assertEqual(17.6, res['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive'])
 211
 212     def test_17_servicePath_create_AToZ(self):
 213         response = test_utils.service_path_request("create", "test", "1",
 214                                                    [{"node-id": "XPDR-A1",
 215                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 216                                                     {"node-id": "ROADM-A1",
 217                                                      "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 218                                                     {"node-id": "ROADM-C1",
 219                                                      "dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG1-TTP-TXRX"},
 220                                                     {"node-id": "XPDR-C1",
 221                                                      "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}])
 222         self.assertEqual(response.status_code, requests.codes.ok)
 223         res = response.json()
 224         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 225         # time.sleep(40)
 226         time.sleep(10)
 227
 228     def test_18_servicePath_create_ZToA(self):
 229         response = test_utils.service_path_request("create", "test", "1",
 230                                                    [{"node-id": "XPDR-C1",
 231                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 232                                                     {"node-id": "ROADM-C1",
 233                                                      "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 234                                                     {"node-id": "ROADM-A1",
 235                                                      "src-tp": "DEG2-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
 236                                                     {"node-id": "XPDR-A1",
 237                                                      "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}])
 238         self.assertEqual(response.status_code, requests.codes.ok)
 239         res = response.json()
 240         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 241         # time.sleep(40)
 242         time.sleep(10)
 243
 244     def test_19_service_power_setup_XPDRA_XPDRC(self):
 245         url = "{}/operations/transportpce-olm:service-power-setup"
 246         data = {
 247             "input": {
 248                 "service-name": "test",
 249                 "wave-number": 1,
 250                 "nodes": [
 251                     {
 252                         "dest-tp": "XPDR1-NETWORK1",
 253                         "src-tp": "XPDR1-CLIENT1",
 254                         "node-id": "XPDR-A1"
 255                     },
 256                     {
 257                         "dest-tp": "DEG2-TTP-TXRX",
 258                         "src-tp": "SRG1-PP1-TXRX",
 259                         "node-id": "ROADM-A1"
 260                     },
 261                     {
 262                         "dest-tp": "SRG1-PP1-TXRX",
 263                         "src-tp": "DEG1-TTP-TXRX",
 264                         "node-id": "ROADM-C1"
 265                     },
 266                     {
 267                         "dest-tp": "XPDR1-CLIENT1",
 268                         "src-tp": "XPDR1-NETWORK1",
 269                         "node-id": "XPDR-C1"
 270                     }
 271                 ]
 272             }
 273         }
 274         response = test_utils.post_request(url, data)
 275         self.assertEqual(response.status_code, requests.codes.ok)
 276         res = response.json()
 277         self.assertIn('Success', res["output"]["result"])
 278
 279     def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
 280         response = test_utils.check_netconf_node_request(
 281             "XPDR-A1",
 282             "interface/XPDR1-NETWORK1-1/org-openroadm-optical-channel-interfaces:och")
 283         self.assertEqual(response.status_code, requests.codes.ok)
 284         res = response.json()
 285         self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 286         self.assertEqual(196.1, res['org-openroadm-optical-channel-interfaces:och']['frequency'])
 287
 288     def test_21_get_roadmconnection_ROADMA(self):
 289         response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
 290         self.assertEqual(response.status_code, requests.codes.ok)
 291         res = response.json()
 292         self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
 293         self.assertEqual(2.0, res['roadm-connections'][0]['target-output-power'])
 294
 295     def test_22_get_roadmconnection_ROADMC(self):
 296         response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP1-TXRX-1")
 297         self.assertEqual(response.status_code, requests.codes.ok)
 298         res = response.json()
 299         self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
 300
 301     def test_23_service_power_setup_XPDRC_XPDRA(self):
 302         url = "{}/operations/transportpce-olm:service-power-setup"
 303         data = {
 304             "input": {
 305                 "service-name": "test",
 306                 "wave-number": 1,
 307                 "nodes": [
 308                     {
 309                         "dest-tp": "XPDR1-NETWORK1",
 310                         "src-tp": "XPDR1-CLIENT1",
 311                         "node-id": "XPDR-C1"
 312                     },
 313                     {
 314                         "dest-tp": "DEG1-TTP-TXRX",
 315                         "src-tp": "SRG1-PP1-TXRX",
 316                         "node-id": "ROADM-C1"
 317                     },
 318                     {
 319                         "src-tp": "DEG2-TTP-TXRX",
 320                         "dest-tp": "SRG1-PP1-TXRX",
 321                         "node-id": "ROADM-A1"
 322                     },
 323                     {
 324                         "src-tp": "XPDR1-NETWORK1",
 325                         "dest-tp": "XPDR1-CLIENT1",
 326                         "node-id": "XPDR-A1"
 327                     }
 328                 ]
 329             }
 330         }
 331         response = test_utils.post_request(url, data)
 332         self.assertEqual(response.status_code, requests.codes.ok)
 333         res = response.json()
 334         self.assertIn('Success', res["output"]["result"])
 335
 336     def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
 337         response = test_utils.check_netconf_node_request(
 338             "XPDR-C1",
 339             "interface/XPDR1-NETWORK1-1/org-openroadm-optical-channel-interfaces:och")
 340         self.assertEqual(response.status_code, requests.codes.ok)
 341         res = response.json()
 342         self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 343         self.assertEqual(196.1, res['org-openroadm-optical-channel-interfaces:och']['frequency'])
 344
 345     def test_25_get_roadmconnection_ROADMC(self):
 346         response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
 347         self.assertEqual(response.status_code, requests.codes.ok)
 348         res = response.json()
 349         self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
 350         self.assertEqual(2.0, res['roadm-connections'][0]['target-output-power'])
 351
 352     def test_26_service_power_turndown_XPDRA_XPDRC(self):
 353         url = "{}/operations/transportpce-olm:service-power-turndown"
 354         data = {
 355             "input": {
 356                 "service-name": "test",
 357                 "wave-number": 1,
 358                 "nodes": [
 359                     {
 360                         "dest-tp": "XPDR1-NETWORK1",
 361                         "src-tp": "XPDR1-CLIENT1",
 362                         "node-id": "XPDR-A1"
 363                     },
 364                     {
 365                         "dest-tp": "DEG2-TTP-TXRX",
 366                         "src-tp": "SRG1-PP1-TXRX",
 367                         "node-id": "ROADM-A1"
 368                     },
 369                     {
 370                         "dest-tp": "SRG1-PP1-TXRX",
 371                         "src-tp": "DEG1-TTP-TXRX",
 372                         "node-id": "ROADM-C1"
 373                     },
 374                     {
 375                         "dest-tp": "XPDR1-CLIENT1",
 376                         "src-tp": "XPDR1-NETWORK1",
 377                         "node-id": "XPDR-C1"
 378                     }
 379                 ]
 380             }
 381         }
 382         response = test_utils.post_request(url, data)
 383         self.assertEqual(response.status_code, requests.codes.ok)
 384         res = response.json()
 385         self.assertIn('Success', res["output"]["result"])
 386
 387     def test_27_get_roadmconnection_ROADMA(self):
 388         response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
 389         self.assertEqual(response.status_code, requests.codes.ok)
 390         res = response.json()
 391         self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
 392         self.assertEqual(-60, res['roadm-connections'][0]['target-output-power'])
 393
 394     def test_28_get_roadmconnection_ROADMC(self):
 395         response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP1-TXRX-1")
 396         self.assertEqual(response.status_code, requests.codes.ok)
 397         res = response.json()
 398         self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
 399
 400     def test_29_servicePath_delete_AToZ(self):
 401         response = test_utils.service_path_request("delete", "test", "1",
 402                                                    [{"node-id": "XPDR-A1",
 403                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 404                                                     {"node-id": "ROADM-A1",
 405                                                      "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 406                                                     {"node-id": "ROADM-C1",
 407                                                      "dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG1-TTP-TXRX"},
 408                                                     {"node-id": "XPDR-C1",
 409                                                      "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}])
 410         self.assertEqual(response.status_code, requests.codes.ok)
 411         res = response.json()
 412         self.assertIn('Request processed', res["output"]["result"])
 413         time.sleep(10)
 414
 415     def test_30_servicePath_delete_ZToA(self):
 416         response = test_utils.service_path_request("delete", "test", "1",
 417                                                    [{"node-id": "XPDR-C1",
 418                                                      "dest-tp": "XPDR1-NETWORK1", "src-tp": "XPDR1-CLIENT1"},
 419                                                     {"node-id": "ROADM-C1",
 420                                                      "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP1-TXRX"},
 421                                                     {"node-id": "ROADM-A1",
 422                                                      "src-tp": "DEG2-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
 423                                                     {"node-id": "XPDR-A1",
 424                                                      "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}])
 425         self.assertEqual(response.status_code, requests.codes.ok)
 426         res = response.json()
 427         self.assertIn('Request processed', res["output"]["result"])
 428         time.sleep(10)
 429
 430     """to test case where SRG where the xpdr is connected to has no optical range data"""
 431
 432     def test_31_connect_xprdA_to_roadmA(self):
 433         response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "2",
 434                                                           "ROADM-A1", "1", "SRG1-PP2-TXRX")
 435         self.assertEqual(response.status_code, requests.codes.ok)
 436         res = response.json()
 437         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
 438
 439     def test_32_connect_roadmA_to_xpdrA(self):
 440         response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "2",
 441                                                           "ROADM-A1", "1", "SRG1-PP2-TXRX")
 442         self.assertEqual(response.status_code, requests.codes.ok)
 443         res = response.json()
 444         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
 445
 446     def test_33_servicePath_create_AToZ(self):
 447         response = test_utils.service_path_request("create", "test2", "2",
 448                                                    [{"node-id": "XPDR-A1",
 449                                                      "dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
 450                                                     {"node-id": "ROADM-A1",
 451                                                      "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}])
 452         self.assertEqual(response.status_code, requests.codes.ok)
 453         res = response.json()
 454         self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
 455         # time.sleep(40)
 456         time.sleep(10)
 457
 458     def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
 459         response = test_utils.check_netconf_node_request(
 460             "XPDR-A1",
 461             "interface/XPDR1-NETWORK2-2/org-openroadm-optical-channel-interfaces:och")
 462         self.assertEqual(response.status_code, requests.codes.ok)
 463         res = response.json()
 464         self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
 465 #         self.assertEqual(2, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 466
 467     def test_35_servicePath_delete_AToZ(self):
 468         response = test_utils.service_path_request("delete", "test", "1",
 469                                                    [{"node-id": "XPDR-A1",
 470                                                      "dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
 471                                                     {"node-id": "ROADM-A1",
 472                                                      "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}])
 473         self.assertEqual(response.status_code, requests.codes.ok)
 474         res = response.json()
 475         self.assertIn('Request processed', res["output"]["result"])
 476         time.sleep(10)
 477
 478     def test_36_xpdrA_device_disconnected(self):
 479         response = test_utils.unmount_device("XPDR-A1")
 480         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 481
 482     def test_37_xpdrC_device_disconnected(self):
 483         response = test_utils.unmount_device("XPDR-C1")
 484         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 485
 486     def test_38_calculate_span_loss_current(self):
 487         url = "{}/operations/transportpce-olm:calculate-spanloss-current"
 488         response = test_utils.post_request(url, None)
 489         self.assertEqual(response.status_code, requests.codes.ok)
 490         res = response.json()
 491         self.assertIn('Success',
 492                       res["output"]["result"])
 493         time.sleep(5)
 494
 495     def test_39_rdmA_device_disconnected(self):
 496         response = test_utils.unmount_device("ROADM-A1")
 497         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 498
 499     def test_40_rdmC_device_disconnected(self):
 500         response = test_utils.unmount_device("ROADM-C1")
 501         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 502
 503
 504 if __name__ == "__main__":
 505     unittest.main(verbosity=2)