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