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