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