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