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