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(5)
  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(10)
  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(10)
  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
 170     # Test OCH-OTU interfaces on SPDR-A1
 171     def test_04_check_interface_och(self):
 172         response = test_utils.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         intf = response['interface'][0]['org-openroadm-optical-channel-interfaces:och']
 182         self.assertEqual(intf['rate'], 'org-openroadm-common-types:R100G')
 183         self.assertEqual(intf['modulation-format'], 'dp-qpsk')
 184         self.assertEqual(float(intf['frequency']), 196.1)
 185         self.assertEqual(float(intf['transmit-power']), -5)
 186
 187     def test_05_check_interface_OTU(self):
 188         response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-OTU")
 189         self.assertEqual(response['status_code'], requests.codes.ok)
 190         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 191                         'administrative-state': 'inService',
 192                         'supporting-circuit-pack-name': 'CP1-CFP0',
 193                         'supporting-interface': 'XPDR1-NETWORK1-1',
 194                         'type': 'org-openroadm-interfaces:otnOtu',
 195                         'supporting-port': 'CP1-CFP0-P1'
 196                         }
 197         input_dict_2 = {'tx-dapi': 'AMf1n5hK6Xkk',
 198                         'expected-sapi': 'AMf1n5hK6Xkk',
 199                         'tx-sapi': 'H/OelLynehI=',
 200                         'expected-dapi': 'H/OelLynehI=',
 201                         'rate': 'org-openroadm-otn-common-types:OTU4',
 202                         'fec': 'scfec'
 203                         }
 204         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 205                              response['interface'][0])
 206         self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
 207                              response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 208
 209     # Test OCH-OTU interfaces on SPDR-C1
 210     def test_06_check_interface_och(self):
 211         response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-761:768")
 212         self.assertEqual(response['status_code'], requests.codes.ok)
 213         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
 214                                    'administrative-state': 'inService',
 215                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 216                                    'type': 'org-openroadm-interfaces:opticalChannel',
 217                                    'supporting-port': 'CP1-CFP0-P1'
 218                                    }, **response['interface'][0]),
 219                              response['interface'][0])
 220         intf = response['interface'][0]['org-openroadm-optical-channel-interfaces:och']
 221         self.assertEqual(intf['rate'], 'org-openroadm-common-types:R100G')
 222         self.assertEqual(intf['modulation-format'], 'dp-qpsk')
 223         self.assertEqual(float(intf['frequency']), 196.1)
 224         self.assertEqual(float(intf['transmit-power']), -5)
 225
 226     def test_07_check_interface_OTU(self):
 227         response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-OTU")
 228         self.assertEqual(response['status_code'], requests.codes.ok)
 229         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 230                         'administrative-state': 'inService',
 231                         'supporting-circuit-pack-name': 'CP1-CFP0',
 232                         'supporting-interface': 'XPDR1-NETWORK1-1',
 233                         'type': 'org-openroadm-interfaces:otnOtu',
 234                         'supporting-port': 'CP1-CFP0-P1'
 235                         }
 236         input_dict_2 = {'tx-dapi': 'H/OelLynehI=',
 237                         'expected-sapi': 'H/OelLynehI=',
 238                         'tx-sapi': 'AMf1n5hK6Xkk',
 239                         'expected-dapi': 'AMf1n5hK6Xkk',
 240                         'rate': 'org-openroadm-otn-common-types:OTU4',
 241                         'fec': 'scfec'
 242                         }
 243         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 244                              response['interface'][0])
 245         self.assertDictEqual(dict(input_dict_2, **response['interface'][0]['org-openroadm-otn-otu-interfaces:otu']),
 246                              response['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 247
 248     # Test creation of ODU4 service
 249     def test_08_service_create_ODU4(self):
 250         response = test_utils.transportpce_api_rpc_request(
 251             'transportpce-renderer', 'service-implementation-request',
 252             {
 253                 'service-name':
 254                 'SPDRA-SPDRC-OTU4-ODU4',
 255                 'connection-type': 'infrastructure',
 256                 'service-handler-header': {
 257                     'request-id': 'abcd12-efgh34'
 258                 },
 259                 'service-a-end': {
 260                     'service-format': 'ODU',
 261                     'odu-service-rate':
 262                     'org-openroadm-otn-common-types:ODU4',
 263                     'clli': 'nodeSA',
 264                     'node-id': 'SPDR-SA1'
 265
 266                 },
 267                 'service-z-end': {
 268                     'service-format': 'ODU',
 269                     'odu-service-rate':
 270                     'org-openroadm-otn-common-types:ODU4',
 271                     'clli': 'nodeSC',
 272                     'node-id': 'SPDR-SC1'
 273                 },
 274                 'path-description': {
 275                     'aToZ-direction': {
 276                         'rate': 100,
 277                         'aToZ': [
 278                             {
 279                                 'id': '0',
 280                                 'resource': {
 281                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 282                                     'tp-id': ''
 283                                 }
 284                             },
 285                             {
 286                                 'id': '1',
 287                                 'resource': {
 288                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 289                                     'tp-id': 'XPDR1-NETWORK1'
 290                                 }
 291                             },
 292                             {
 293                                 'id': '2',
 294                                 'resource': {
 295                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 296                                     'tp-id': 'XPDR1-NETWORK1'
 297                                 }
 298                             },
 299                             {
 300                                 'id': '3',
 301                                 'resource': {
 302                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 303                                     'tp-id': ''
 304                                 }
 305                             }
 306                         ]
 307                     },
 308                     'zToA-direction': {
 309                         'rate': '100',
 310                         'zToA': [
 311                             {
 312                                 'id': '0',
 313                                 'resource': {
 314                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 315                                     'tp-id': ''
 316                                 }
 317                             },
 318                             {
 319                                 'id': '1',
 320                                 'resource': {
 321                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 322                                     'tp-id': 'XPDR1-NETWORK1'
 323                                 }
 324                             },
 325                             {
 326                                 'id': '2',
 327                                 'resource': {
 328                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 329                                     'tp-id': 'XPDR1-NETWORK1'
 330                                 }
 331                             },
 332                             {
 333                                 'id': '3',
 334                                 'resource': {
 335                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 336                                     'tp-id': ''
 337                                 }
 338                             }
 339                         ]
 340                     }
 341                 }
 342             })
 343         self.assertEqual(response['status_code'], requests.codes.ok)
 344         self.assertIn('Operation Successful',
 345                       response['output']['configuration-response-common']['response-message'])
 346
 347     # Test ODU4 interfaces on SPDR-A1 and SPDR-C1
 348     def test_09_check_interface_ODU4(self):
 349         response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU4")
 350         self.assertEqual(response['status_code'], requests.codes.ok)
 351         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 352                         'administrative-state': 'inService',
 353                         'supporting-circuit-pack-name': 'CP1-CFP0',
 354                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 355                         'type': 'org-openroadm-interfaces:otnOdu',
 356                         'supporting-port': 'CP1-CFP0-P1'}
 357         # SAPI/DAPI are added in the Otu4 renderer
 358         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 359                         'rate': 'org-openroadm-otn-common-types:ODU4',
 360                         'expected-dapi': 'H/OelLynehI=',
 361                         'expected-sapi': 'AMf1n5hK6Xkk',
 362                         'tx-dapi': 'AMf1n5hK6Xkk',
 363                         'tx-sapi': 'H/OelLynehI='}
 364
 365         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 366                              response['interface'][0])
 367         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 368                                   **input_dict_2),
 369                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 370                              )
 371         self.assertDictEqual(
 372             {'payload-type': '21', 'exp-payload-type': '21'},
 373             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 374
 375     def test_10_check_interface_ODU4(self):
 376         response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU4")
 377         self.assertEqual(response['status_code'], requests.codes.ok)
 378         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 379                         'administrative-state': 'inService',
 380                         'supporting-circuit-pack-name': 'CP1-CFP0',
 381                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 382                         'type': 'org-openroadm-interfaces:otnOdu',
 383                         'supporting-port': 'CP1-CFP0-P1'}
 384         # SAPI/DAPI are added in the Otu4 renderer
 385         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 386                         'rate': 'org-openroadm-otn-common-types:ODU4',
 387                         'tx-sapi': 'AMf1n5hK6Xkk',
 388                         'tx-dapi': 'H/OelLynehI=',
 389                         'expected-sapi': 'H/OelLynehI=',
 390                         'expected-dapi': 'AMf1n5hK6Xkk'
 391                         }
 392         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 393                              response['interface'][0])
 394         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 395                                   **input_dict_2),
 396                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 397                              )
 398         self.assertDictEqual(
 399             {'payload-type': '21', 'exp-payload-type': '21'},
 400             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 401
 402     # Test creation of 10G service
 403     def test_11_service_create_10GE(self):
 404         response = test_utils.transportpce_api_rpc_request(
 405             'transportpce-renderer', 'service-implementation-request',
 406             {
 407                 'service-name': 'SPDRA-SPDRC-10G',
 408                 'connection-type': 'service',
 409                 'service-handler-header': {
 410                     'request-id': 'abcd12-efgh34'
 411                 },
 412                 'service-a-end': {
 413                     'service-format': 'Ethernet',
 414                     'service-rate': '10',
 415                     'clli': 'nodeSA',
 416                     'node-id': 'SPDR-SA1'
 417                 },
 418                 'service-z-end': {
 419                     'service-format': 'Ethernet',
 420                     'service-rate': '10',
 421                     'clli': 'nodeSC',
 422                     'node-id': 'SPDR-SC1'
 423                 },
 424                 'path-description': {
 425                     'aToZ-direction': {
 426                         'rate': 10,
 427                         'min-trib-slot': '1.1',
 428                         'max-trib-slot': '1.8',
 429                         'aToZ': [
 430                             {
 431                                 'id': '0',
 432                                 'resource': {
 433                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 434                                     'tp-id': 'XPDR1-CLIENT1'
 435
 436                                 }
 437                             },
 438                             {
 439                                 'id': '1',
 440                                 'resource': {
 441                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 442                                     'tp-id': 'XPDR1-NETWORK1'
 443                                 }
 444                             },
 445                             {
 446                                 'id': '2',
 447                                 'resource': {
 448                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 449                                     'tp-id': 'XPDR1-NETWORK1'
 450                                 }
 451                             },
 452                             {
 453                                 'id': '3',
 454                                 'resource': {
 455                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 456                                     'tp-id': 'XPDR1-CLIENT1'
 457                                 }
 458                             }
 459                         ]
 460                     },
 461                     'zToA-direction': {
 462                         'rate': '10',
 463                         'min-trib-slot': '1.1',
 464                         'max-trib-slot': '1.8',
 465                         'zToA': [
 466                             {
 467                                 'id': '0',
 468                                 'resource': {
 469                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 470                                     'tp-id': 'XPDR1-CLIENT1'
 471                                 }
 472                             },
 473                             {
 474                                 'id': '1',
 475                                 'resource': {
 476                                     'tp-node-id': 'SPDR-SC1-XPDR1',
 477                                     'tp-id': 'XPDR1-NETWORK1'
 478                                 }
 479                             },
 480                             {
 481                                 'id': '2',
 482                                 'resource': {
 483                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 484                                     'tp-id': 'XPDR1-NETWORK1'
 485                                 }
 486                             },
 487                             {
 488                                 'id': '3',
 489                                 'resource': {
 490                                     'tp-node-id': 'SPDR-SA1-XPDR1',
 491                                     'tp-id': 'XPDR1-CLIENT1'
 492
 493                                 }
 494                             }
 495                         ]
 496                     }
 497                 }
 498             })
 499         self.assertEqual(response['status_code'], requests.codes.ok)
 500         self.assertIn('Operation Successful',
 501                       response['output']['configuration-response-common']['response-message'])
 502
 503     # Test the interfaces on SPDR-A1
 504     def test_12_check_interface_10GE_CLIENT(self):
 505         response = test_utils.check_node_attribute_request("SPDR-SA1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
 506         self.assertEqual(response['status_code'], requests.codes.ok)
 507         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 508                       'administrative-state': 'inService',
 509                       'supporting-circuit-pack-name': 'CP1-SFP4',
 510                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 511                       'supporting-port': 'CP1-SFP4-P1'
 512                       }
 513         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 514                              response['interface'][0])
 515         self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
 516
 517     def test_13_check_interface_ODU2E_CLIENT(self):
 518         response = test_utils.check_node_attribute_request(
 519             "SPDR-SA1", "interface", "XPDR1-CLIENT1-ODU2e")
 520         self.assertEqual(response['status_code'], requests.codes.ok)
 521         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e',
 522                         'administrative-state': 'inService',
 523                         'supporting-circuit-pack-name': 'CP1-SFP4',
 524                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 525                         'type': 'org-openroadm-interfaces:otnOdu',
 526                         'supporting-port': 'CP1-SFP4-P1'}
 527         input_dict_2 = {
 528             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 529             'rate': 'org-openroadm-otn-common-types:ODU2e',
 530             'monitoring-mode': 'terminated'}
 531
 532         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 533                              response['interface'][0])
 534         self.assertDictEqual(dict(input_dict_2,
 535                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 536                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 537         self.assertDictEqual(
 538             {'payload-type': '03', 'exp-payload-type': '03'},
 539             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 540
 541     def test_14_check_ODU2E_connection(self):
 542         response = test_utils.check_node_attribute_request(
 543             "SPDR-SA1",
 544             "odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
 545         self.assertEqual(response['status_code'], requests.codes.ok)
 546         input_dict_1 = {
 547             'connection-name':
 548             'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
 549             'direction': 'bidirectional'
 550         }
 551         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 552                              response['odu-connection'][0])
 553         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'},
 554                              response['odu-connection'][0]['destination'])
 555         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'},
 556                              response['odu-connection'][0]['source'])
 557
 558     def test_15_check_interface_ODU2E_NETWORK(self):
 559         response = test_utils.check_node_attribute_request(
 560             "SPDR-SA1", "interface", "XPDR1-NETWORK1-ODU2e")
 561         self.assertEqual(response['status_code'], requests.codes.ok)
 562         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
 563                         'administrative-state': 'inService',
 564                         'supporting-circuit-pack-name': 'CP1-CFP0',
 565                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 566                         'type': 'org-openroadm-interfaces:otnOdu',
 567                         'supporting-port': 'CP1-CFP0-P1'}
 568         input_dict_2 = {
 569             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 570             'rate': 'org-openroadm-otn-common-types:ODU2e',
 571             'monitoring-mode': 'monitored'}
 572         input_dict_3 = {'trib-port-number': 1}
 573         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 574                              response['interface'][0])
 575         self.assertDictEqual(dict(input_dict_2,
 576                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 577                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 578         self.assertDictEqual(dict(input_dict_3,
 579                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 580                                       'parent-odu-allocation']),
 581                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 582             'parent-odu-allocation'])
 583         self.assertIn(1,
 584                       response['interface'][0][
 585                           'org-openroadm-otn-odu-interfaces:odu'][
 586                           'parent-odu-allocation']['trib-slots'])
 587
 588     # Test the interfaces on SPDR-C1
 589     def test_16_check_interface_ODU2E_NETWORK(self):
 590         response = test_utils.check_node_attribute_request(
 591             "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e")
 592         self.assertEqual(response['status_code'], requests.codes.ok)
 593         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
 594                         'administrative-state': 'inService',
 595                         'supporting-circuit-pack-name': 'CP1-CFP0',
 596                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 597                         'type': 'org-openroadm-interfaces:otnOdu',
 598                         'supporting-port': 'CP1-CFP0-P1'}
 599         input_dict_2 = {
 600             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 601             'rate': 'org-openroadm-otn-common-types:ODU2e',
 602             'monitoring-mode': 'monitored'}
 603         input_dict_3 = {'trib-port-number': 1}
 604         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 605                              response['interface'][0])
 606         self.assertDictEqual(dict(input_dict_2,
 607                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 608                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 609         self.assertDictEqual(dict(input_dict_3,
 610                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 611                                       'parent-odu-allocation']),
 612                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 613             'parent-odu-allocation'])
 614         self.assertIn(1,
 615                       response['interface'][0][
 616                           'org-openroadm-otn-odu-interfaces:odu'][
 617                           'parent-odu-allocation']['trib-slots'])
 618
 619     def test_17_check_interface_10GE_CLIENT(self):
 620         response = test_utils.check_node_attribute_request("SPDR-SC1", "interface", "XPDR1-CLIENT1-ETHERNET10G")
 621         self.assertEqual(response['status_code'], requests.codes.ok)
 622         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 623                       'administrative-state': 'inService',
 624                       'supporting-circuit-pack-name': 'CP1-SFP4',
 625                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 626                       'supporting-port': 'CP1-SFP4-P1'
 627                       }
 628         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 629                              response['interface'][0])
 630         self.assertEqual(response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'], 10000)
 631
 632     def test_18_check_interface_ODU2E_CLIENT(self):
 633         response = test_utils.check_node_attribute_request(
 634             "SPDR-SC1", "interface", "XPDR1-CLIENT1-ODU2e")
 635         self.assertEqual(response['status_code'], requests.codes.ok)
 636         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e',
 637                         'administrative-state': 'inService',
 638                         'supporting-circuit-pack-name': 'CP1-SFP4',
 639                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 640                         'type': 'org-openroadm-interfaces:otnOdu',
 641                         'supporting-port': 'CP1-SFP4-P1'}
 642         input_dict_2 = {
 643             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 644             'rate': 'org-openroadm-otn-common-types:ODU2e',
 645             'monitoring-mode': 'terminated'}
 646         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 647                              response['interface'][0])
 648         self.assertDictEqual(dict(input_dict_2,
 649                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 650                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 651         self.assertDictEqual(
 652             {'payload-type': '03', 'exp-payload-type': '03'},
 653             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 654
 655     def test_19_check_ODU2E_connection(self):
 656         response = test_utils.check_node_attribute_request(
 657             "SPDR-SC1",
 658             "odu-connection", "XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e")
 659         self.assertEqual(response['status_code'], requests.codes.ok)
 660         input_dict_1 = {
 661             'connection-name':
 662             'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
 663             'direction': 'bidirectional'
 664         }
 665         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 666                              response['odu-connection'][0])
 667         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'},
 668                              response['odu-connection'][0]['destination'])
 669         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'},
 670                              response['odu-connection'][0]['source'])
 671
 672     def test_20_check_interface_ODU2E_NETWORK(self):
 673         response = test_utils.check_node_attribute_request(
 674             "SPDR-SC1", "interface", "XPDR1-NETWORK1-ODU2e")
 675         self.assertEqual(response['status_code'], requests.codes.ok)
 676         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
 677                         'administrative-state': 'inService',
 678                         'supporting-circuit-pack-name': 'CP1-CFP0',
 679                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 680                         'type': 'org-openroadm-interfaces:otnOdu',
 681                         'supporting-port': 'CP1-CFP0-P1'}
 682         input_dict_2 = {
 683             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 684             'rate': 'org-openroadm-otn-common-types:ODU2e',
 685             'monitoring-mode': 'monitored'}
 686
 687         input_dict_3 = {'trib-port-number': 1}
 688
 689         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 690                              response['interface'][0])
 691         self.assertDictEqual(dict(input_dict_2,
 692                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 693                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 694         self.assertDictEqual(dict(input_dict_3,
 695                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 696                                       'parent-odu-allocation']),
 697                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 698             'parent-odu-allocation'])
 699         self.assertIn(1,
 700                       response['interface'][0][
 701                           'org-openroadm-otn-odu-interfaces:odu'][
 702                           'parent-odu-allocation']['trib-slots'])
 703
 704     # TODO: Delete the services (OTU, ODU, LO-ODU)
 705     # TODO: Delete interfaces (SPDR-A1, SPDR-C1)
 706
 707     def test_21_disconnect_SPDR_SA1(self):
 708         response = test_utils.unmount_device("SPDR-SA1")
 709         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 710
 711     def test_22_disconnect_SPDR_SC1(self):
 712         response = test_utils.unmount_device("SPDR-SC1")
 713         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 714
 715
 716 if __name__ == "__main__":
 717     unittest.main(verbosity=2)