tests/transportpce_tests/2.2.1/test08_otn_sh_renderer.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2020 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 TransportPCEtesting(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([('spdra', cls.NODE_VERSION),
  35                                                        ('spdrc', cls.NODE_VERSION)])
  36
  37     @classmethod
  38     def tearDownClass(cls):
  39         # pylint: disable=not-an-iterable
  40         for process in cls.processes:
  41             test_utils_rfc8040.shutdown_process(process)
  42         print("all processes killed")
  43
  44     def setUp(self):
  45         time.sleep(5)
  46
  47     def test_01_connect_SPDR_SA1(self):
  48         response = test_utils_rfc8040.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
  49         self.assertEqual(response.status_code, requests.codes.created,
  50                          test_utils_rfc8040.CODE_SHOULD_BE_201)
  51         time.sleep(10)
  52
  53         response = test_utils_rfc8040.check_device_connection("SPDR-SA1")
  54         self.assertEqual(response['status_code'], requests.codes.ok)
  55         self.assertEqual(response['connection-status'], 'connected')
  56
  57     def test_02_connect_SPDR_SC1(self):
  58         response = test_utils_rfc8040.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
  59         self.assertEqual(response.status_code, requests.codes.created,
  60                          test_utils_rfc8040.CODE_SHOULD_BE_201)
  61         time.sleep(10)
  62
  63         response = test_utils_rfc8040.check_device_connection("SPDR-SC1")
  64         self.assertEqual(response['status_code'], requests.codes.ok)
  65         self.assertEqual(response['connection-status'], 'connected')
  66
  67     def test_03_service_create_OTU4(self):
  68         response = test_utils_rfc8040.transportpce_api_rpc_request(
  69             'transportpce-renderer', 'service-implementation-request',
  70             {
  71                 'service-name': 'SPDRA-SPDRC-OTU4-ODU4',
  72                 'connection-type': 'infrastructure',
  73                 'service-handler-header': {
  74                     'request-id': 'abcd12-efgh34'
  75                 },
  76                 'service-a-end': {
  77                     'service-format': 'OTU',
  78                     'otu-service-rate': 'org-openroadm-otn-common-types:OTU4',
  79                     'clli': 'nodeSA',
  80                     'node-id': 'SPDR-SA1'
  81
  82                 },
  83                 'service-z-end': {
  84                     'service-format': 'OTU',
  85                     'otu-service-rate': 'org-openroadm-otn-common-types:OTU4',
  86                     'clli': 'nodeSC',
  87                     'node-id': 'SPDR-SC1'
  88                 },
  89                 'path-description': {
  90                     'aToZ-direction': {
  91                         'rate': 100,
  92                         'modulation-format': 'dp-qpsk',
  93                         'aToZ-wavelength-number': 1,
  94                         'aToZ': [
  95                             {
  96                                 'id': '0',
  97                                 'resource': {
  98                                     'tp-node-id': 'SPDR-SA1-XPDR1',
  99                                     'tp-id': ''
 100                                 }
 101                             },
 102                             {
 103                                 'id': '1',
 104                                 'resource': {
 105                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 106                                     'tp-id': 'XPDR1-NETWORK1'
 107                                 }
 108                             },
 109                             {
 110                                 'id': '2',
 111                                 'resource': {
 112                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 113                                     'tp-id': 'XPDR1-NETWORK1'
 114                                 }
 115                             },
 116                             {
 117                                 'id': '3',
 118                                 'resource': {
 119                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 120                                     'tp-id': ''
 121                                 }
 122                             }
 123                         ],
 124                         'aToZ-min-frequency': 196.075,
 125                         'aToZ-max-frequency': 196.125
 126                     },
 127                     'zToA-direction': {
 128                         'zToA-wavelength-number': '1',
 129                         'rate': '100',
 130                         'modulation-format': 'dp-qpsk',
 131                         'zToA': [
 132                             {
 133                                 'id': '0',
 134                                 'resource': {
 135                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 136                                     'tp-id': ''
 137                                 }
 138                             },
 139                             {
 140                                 'id': '1',
 141                                 'resource': {
 142                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 143                                     'tp-id': 'XPDR1-NETWORK1'
 144                                 }
 145                             },
 146                             {
 147                                 'id': '2',
 148                                 'resource': {
 149                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 150                                     'tp-id': 'XPDR1-NETWORK1'
 151                                 }
 152                             },
 153                             {
 154                                 'id': '3',
 155                                 'resource': {
 156                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 157                                     'tp-id': ''
 158                                 }
 159                             }
 160                         ],
 161                         'zToA-min-frequency': 196.075,
 162                         'zToA-max-frequency': 196.125
 163                     }
 164                 }
 165             })
 166         self.assertEqual(response['status_code'], requests.codes.ok)
 167         self.assertIn('Operation Successful',
 168                       response['output']['configuration-response-common']['response-message'])
 169
 170     # Test OCH-OTU interfaces on SPDR-A1
 171     def test_04_check_interface_och(self):
 172         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
 173         self.assertEqual(response['status_code'], requests.codes.ok)
 174         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
 175                                    'administrative-state': 'inService',
 176                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 177                                    'type': 'org-openroadm-interfaces:opticalChannel',
 178                                    'supporting-port': 'CP1-CFP0-P1'
 179                                    }, **response['interface'][0]),
 180                              response['interface'][0])
 181         self.assertIn(
 182             response['interface'][0]['org-openroadm-optical-channel-interfaces:och'],
 183             [{'frequency': '196.1000', 'rate': 'org-openroadm-common-types:R100G',
 184               'transmit-power': '-5', 'modulation-format': 'dp-qpsk'},
 185              {'frequency': 196.1, 'rate': 'org-openroadm-common-types:R100G',
 186               'transmit-power': -5, 'modulation-format': 'dp-qpsk'}])
 187
 188     def test_05_check_interface_OTU(self):
 189         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
 190         self.assertEqual(response['status_code'], requests.codes.ok)
 191         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 192                         'administrative-state': 'inService',
 193                         'supporting-circuit-pack-name': 'CP1-CFP0',
 194                         'supporting-interface': 'XPDR1-NETWORK1-1',
 195                         'type': 'org-openroadm-interfaces:otnOtu',
 196                         'supporting-port': 'CP1-CFP0-P1'
 197                         }
 198         input_dict_2 = {'tx-dapi': 'AMf1n5hK6Xkk',
 199                         'expected-sapi': 'AMf1n5hK6Xkk',
 200                         'tx-sapi': 'H/OelLynehI=',
 201                         'expected-dapi': 'H/OelLynehI=',
 202                         'rate': 'org-openroadm-otn-common-types:OTU4',
 203                         'fec': 'scfec'
 204                         }
 205         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 206                              response['interface'][0])
 207         self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
 208                              response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 209
 210     # Test OCH-OTU interfaces on SPDR-C1
 211     def test_06_check_interface_och(self):
 212         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-761:768")
 213         self.assertEqual(response['status_code'], requests.codes.ok)
 214         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
 215                                    'administrative-state': 'inService',
 216                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 217                                    'type': 'org-openroadm-interfaces:opticalChannel',
 218                                    'supporting-port': 'CP1-CFP0-P1'
 219                                    }, **response['interface'][0]),
 220                              response['interface'][0])
 221         self.assertIn(
 222             response['interface'][0]['org-openroadm-optical-channel-interfaces:och'],
 223             [{'frequency': '196.1000', 'rate': 'org-openroadm-common-types:R100G',
 224               'transmit-power': '-5', 'modulation-format': 'dp-qpsk'},
 225              {'frequency': 196.1, 'rate': 'org-openroadm-common-types:R100G',
 226               'transmit-power': -5, 'modulation-format': 'dp-qpsk'}])
 227
 228     def test_07_check_interface_OTU(self):
 229         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-OTU")
 230         self.assertEqual(response['status_code'], requests.codes.ok)
 231         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 232                         'administrative-state': 'inService',
 233                         'supporting-circuit-pack-name': 'CP1-CFP0',
 234                         'supporting-interface': 'XPDR1-NETWORK1-1',
 235                         'type': 'org-openroadm-interfaces:otnOtu',
 236                         'supporting-port': 'CP1-CFP0-P1'
 237                         }
 238         input_dict_2 = {'tx-dapi': 'H/OelLynehI=',
 239                         'expected-sapi': 'H/OelLynehI=',
 240                         'tx-sapi': 'AMf1n5hK6Xkk',
 241                         'expected-dapi': 'AMf1n5hK6Xkk',
 242                         'rate': 'org-openroadm-otn-common-types:OTU4',
 243                         'fec': 'scfec'
 244                         }
 245         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 246                              response['interface'][0])
 247         self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
 248                              response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 249
 250     # Test creation of ODU4 service
 251     def test_08_service_create_ODU4(self):
 252         response = test_utils_rfc8040.transportpce_api_rpc_request(
 253             'transportpce-renderer', 'service-implementation-request',
 254             {
 255                 'service-name':
 256                 'SPDRA-SPDRC-OTU4-ODU4',
 257                 'connection-type': 'infrastructure',
 258                 'service-handler-header': {
 259                     'request-id': 'abcd12-efgh34'
 260                 },
 261                 'service-a-end': {
 262                     'service-format': 'ODU',
 263                     'odu-service-rate':
 264                     'org-openroadm-otn-common-types:ODU4',
 265                     'clli': 'nodeSA',
 266                     'node-id': 'SPDR-SA1'
 267
 268                 },
 269                 'service-z-end': {
 270                     'service-format': 'ODU',
 271                     'odu-service-rate':
 272                     'org-openroadm-otn-common-types:ODU4',
 273                     'clli': 'nodeSC',
 274                     'node-id': 'SPDR-SC1'
 275                 },
 276                 'path-description': {
 277                     'aToZ-direction': {
 278                         'rate': 100,
 279                         'aToZ': [
 280                             {
 281                                 'id': '0',
 282                                 'resource': {
 283                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 284                                     'tp-id': ''
 285                                 }
 286                             },
 287                             {
 288                                 'id': '1',
 289                                 'resource': {
 290                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 291                                     'tp-id': 'XPDR1-NETWORK1'
 292                                 }
 293                             },
 294                             {
 295                                 'id': '2',
 296                                 'resource': {
 297                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 298                                     'tp-id': 'XPDR1-NETWORK1'
 299                                 }
 300                             },
 301                             {
 302                                 'id': '3',
 303                                 'resource': {
 304                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 305                                     'tp-id': ''
 306                                 }
 307                             }
 308                         ]
 309                     },
 310                     'zToA-direction': {
 311                         'rate': '100',
 312                         'zToA': [
 313                             {
 314                                 'id': '0',
 315                                 'resource': {
 316                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 317                                     'tp-id': ''
 318                                 }
 319                             },
 320                             {
 321                                 'id': '1',
 322                                 'resource': {
 323                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 324                                     'tp-id': 'XPDR1-NETWORK1'
 325                                 }
 326                             },
 327                             {
 328                                 'id': '2',
 329                                 'resource': {
 330                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 331                                     'tp-id': 'XPDR1-NETWORK1'
 332                                 }
 333                             },
 334                             {
 335                                 'id': '3',
 336                                 'resource': {
 337                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 338                                     'tp-id': ''
 339                                 }
 340                             }
 341                         ]
 342                     }
 343                 }
 344             })
 345         self.assertEqual(response['status_code'], requests.codes.ok)
 346         self.assertIn('Operation Successful',
 347                       response['output']['configuration-response-common']['response-message'])
 348
 349     # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
 350     def test_09_check_interface_ODU4(self):
 351         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
 352         self.assertEqual(response['status_code'], requests.codes.ok)
 353         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 354                         'administrative-state': 'inService',
 355                         'supporting-circuit-pack-name': 'CP1-CFP0',
 356                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 357                         'type': 'org-openroadm-interfaces:otnOdu',
 358                         'supporting-port': 'CP1-CFP0-P1'}
 359         # SAPI/DAPI are added in the Otu4 renderer
 360         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 361                         'rate': 'org-openroadm-otn-common-types:ODU4',
 362                         'expected-dapi': 'H/OelLynehI=',
 363                         'expected-sapi': 'AMf1n5hK6Xkk',
 364                         'tx-dapi': 'AMf1n5hK6Xkk',
 365                         'tx-sapi': 'H/OelLynehI='}
 366
 367         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 368                              response['interface'][0])
 369         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 370                                   **input_dict_2),
 371                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 372                              )
 373         self.assertDictEqual(
 374             {'payload-type': '21', 'exp-payload-type': '21'},
 375             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 376
 377     def test_10_check_interface_ODU4(self):
 378         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU4")
 379         self.assertEqual(response['status_code'], requests.codes.ok)
 380         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 381                         'administrative-state': 'inService',
 382                         'supporting-circuit-pack-name': 'CP1-CFP0',
 383                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 384                         'type': 'org-openroadm-interfaces:otnOdu',
 385                         'supporting-port': 'CP1-CFP0-P1'}
 386         # SAPI/DAPI are added in the Otu4 renderer
 387         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 388                         'rate': 'org-openroadm-otn-common-types:ODU4',
 389                         'tx-sapi': 'AMf1n5hK6Xkk',
 390                         'tx-dapi': 'H/OelLynehI=',
 391                         'expected-sapi': 'H/OelLynehI=',
 392                         'expected-dapi': 'AMf1n5hK6Xkk'
 393                         }
 394         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 395                              response['interface'][0])
 396         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 397                                   **input_dict_2),
 398                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 399                              )
 400         self.assertDictEqual(
 401             {'payload-type': '21', 'exp-payload-type': '21'},
 402             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 403
 404     # Test creation of 10G service
 405     def test_11_service_create_10GE(self):
 406         response = test_utils_rfc8040.transportpce_api_rpc_request(
 407             'transportpce-renderer', 'service-implementation-request',
 408             {
 409                 'service-name': 'SPDRA-SPDRC-10G',
 410                 'connection-type': 'service',
 411                 'service-handler-header': {
 412                     'request-id': 'abcd12-efgh34'
 413                 },
 414                 'service-a-end': {
 415                     'service-format': 'Ethernet',
 416                     'service-rate': '10',
 417                     'clli': 'nodeSA',
 418                     'node-id': 'SPDR-SA1'
 419                 },
 420                 'service-z-end': {
 421                     'service-format': 'Ethernet',
 422                     'service-rate': '10',
 423                     'clli': 'nodeSC',
 424                     'node-id': 'SPDR-SC1'
 425                 },
 426                 'path-description': {
 427                     'aToZ-direction': {
 428                         'rate': 10,
 429                         'min-trib-slot': '1.1',
 430                         'max-trib-slot': '1.8',
 431                         'aToZ': [
 432                             {
 433                                 'id': '0',
 434                                 'resource': {
 435                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 436                                     'tp-id': 'XPDR1-CLIENT1'
 437
 438                                 }
 439                             },
 440                             {
 441                                 'id': '1',
 442                                 'resource': {
 443                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 444                                     'tp-id': 'XPDR1-NETWORK1'
 445                                 }
 446                             },
 447                             {
 448                                 'id': '2',
 449                                 'resource': {
 450                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 451                                     'tp-id': 'XPDR1-NETWORK1'
 452                                 }
 453                             },
 454                             {
 455                                 'id': '3',
 456                                 'resource': {
 457                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 458                                     'tp-id': 'XPDR1-CLIENT1'
 459                                 }
 460                             }
 461                         ]
 462                     },
 463                     'zToA-direction': {
 464                         'rate': '10',
 465                         'min-trib-slot': '1.1',
 466                         'max-trib-slot': '1.8',
 467                         'zToA': [
 468                             {
 469                                 'id': '0',
 470                                 'resource': {
 471                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 472                                     'tp-id': 'XPDR1-CLIENT1'
 473                                 }
 474                             },
 475                             {
 476                                 'id': '1',
 477                                 'resource': {
 478                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 479                                     'tp-id': 'XPDR1-NETWORK1'
 480                                 }
 481                             },
 482                             {
 483                                 'id': '2',
 484                                 'resource': {
 485                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 486                                     'tp-id': 'XPDR1-NETWORK1'
 487                                 }
 488                             },
 489                             {
 490                                 'id': '3',
 491                                 'resource': {
 492                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 493                                     'tp-id': 'XPDR1-CLIENT1'
 494
 495                                 }
 496                             }
 497                         ]
 498                     }
 499                 }
 500             })
 501         self.assertEqual(response['status_code'], requests.codes.ok)
 502         self.assertIn('Operation Successful',
 503                       response['output']['configuration-response-common']['response-message'])
 504
 505     # Test the interfaces on SPDR-A1
 506     def test_12_check_interface_10GE_CLIENT(self):
 507         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
 508         self.assertEqual(response['status_code'], requests.codes.ok)
 509         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 510                       'administrative-state': 'inService',
 511                       'supporting-circuit-pack-name': 'CP1-SFP4',
 512                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 513                       'supporting-port': 'CP1-SFP4-P1'
 514                       }
 515         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 516                              response['interface'][0])
 517         self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
 518
 519     def test_13_check_interface_ODU2E_CLIENT(self):
 520         response = test_utils_rfc8040.check_node_attribute_request(
 521             "SPDR-SA1", "interface", "XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
 522         self.assertEqual(response['status_code'], requests.codes.ok)
 523         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
 524                         'administrative-state': 'inService',
 525                         'supporting-circuit-pack-name': 'CP1-SFP4',
 526                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 527                         'type': 'org-openroadm-interfaces:otnOdu',
 528                         'supporting-port': 'CP1-SFP4-P1'}
 529         input_dict_2 = {
 530             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 531             'rate': 'org-openroadm-otn-common-types:ODU2e',
 532             'monitoring-mode': 'terminated'}
 533
 534         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 535                              response['interface'][0])
 536         self.assertDictEqual(dict(input_dict_2,
 537                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 538                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 539         self.assertDictEqual(
 540             {'payload-type': '03', 'exp-payload-type': '03'},
 541             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 542
 543     def test_14_check_ODU2E_connection(self):
 544         response = test_utils_rfc8040.check_node_attribute_request(
 545             "SPDR-SA1",
 546             "odu-connection", "XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
 547         self.assertEqual(response['status_code'], requests.codes.ok)
 548         input_dict_1 = {
 549             'connection-name':
 550             'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
 551             'direction': 'bidirectional'
 552         }
 553         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 554                              response['odu-connection'][0])
 555         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
 556                              response['odu-connection'][0]['destination'])
 557         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
 558                              response['odu-connection'][0]['source'])
 559
 560     def test_15_check_interface_ODU2E_NETWORK(self):
 561         response = test_utils_rfc8040.check_node_attribute_request(
 562             "SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
 563         self.assertEqual(response['status_code'], requests.codes.ok)
 564         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
 565                         'administrative-state': 'inService',
 566                         'supporting-circuit-pack-name': 'CP1-CFP0',
 567                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 568                         'type': 'org-openroadm-interfaces:otnOdu',
 569                         'supporting-port': 'CP1-CFP0-P1'}
 570         input_dict_2 = {
 571             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 572             'rate': 'org-openroadm-otn-common-types:ODU2e',
 573             'monitoring-mode': 'monitored'}
 574         input_dict_3 = {'trib-port-number': 1}
 575         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 576                              response['interface'][0])
 577         self.assertDictEqual(dict(input_dict_2,
 578                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 579                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 580         self.assertDictEqual(dict(input_dict_3,
 581                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 582                                       'parent-odu-allocation']),
 583                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 584             'parent-odu-allocation'])
 585         self.assertIn(1,
 586                       response['interface'][0][
 587                           'org-openroadm-otn-odu-interfaces:odu'][
 588                           'parent-odu-allocation']['trib-slots'])
 589
 590     # Test the interfaces on SPDR-C1
 591     def test_16_check_interface_ODU2E_NETWORK(self):
 592         response = test_utils_rfc8040.check_node_attribute_request(
 593             "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
 594         self.assertEqual(response['status_code'], requests.codes.ok)
 595         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
 596                         'administrative-state': 'inService',
 597                         'supporting-circuit-pack-name': 'CP1-CFP0',
 598                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 599                         'type': 'org-openroadm-interfaces:otnOdu',
 600                         'supporting-port': 'CP1-CFP0-P1'}
 601         input_dict_2 = {
 602             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 603             'rate': 'org-openroadm-otn-common-types:ODU2e',
 604             'monitoring-mode': 'monitored'}
 605         input_dict_3 = {'trib-port-number': 1}
 606         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 607                              response['interface'][0])
 608         self.assertDictEqual(dict(input_dict_2,
 609                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 610                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 611         self.assertDictEqual(dict(input_dict_3,
 612                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 613                                       'parent-odu-allocation']),
 614                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 615             'parent-odu-allocation'])
 616         self.assertIn(1,
 617                       response['interface'][0][
 618                           'org-openroadm-otn-odu-interfaces:odu'][
 619                           'parent-odu-allocation']['trib-slots'])
 620
 621     def test_17_check_interface_10GE_CLIENT(self):
 622         response = test_utils_rfc8040.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
 623         self.assertEqual(response['status_code'], requests.codes.ok)
 624         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 625                       'administrative-state': 'inService',
 626                       'supporting-circuit-pack-name': 'CP1-SFP4',
 627                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 628                       'supporting-port': 'CP1-SFP4-P1'
 629                       }
 630         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 631                              response['interface'][0])
 632         self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
 633
 634     def test_18_check_interface_ODU2E_CLIENT(self):
 635         response = test_utils_rfc8040.check_node_attribute_request(
 636             "SPDR-SC1", "interface", "XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G")
 637         self.assertEqual(response['status_code'], requests.codes.ok)
 638         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
 639                         'administrative-state': 'inService',
 640                         'supporting-circuit-pack-name': 'CP1-SFP4',
 641                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 642                         'type': 'org-openroadm-interfaces:otnOdu',
 643                         'supporting-port': 'CP1-SFP4-P1'}
 644         input_dict_2 = {
 645             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 646             'rate': 'org-openroadm-otn-common-types:ODU2e',
 647             'monitoring-mode': 'terminated'}
 648         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 649                              response['interface'][0])
 650         self.assertDictEqual(dict(input_dict_2,
 651                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 652                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 653         self.assertDictEqual(
 654             {'payload-type': '03', 'exp-payload-type': '03'},
 655             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 656
 657     def test_19_check_ODU2E_connection(self):
 658         response = test_utils_rfc8040.check_node_attribute_request(
 659             "SPDR-SC1",
 660             "odu-connection", "XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
 661         self.assertEqual(response['status_code'], requests.codes.ok)
 662         input_dict_1 = {
 663             'connection-name':
 664             'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G-x-XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
 665             'direction': 'bidirectional'
 666         }
 667         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 668                              response['odu-connection'][0])
 669         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G'},
 670                              response['odu-connection'][0]['destination'])
 671         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G'},
 672                              response['odu-connection'][0]['source'])
 673
 674     def test_20_check_interface_ODU2E_NETWORK(self):
 675         response = test_utils_rfc8040.check_node_attribute_request(
 676             "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G")
 677         self.assertEqual(response['status_code'], requests.codes.ok)
 678         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA-SPDRC-10G',
 679                         'administrative-state': 'inService',
 680                         'supporting-circuit-pack-name': 'CP1-CFP0',
 681                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 682                         'type': 'org-openroadm-interfaces:otnOdu',
 683                         'supporting-port': 'CP1-CFP0-P1'}
 684         input_dict_2 = {
 685             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 686             'rate': 'org-openroadm-otn-common-types:ODU2e',
 687             'monitoring-mode': 'monitored'}
 688
 689         input_dict_3 = {'trib-port-number': 1}
 690
 691         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 692                              response['interface'][0])
 693         self.assertDictEqual(dict(input_dict_2,
 694                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 695                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 696         self.assertDictEqual(dict(input_dict_3,
 697                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 698                                       'parent-odu-allocation']),
 699                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 700             'parent-odu-allocation'])
 701         self.assertIn(1,
 702                       response['interface'][0][
 703                           'org-openroadm-otn-odu-interfaces:odu'][
 704                           'parent-odu-allocation']['trib-slots'])
 705
 706     # TODO: Delete the services (OTU, ODU, LO-ODU)
 707     # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
 708
 709     def test_21_disconnect_SPDR_SA1(self):
 710         response = test_utils_rfc8040.unmount_device("SPDR-SA1")
 711         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 712
 713     def test_22_disconnect_SPDR_SC1(self):
 714         response = test_utils_rfc8040.unmount_device("SPDR-SC1")
 715         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 716
 717
 718 if __name__ == "__main__":
 719     unittest.main(verbosity=2)