tests/transportpce_tests/2.2.1/test_otn_sh_renderer.py

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