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