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