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