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