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