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