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