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