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  # 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.start_tpce()
  34         cls.processes = test_utils.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.shutdown_process(process)
  42         print("all processes killed")
  43
  44     def setUp(self):
  45         time.sleep(2)
  46
  47     def test_01_connect_SPDR_SA1(self):
  48         response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
  49         self.assertEqual(response.status_code, requests.codes.created,
  50                          test_utils.CODE_SHOULD_BE_201)
  51         time.sleep(5)
  52
  53         response = test_utils.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.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
  59         self.assertEqual(response.status_code, requests.codes.created,
  60                          test_utils.CODE_SHOULD_BE_201)
  61         time.sleep(5)
  62
  63         response = test_utils.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.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         time.sleep(2)
 170
 171     # Test OCH-OTU interfaces on SPDR-A1
 172     def test_04_check_interface_och(self):
 173         response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-761:768")
 174         self.assertEqual(response['status_code'], requests.codes.ok)
 175         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
 176                                    'administrative-state': 'inService',
 177                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 178                                    'type': 'org-openroadm-interfaces:opticalChannel',
 179                                    'supporting-port': 'CP1-CFP0-P1'
 180                                    }, **response['interface'][0]),
 181                              response['interface'][0])
 182         intf = response['interface'][0]['org-openroadm-optical-channel-interfaces:och']
 183         self.assertEqual(intf['rate'], 'org-openroadm-common-types:R100G')
 184         self.assertEqual(intf['modulation-format'], 'dp-qpsk')
 185         self.assertEqual(float(intf['frequency']), 196.1)
 186         self.assertEqual(float(intf['transmit-power']), -5)
 187
 188     def test_05_check_interface_OTU(self):
 189         response = test_utils.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.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         intf = response['interface'][0]['org-openroadm-optical-channel-interfaces:och']
 222         self.assertEqual(intf['rate'], 'org-openroadm-common-types:R100G')
 223         self.assertEqual(intf['modulation-format'], 'dp-qpsk')
 224         self.assertEqual(float(intf['frequency']), 196.1)
 225         self.assertEqual(float(intf['transmit-power']), -5)
 226
 227     def test_07_check_interface_OTU(self):
 228         response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-OTU")
 229         self.assertEqual(response['status_code'], requests.codes.ok)
 230         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 231                         'administrative-state': 'inService',
 232                         'supporting-circuit-pack-name': 'CP1-CFP0',
 233                         'supporting-interface': 'XPDR1-NETWORK1-1',
 234                         'type': 'org-openroadm-interfaces:otnOtu',
 235                         'supporting-port': 'CP1-CFP0-P1'
 236                         }
 237         input_dict_2 = {'tx-dapi': 'H/OelLynehI=',
 238                         'expected-sapi': 'H/OelLynehI=',
 239                         'tx-sapi': 'AMf1n5hK6Xkk',
 240                         'expected-dapi': 'AMf1n5hK6Xkk',
 241                         'rate': 'org-openroadm-otn-common-types:OTU4',
 242                         'fec': 'scfec'
 243                         }
 244         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 245                              response['interface'][0])
 246         self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
 247                              response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 248
 249     # Test creation of ODU4 service
 250     def test_08_service_create_ODU4(self):
 251         response = test_utils.transportpce_api_rpc_request(
 252             'transportpce-renderer', 'service-implementation-request',
 253             {
 254                 'service-name':
 255                 'SPDRA-SPDRC-OTU4-ODU4',
 256                 'connection-type': 'infrastructure',
 257                 'service-handler-header': {
 258                     'request-id': 'abcd12-efgh34'
 259                 },
 260                 'service-a-end': {
 261                     'service-format': 'ODU',
 262                     'odu-service-rate':
 263                     'org-openroadm-otn-common-types:ODU4',
 264                     'clli': 'nodeSA',
 265                     'node-id': 'SPDR-SA1'
 266
 267                 },
 268                 'service-z-end': {
 269                     'service-format': 'ODU',
 270                     'odu-service-rate':
 271                     'org-openroadm-otn-common-types:ODU4',
 272                     'clli': 'nodeSC',
 273                     'node-id': 'SPDR-SC1'
 274                 },
 275                 'path-description': {
 276                     'aToZ-direction': {
 277                         'rate': 100,
 278                         'aToZ': [
 279                             {
 280                                 'id': '0',
 281                                 'resource': {
 282                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 283                                     'tp-id': ''
 284                                 }
 285                             },
 286                             {
 287                                 'id': '1',
 288                                 'resource': {
 289                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 290                                     'tp-id': 'XPDR1-NETWORK1'
 291                                 }
 292                             },
 293                             {
 294                                 'id': '2',
 295                                 'resource': {
 296                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 297                                     'tp-id': 'XPDR1-NETWORK1'
 298                                 }
 299                             },
 300                             {
 301                                 'id': '3',
 302                                 'resource': {
 303                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 304                                     'tp-id': ''
 305                                 }
 306                             }
 307                         ]
 308                     },
 309                     'zToA-direction': {
 310                         'rate': '100',
 311                         'zToA': [
 312                             {
 313                                 'id': '0',
 314                                 'resource': {
 315                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 316                                     'tp-id': ''
 317                                 }
 318                             },
 319                             {
 320                                 'id': '1',
 321                                 'resource': {
 322                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 323                                     'tp-id': 'XPDR1-NETWORK1'
 324                                 }
 325                             },
 326                             {
 327                                 'id': '2',
 328                                 'resource': {
 329                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 330                                     'tp-id': 'XPDR1-NETWORK1'
 331                                 }
 332                             },
 333                             {
 334                                 'id': '3',
 335                                 'resource': {
 336                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 337                                     'tp-id': ''
 338                                 }
 339                             }
 340                         ]
 341                     }
 342                 }
 343             })
 344         self.assertEqual(response['status_code'], requests.codes.ok)
 345         self.assertIn('Operation Successful',
 346                       response['output']['configuration-response-common']['response-message'])
 347         time.sleep(2)
 348
 349     # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
 350     def test_09_check_interface_ODU4(self):
 351         response = test_utils.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.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.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         time.sleep(2)
 505
 506     # Test the interfaces on SPDR-A1
 507     def test_12_check_interface_10GE_CLIENT(self):
 508         response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
 509         self.assertEqual(response['status_code'], requests.codes.ok)
 510         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 511                       'administrative-state': 'inService',
 512                       'supporting-circuit-pack-name': 'CP1-SFP4',
 513                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 514                       'supporting-port': 'CP1-SFP4-P1'
 515                       }
 516         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 517                              response['interface'][0])
 518         self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
 519
 520     def test_13_check_interface_ODU2E_CLIENT(self):
 521         response = test_utils.check_node_attribute_request(
 522             "SPDR-SA1", "interface", "XPDR1-CLIENT1-ODU2e:SPDRA-SPDRC-10G")
 523         self.assertEqual(response['status_code'], requests.codes.ok)
 524         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e:SPDRA-SPDRC-10G',
 525                         'administrative-state': 'inService',
 526                         'supporting-circuit-pack-name': 'CP1-SFP4',
 527                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 528                         'type': 'org-openroadm-interfaces:otnOdu',
 529                         'supporting-port': 'CP1-SFP4-P1'}
 530         input_dict_2 = {
 531             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 532             'rate': 'org-openroadm-otn-common-types:ODU2e',
 533             'monitoring-mode': 'terminated'}
 534
 535         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 536                              response['interface'][0])
 537         self.assertDictEqual(dict(input_dict_2,
 538                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 539                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 540         self.assertDictEqual(
 541             {'payload-type': '03', 'exp-payload-type': '03'},
 542             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 543
 544     def test_14_check_ODU2E_connection(self):
 545         response = test_utils.check_node_attribute_request(
 546             "SPDR-SA1",
 547             "odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
 548         self.assertEqual(response['status_code'], requests.codes.ok)
 549         input_dict_1 = {
 550             'connection-name':
 551             'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
 552             'direction': 'bidirectional'
 553         }
 554         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 555                              response['odu-connection'][0])
 556         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G'},
 557                              response['odu-connection'][0]['destination'])
 558         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e:SPDRA-SPDRC-10G'},
 559                              response['odu-connection'][0]['source'])
 560
 561     def test_15_check_interface_ODU2E_NETWORK(self):
 562         response = test_utils.check_node_attribute_request(
 563             "SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G")
 564         self.assertEqual(response['status_code'], requests.codes.ok)
 565         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-SPDRA:SPDRC-10G',
 566                         'administrative-state': 'inService',
 567                         'supporting-circuit-pack-name': 'CP1-CFP0',
 568                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 569                         'type': 'org-openroadm-interfaces:otnOdu',
 570                         'supporting-port': 'CP1-CFP0-P1'}
 571         input_dict_2 = {
 572             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 573             'rate': 'org-openroadm-otn-common-types:ODU2e',
 574             'monitoring-mode': 'monitored'}
 575         input_dict_3 = {'trib-port-number': 1}
 576         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 577                              response['interface'][0])
 578         self.assertDictEqual(dict(input_dict_2,
 579                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 580                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 581         self.assertDictEqual(dict(input_dict_3,
 582                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 583                                       'parent-odu-allocation']),
 584                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 585             'parent-odu-allocation'])
 586         self.assertIn(1,
 587                       response['interface'][0][
 588                           'org-openroadm-otn-odu-interfaces:odu'][
 589                           'parent-odu-allocation']['trib-slots'])
 590
 591     # Test the interfaces on SPDR-C1
 592     def test_16_check_interface_ODU2E_NETWORK(self):
 593         response = test_utils.check_node_attribute_request(
 594             "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G")
 595         self.assertEqual(response['status_code'], requests.codes.ok)
 596         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G',
 597                         'administrative-state': 'inService',
 598                         'supporting-circuit-pack-name': 'CP1-CFP0',
 599                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 600                         'type': 'org-openroadm-interfaces:otnOdu',
 601                         'supporting-port': 'CP1-CFP0-P1'}
 602         input_dict_2 = {
 603             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 604             'rate': 'org-openroadm-otn-common-types:ODU2e',
 605             'monitoring-mode': 'monitored'}
 606         input_dict_3 = {'trib-port-number': 1}
 607         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 608                              response['interface'][0])
 609         self.assertDictEqual(dict(input_dict_2,
 610                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 611                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 612         self.assertDictEqual(dict(input_dict_3,
 613                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 614                                       'parent-odu-allocation']),
 615                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 616             'parent-odu-allocation'])
 617         self.assertIn(1,
 618                       response['interface'][0][
 619                           'org-openroadm-otn-odu-interfaces:odu'][
 620                           'parent-odu-allocation']['trib-slots'])
 621
 622     def test_17_check_interface_10GE_CLIENT(self):
 623         response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
 624         self.assertEqual(response['status_code'], requests.codes.ok)
 625         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 626                       'administrative-state': 'inService',
 627                       'supporting-circuit-pack-name': 'CP1-SFP4',
 628                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 629                       'supporting-port': 'CP1-SFP4-P1'
 630                       }
 631         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 632                              response['interface'][0])
 633         self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
 634
 635     def test_18_check_interface_ODU2E_CLIENT(self):
 636         response = test_utils.check_node_attribute_request(
 637             "SPDR-SC1", "interface", "XPDR1-CLIENT1-ODU2e:SPDRA-SPDRC-10G")
 638         self.assertEqual(response['status_code'], requests.codes.ok)
 639         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-SPDRA-SPDRC-10G',
 640                         'administrative-state': 'inService',
 641                         'supporting-circuit-pack-name': 'CP1-SFP4',
 642                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 643                         'type': 'org-openroadm-interfaces:otnOdu',
 644                         'supporting-port': 'CP1-SFP4-P1'}
 645         input_dict_2 = {
 646             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 647             'rate': 'org-openroadm-otn-common-types:ODU2e',
 648             'monitoring-mode': 'terminated'}
 649         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 650                              response['interface'][0])
 651         self.assertDictEqual(dict(input_dict_2,
 652                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 653                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 654         self.assertDictEqual(
 655             {'payload-type': '03', 'exp-payload-type': '03'},
 656             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 657
 658     def test_19_check_ODU2E_connection(self):
 659         response = test_utils.check_node_attribute_request(
 660             "SPDR-SC1",
 661             "odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
 662         self.assertEqual(response['status_code'], requests.codes.ok)
 663         input_dict_1 = {
 664             'connection-name':
 665             'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
 666             'direction': 'bidirectional'
 667         }
 668         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 669                              response['odu-connection'][0])
 670         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G'},
 671                              response['odu-connection'][0]['destination'])
 672         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e:SPDRA-SPDRC-10G'},
 673                              response['odu-connection'][0]['source'])
 674
 675     def test_20_check_interface_ODU2E_NETWORK(self):
 676         response = test_utils.check_node_attribute_request(
 677             "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G")
 678         self.assertEqual(response['status_code'], requests.codes.ok)
 679         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e:SPDRA-SPDRC-10G',
 680                         'administrative-state': 'inService',
 681                         'supporting-circuit-pack-name': 'CP1-CFP0',
 682                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 683                         'type': 'org-openroadm-interfaces:otnOdu',
 684                         'supporting-port': 'CP1-CFP0-P1'}
 685         input_dict_2 = {
 686             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 687             'rate': 'org-openroadm-otn-common-types:ODU2e',
 688             'monitoring-mode': 'monitored'}
 689
 690         input_dict_3 = {'trib-port-number': 1}
 691
 692         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 693                              response['interface'][0])
 694         self.assertDictEqual(dict(input_dict_2,
 695                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 696                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 697         self.assertDictEqual(dict(input_dict_3,
 698                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 699                                       'parent-odu-allocation']),
 700                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 701             'parent-odu-allocation'])
 702         self.assertIn(1,
 703                       response['interface'][0][
 704                           'org-openroadm-otn-odu-interfaces:odu'][
 705                           'parent-odu-allocation']['trib-slots'])
 706
 707     # TODO: Delete the services (OTU, ODU, LO-ODU)
 708     # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
 709
 710     def test_21_disconnect_SPDR_SA1(self):
 711         response = test_utils.unmount_device("SPDR-SA1")
 712         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 713
 714     def test_22_disconnect_SPDR_SC1(self):
 715         response = test_utils.unmount_device("SPDR-SC1")
 716         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 717
 718
 719 if __name__ == "__main__":
 720     unittest.main(verbosity=2)