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_rfc8040  # 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_rfc8040.start_tpce()
  34         cls.processes = test_utils_rfc8040.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_rfc8040.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_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
  53         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
  54
  55     def test_02_xpdrC_device_connected(self):
  56         response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION))
  57         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
  58
  59     def test_03_rdmA_device_connected(self):
  60         response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
  61         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
  62
  63     def test_04_rdmC_device_connected(self):
  64         response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
  65         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
  66
  67     def test_05_connect_xprdA_to_roadmA(self):
  68         response = test_utils_rfc8040.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_rfc8040.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_xprdC_to_roadmC(self):
  82         response = test_utils_rfc8040.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_rfc8040.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_rfc8040.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_rfc8040.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_rfc8040.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         self.assertIn({
 127             'pmparameter-name': 'OpticalPowerOutput',
 128             'pmparameter-value': '2.5'
 129         }, response['output']['measurements'])
 130         self.assertIn({
 131             'pmparameter-name': 'OpticalReturnLoss',
 132             'pmparameter-value': '40'
 133         }, response['output']['measurements'])
 134         self.assertIn({
 135             'pmparameter-name': 'OpticalPowerInput',
 136             'pmparameter-value': '-21.1'
 137         }, response['output']['measurements'])
 138
 139     def test_12_get_PM_ROADMC(self):
 140         response = test_utils_rfc8040.transportpce_api_rpc_request(
 141             'transportpce-olm', 'get-pm',
 142             {
 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         self.assertEqual(response['status_code'], requests.codes.ok)
 151         self.assertIn({
 152             'pmparameter-name': 'OpticalPowerOutput',
 153             'pmparameter-value': '4.6'
 154         }, response['output']['measurements'])
 155         self.assertIn({
 156             'pmparameter-name': 'OpticalReturnLoss',
 157             'pmparameter-value': '49.1'
 158         }, response['output']['measurements'])
 159         self.assertIn({
 160             'pmparameter-name': 'OpticalPowerInput',
 161             'pmparameter-value': '-15.1'
 162         }, response['output']['measurements'])
 163
 164     def test_13_calculate_span_loss_base_ROADMA_ROADMC(self):
 165         response = test_utils_rfc8040.transportpce_api_rpc_request(
 166             'transportpce-olm', 'calculate-spanloss-base',
 167             {
 168                 'src-type': 'link',
 169                 'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
 170             })
 171         self.assertEqual(response['status_code'], requests.codes.ok)
 172         self.assertIn('Success',
 173                       response['output']['result'])
 174         self.assertIn({
 175             'spanloss': '17.6',
 176             'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
 177         }, response['output']['spans'])
 178         time.sleep(5)
 179
 180     def test_14_calculate_span_loss_base_all(self):
 181         response = test_utils_rfc8040.transportpce_api_rpc_request(
 182             'transportpce-olm', 'calculate-spanloss-base',
 183             {
 184                 'src-type': 'all'
 185             })
 186         self.assertEqual(response['status_code'], requests.codes.ok)
 187         self.assertIn('Success',
 188                       response['output']['result'])
 189         self.assertIn({
 190             'spanloss': '25.7',
 191             'link-id': 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'
 192         }, response['output']['spans'])
 193         self.assertIn({
 194             'spanloss': '17.6',
 195             'link-id': 'ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX'
 196         }, response['output']['spans'])
 197         time.sleep(5)
 198
 199     def test_15_get_OTS_DEG2_TTP_TXRX_ROADMA(self):
 200         response = test_utils_rfc8040.check_node_attribute2_request(
 201             'ROADM-A1', 'interface', 'OTS-DEG2-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
 202         self.assertEqual(response['status_code'], requests.codes.ok)
 203         self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 17.6)
 204         self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 25.7)
 205
 206     def test_16_get_OTS_DEG1_TTP_TXRX_ROADMC(self):
 207         response = test_utils_rfc8040.check_node_attribute2_request(
 208             'ROADM-C1', 'interface', 'OTS-DEG1-TTP-TXRX', 'org-openroadm-optical-transport-interfaces:ots')
 209         self.assertEqual(response['status_code'], requests.codes.ok)
 210         self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-transmit']), 25.7)
 211         self.assertEqual(float(response['org-openroadm-optical-transport-interfaces:ots']['span-loss-receive']), 17.6)
 212
 213     def test_17_servicePath_create_AToZ(self):
 214         response = test_utils_rfc8040.transportpce_api_rpc_request(
 215             'transportpce-device-renderer', 'service-path',
 216             {
 217                 'service-name': 'test',
 218                 'wave-number': '1',
 219                 'modulation-format': 'dp-qpsk',
 220                 'operation': 'create',
 221                 'nodes':
 222                 [{'node-id': 'XPDR-A1',
 223                   'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
 224                  {'node-id': 'ROADM-A1',
 225                     'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
 226                     {'node-id': 'ROADM-C1',
 227                      'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG1-TTP-TXRX'},
 228                     {'node-id': 'XPDR-C1',
 229                      'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
 230                 'center-freq': 196.1,
 231                 'nmc-width': 40,
 232                 'min-freq': 196.075,
 233                 'max-freq': 196.125,
 234                 'lower-spectral-slot-number': 761,
 235                 'higher-spectral-slot-number': 768
 236             })
 237         self.assertEqual(response['status_code'], requests.codes.ok)
 238         self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
 239         time.sleep(10)
 240
 241     def test_18_servicePath_create_ZToA(self):
 242         response = test_utils_rfc8040.transportpce_api_rpc_request(
 243             'transportpce-device-renderer', 'service-path',
 244             {
 245                 'service-name': 'test',
 246                 'wave-number': '1',
 247                 'modulation-format': 'dp-qpsk',
 248                 'operation': 'create',
 249                 'nodes':
 250                 [{'node-id': 'XPDR-C1',
 251                   'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
 252                  {'node-id': 'ROADM-C1',
 253                     'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
 254                     {'node-id': 'ROADM-A1',
 255                      'src-tp': 'DEG2-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
 256                     {'node-id': 'XPDR-A1',
 257                      'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
 258                 'center-freq': 196.1,
 259                 'nmc-width': 40,
 260                 'min-freq': 196.075,
 261                 'max-freq': 196.125,
 262                 'lower-spectral-slot-number': 761,
 263                 'higher-spectral-slot-number': 768
 264             })
 265         self.assertEqual(response['status_code'], requests.codes.ok)
 266         self.assertIn('Interfaces created successfully for nodes: ', response['output']['result'])
 267         time.sleep(10)
 268
 269     def test_19_service_power_setup_XPDRA_XPDRC(self):
 270         response = test_utils_rfc8040.transportpce_api_rpc_request(
 271             'transportpce-olm', 'service-power-setup',
 272             {
 273                 'service-name': 'test',
 274                 'wave-number': 1,
 275                 'nodes': [
 276                     {
 277                         'dest-tp': 'XPDR1-NETWORK1',
 278                         'src-tp': 'XPDR1-CLIENT1',
 279                         'node-id': 'XPDR-A1'
 280                     },
 281                     {
 282                         'dest-tp': 'DEG2-TTP-TXRX',
 283                         'src-tp': 'SRG1-PP1-TXRX',
 284                         'node-id': 'ROADM-A1'
 285                     },
 286                     {
 287                         'dest-tp': 'SRG1-PP1-TXRX',
 288                         'src-tp': 'DEG1-TTP-TXRX',
 289                         'node-id': 'ROADM-C1'
 290                     },
 291                     {
 292                         'dest-tp': 'XPDR1-CLIENT1',
 293                         'src-tp': 'XPDR1-NETWORK1',
 294                         'node-id': 'XPDR-C1'
 295                     }
 296                 ],
 297                 'lower-spectral-slot-number': 761,
 298                 'higher-spectral-slot-number': 768
 299             })
 300         self.assertEqual(response['status_code'], requests.codes.ok)
 301         self.assertIn('Success', response['output']['result'])
 302
 303     def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
 304         response = test_utils_rfc8040.check_node_attribute2_request(
 305             'XPDR-A1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
 306         self.assertEqual(response['status_code'], requests.codes.ok)
 307         self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
 308         self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
 309
 310     def test_21_get_roadmconnection_ROADMA(self):
 311         response = test_utils_rfc8040.check_node_attribute_request(
 312             'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
 313         self.assertEqual(response['status_code'], requests.codes.ok)
 314         self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
 315         self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 0.21)
 316
 317     def test_22_get_roadmconnection_ROADMC(self):
 318         response = test_utils_rfc8040.check_node_attribute_request(
 319             'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
 320         self.assertEqual(response['status_code'], requests.codes.ok)
 321         self.assertEqual("power", response['roadm-connections'][0]['opticalControlMode'])
 322
 323     def test_23_service_power_setup_XPDRC_XPDRA(self):
 324         response = test_utils_rfc8040.transportpce_api_rpc_request(
 325             'transportpce-olm', 'service-power-setup',
 326             {
 327                 'service-name': 'test',
 328                 'wave-number': 1,
 329                 'nodes': [
 330                     {
 331                         'dest-tp': 'XPDR1-NETWORK1',
 332                         'src-tp': 'XPDR1-CLIENT1',
 333                         'node-id': 'XPDR-C1'
 334                     },
 335                     {
 336                         'dest-tp': 'DEG1-TTP-TXRX',
 337                         'src-tp': 'SRG1-PP1-TXRX',
 338                         'node-id': 'ROADM-C1'
 339                     },
 340                     {
 341                         'src-tp': 'DEG2-TTP-TXRX',
 342                         'dest-tp': 'SRG1-PP1-TXRX',
 343                         'node-id': 'ROADM-A1'
 344                     },
 345                     {
 346                         'src-tp': 'XPDR1-NETWORK1',
 347                         'dest-tp': 'XPDR1-CLIENT1',
 348                         'node-id': 'XPDR-A1'
 349                     }
 350                 ],
 351                 'lower-spectral-slot-number': 761,
 352                 'higher-spectral-slot-number': 768
 353             })
 354         self.assertEqual(response['status_code'], requests.codes.ok)
 355         self.assertIn('Success', response['output']['result'])
 356
 357     def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
 358         response = test_utils_rfc8040.check_node_attribute2_request(
 359             'XPDR-C1', 'interface', 'XPDR1-NETWORK1-761:768', 'org-openroadm-optical-channel-interfaces:och')
 360         self.assertEqual(response['status_code'], requests.codes.ok)
 361         self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
 362         self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['frequency']), 196.1)
 363
 364     def test_25_get_roadmconnection_ROADMC(self):
 365         response = test_utils_rfc8040.check_node_attribute_request(
 366             'ROADM-C1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768')
 367         self.assertEqual(response['status_code'], requests.codes.ok)
 368         self.assertEqual("gainLoss", response['roadm-connections'][0]['opticalControlMode'])
 369         self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), 2.0)
 370
 371     def test_26_service_power_turndown_XPDRA_XPDRC(self):
 372         response = test_utils_rfc8040.transportpce_api_rpc_request(
 373             'transportpce-olm', 'service-power-turndown',
 374             {
 375                 'service-name': 'test',
 376                 'wave-number': 1,
 377                 'nodes': [
 378                     {
 379                         'dest-tp': 'XPDR1-NETWORK1',
 380                         'src-tp': 'XPDR1-CLIENT1',
 381                         'node-id': 'XPDR-A1'
 382                     },
 383                     {
 384                         'dest-tp': 'DEG2-TTP-TXRX',
 385                         'src-tp': 'SRG1-PP1-TXRX',
 386                         'node-id': 'ROADM-A1'
 387                     },
 388                     {
 389                         'dest-tp': 'SRG1-PP1-TXRX',
 390                         'src-tp': 'DEG1-TTP-TXRX',
 391                         'node-id': 'ROADM-C1'
 392                     },
 393                     {
 394                         'dest-tp': 'XPDR1-CLIENT1',
 395                         'src-tp': 'XPDR1-NETWORK1',
 396                         'node-id': 'XPDR-C1'
 397                     }
 398                 ],
 399                 'lower-spectral-slot-number': 761,
 400                 'higher-spectral-slot-number': 768
 401             })
 402         self.assertEqual(response['status_code'], requests.codes.ok)
 403         self.assertIn('Success', response['output']['result'])
 404
 405     def test_27_get_roadmconnection_ROADMA(self):
 406         response = test_utils_rfc8040.check_node_attribute_request(
 407             'ROADM-A1', 'roadm-connections', 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768')
 408         self.assertEqual(response['status_code'], requests.codes.ok)
 409         self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
 410         self.assertEqual(float(response['roadm-connections'][0]['target-output-power']), -60)
 411
 412     def test_28_get_roadmconnection_ROADMC(self):
 413         response = test_utils_rfc8040.check_node_attribute_request(
 414             'ROADM-C1', 'roadm-connections', 'DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768')
 415         self.assertEqual(response['status_code'], requests.codes.ok)
 416         self.assertEqual("off", response['roadm-connections'][0]['opticalControlMode'])
 417
 418     def test_29_servicePath_delete_AToZ(self):
 419         response = test_utils_rfc8040.transportpce_api_rpc_request(
 420             'transportpce-device-renderer', 'service-path',
 421             {
 422                 'service-name': 'test',
 423                 'wave-number': '1',
 424                 'modulation-format': 'dp-qpsk',
 425                 'operation': 'delete',
 426                 'nodes':
 427                 [{'node-id': 'XPDR-A1',
 428                   'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
 429                  {'node-id': 'ROADM-A1',
 430                     'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
 431                     {'node-id': 'ROADM-C1',
 432                      'dest-tp': 'SRG1-PP1-TXRX', 'src-tp': 'DEG1-TTP-TXRX'},
 433                     {'node-id': 'XPDR-C1',
 434                      'dest-tp': 'XPDR1-CLIENT1', 'src-tp': 'XPDR1-NETWORK1'}],
 435                 'center-freq': 196.1,
 436                 'nmc-width': 40,
 437                 'min-freq': 196.075,
 438                 'max-freq': 196.125,
 439                 'lower-spectral-slot-number': 761,
 440                 'higher-spectral-slot-number': 768
 441             })
 442         self.assertEqual(response['status_code'], requests.codes.ok)
 443         self.assertIn('Request processed', response['output']['result'])
 444         time.sleep(10)
 445
 446     def test_30_servicePath_delete_ZToA(self):
 447         response = test_utils_rfc8040.transportpce_api_rpc_request(
 448             'transportpce-device-renderer', 'service-path',
 449             {
 450                 'service-name': 'test',
 451                 'wave-number': '1',
 452                 'modulation-format': 'dp-qpsk',
 453                 'operation': 'delete',
 454                 'nodes':
 455                 [{'node-id': 'XPDR-C1',
 456                   'dest-tp': 'XPDR1-NETWORK1', 'src-tp': 'XPDR1-CLIENT1'},
 457                  {'node-id': 'ROADM-C1',
 458                     'dest-tp': 'DEG1-TTP-TXRX', 'src-tp': 'SRG1-PP1-TXRX'},
 459                     {'node-id': 'ROADM-A1',
 460                      'src-tp': 'DEG2-TTP-TXRX', 'dest-tp': 'SRG1-PP1-TXRX'},
 461                     {'node-id': 'XPDR-A1',
 462                      'src-tp': 'XPDR1-NETWORK1', 'dest-tp': 'XPDR1-CLIENT1'}],
 463                 'center-freq': 196.1,
 464                 'nmc-width': 40,
 465                 'min-freq': 196.075,
 466                 'max-freq': 196.125,
 467                 'lower-spectral-slot-number': 761,
 468                 'higher-spectral-slot-number': 768
 469             })
 470         self.assertEqual(response['status_code'], requests.codes.ok)
 471         self.assertIn('Request processed', response['output']['result'])
 472         time.sleep(10)
 473
 474    #"""to test case where SRG where the xpdr is connected to has no optical range data"""
 475
 476     def test_31_connect_xprdA_to_roadmA(self):
 477         response = test_utils_rfc8040.transportpce_api_rpc_request(
 478             'transportpce-networkutils', 'init-xpdr-rdm-links',
 479             {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2',
 480                              'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
 481         self.assertEqual(response['status_code'], requests.codes.ok)
 482
 483     def test_32_connect_roadmA_to_xpdrA(self):
 484         response = test_utils_rfc8040.transportpce_api_rpc_request(
 485             'transportpce-networkutils', 'init-rdm-xpdr-links',
 486             {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '2',
 487                              'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
 488         self.assertEqual(response['status_code'], requests.codes.ok)
 489
 490     def test_33_servicePath_create_AToZ(self):
 491         response = test_utils_rfc8040.transportpce_api_rpc_request(
 492             'transportpce-device-renderer', 'service-path',
 493             {
 494                 'service-name': 'test2',
 495                 'wave-number': '2',
 496                 'modulation-format': 'dp-qpsk',
 497                 'operation': 'create',
 498                 'nodes':
 499                 [{'node-id': 'XPDR-A1',
 500                   'dest-tp': 'XPDR1-NETWORK2', 'src-tp': 'XPDR1-CLIENT2'},
 501                  {'node-id': 'ROADM-A1',
 502                     'dest-tp': 'DEG2-TTP-TXRX', 'src-tp': 'SRG1-PP2-TXRX'}],
 503                 'center-freq': 196.1,
 504                 'nmc-width': 40,
 505                 'min-freq': 196.075,
 506                 'max-freq': 196.125,
 507                 'lower-spectral-slot-number': 753,
 508                 'higher-spectral-slot-number': 760
 509             })
 510         self.assertEqual(response['status_code'], requests.codes.ok)
 511         self.assertIn('Interfaces created successfully for nodes', response['output']['result'])
 512         time.sleep(10)
 513
 514     def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
 515         response = test_utils_rfc8040.check_node_attribute2_request(
 516             'XPDR-A1', 'interface', 'XPDR1-NETWORK2-753:760', 'org-openroadm-optical-channel-interfaces:och')
 517         self.assertEqual(response['status_code'], requests.codes.ok)
 518         self.assertEqual(float(response['org-openroadm-optical-channel-interfaces:och']['transmit-power']), -5)
 519 #         self.assertEqual(2, response['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
 520
 521     def test_35_servicePath_delete_AToZ(self):
 522         response = test_utils_rfc8040.transportpce_api_rpc_request(
 523             'transportpce-device-renderer', 'service-path',
 524             {
 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         response = test_utils_rfc8040.transportpce_api_rpc_request(
 555             'transportpce-olm', 'calculate-spanloss-current',
 556             None)
 557         self.assertEqual(response['status_code'], requests.codes.ok)
 558         self.assertIn('Success',
 559                       response["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)