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