tests/transportpce_tests/2.2.1/test_otn_end2end.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     WAITING = 20  # nominal value is 300
  22
  23     @classmethod
  24     def setUpClass(cls):
  25         cls.processes = test_utils.start_tpce()
  26         cls.processes = test_utils.start_sims(['spdra', 'roadma', 'roadmc', 'spdrc'])
  27
  28     @classmethod
  29     def tearDownClass(cls):
  30         for process in cls.processes:
  31             test_utils.shutdown_process(process)
  32         print("all processes killed")
  33
  34     def setUp(self):
  35         time.sleep(5)
  36
  37     def test_01_connect_spdrA(self):
  38         response = test_utils.mount_device("SPDR-SA1", 'spdra')
  39         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  40
  41     def test_02_connect_spdrC(self):
  42         response = test_utils.mount_device("SPDR-SC1", 'spdrc')
  43         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  44
  45     def test_03_connect_rdmA(self):
  46         response = test_utils.mount_device("ROADM-A1", 'roadma')
  47         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  48
  49     def test_04_connect_rdmC(self):
  50         response = test_utils.mount_device("ROADM-C1", 'roadmc')
  51         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  52
  53     def test_05_connect_sprdA_N1_to_roadmA_PP1(self):
  54         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "1", "1",
  55                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
  56         self.assertEqual(response.status_code, requests.codes.ok)
  57         res = response.json()
  58         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
  59         time.sleep(2)
  60
  61     def test_06_connect_roadmA_PP1_to_spdrA_N1(self):
  62         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "1", "1",
  63                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
  64         self.assertEqual(response.status_code, requests.codes.ok)
  65         res = response.json()
  66         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
  67         time.sleep(2)
  68
  69     def test_07_connect_sprdC_N1_to_roadmC_PP1(self):
  70         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "1", "1",
  71                                                           "ROADM-C1", "1", "SRG1-PP1-TXRX")
  72         self.assertEqual(response.status_code, requests.codes.ok)
  73         res = response.json()
  74         self.assertIn('Xponder Roadm Link created successfully', res["output"]["result"])
  75         time.sleep(2)
  76
  77     def test_08_connect_roadmC_PP1_to_spdrC_N1(self):
  78         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "1", "1",
  79                                                           "ROADM-C1", "1", "SRG1-PP1-TXRX")
  80         self.assertEqual(response.status_code, requests.codes.ok)
  81         res = response.json()
  82         self.assertIn('Roadm Xponder links created successfully', res["output"]["result"])
  83         time.sleep(2)
  84
  85     def test_09_add_omsAttributes_ROADMA_ROADMC(self):
  86         # Config ROADMA-ROADMC oms-attributes
  87         data = {"span": {
  88             "auto-spanloss": "true",
  89             "spanloss-base": 11.4,
  90             "spanloss-current": 12,
  91             "engineered-spanloss": 12.2,
  92             "link-concatenation": [{
  93                 "SRLG-Id": 0,
  94                 "fiber-type": "smf",
  95                 "SRLG-length": 100000,
  96                 "pmd": 0.5}]}}
  97         response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
  98         self.assertEqual(response.status_code, requests.codes.created)
  99
 100     def test_10_add_omsAttributes_ROADMC_ROADMA(self):
 101         # Config ROADMC-ROADMA oms-attributes
 102         data = {"span": {
 103             "auto-spanloss": "true",
 104             "spanloss-base": 11.4,
 105             "spanloss-current": 12,
 106             "engineered-spanloss": 12.2,
 107             "link-concatenation": [{
 108                 "SRLG-Id": 0,
 109                 "fiber-type": "smf",
 110                 "SRLG-length": 100000,
 111                 "pmd": 0.5}]}}
 112         response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
 113         self.assertEqual(response.status_code, requests.codes.created)
 114
 115 # test service-create for OCH-OTU4 service from spdr to spdr
 116     def test_11_check_otn_topology(self):
 117         response = test_utils.get_otn_topo_request()
 118         self.assertEqual(response.status_code, requests.codes.ok)
 119         res = response.json()
 120         nbNode = len(res['network'][0]['node'])
 121         self.assertEqual(nbNode, 4)
 122         self.assertNotIn('ietf-network-topology:link', res['network'][0])
 123
 124     def test_12_create_OCH_OTU4_service(self):
 125         url = "{}/operations/org-openroadm-service:service-create"
 126         data = {"input": {
 127                 "sdnc-request-header": {
 128                     "request-id": "request-1",
 129                     "rpc-action": "service-create",
 130                     "request-system-id": "appname"
 131                 },
 132                 "service-name": "service1-OCH-OTU4",
 133                 "common-id": "commonId",
 134                 "connection-type": "infrastructure",
 135                 "service-a-end": {
 136                     "service-rate": "100",
 137                     "node-id": "SPDR-SA1",
 138                     "service-format": "OTU",
 139                     "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
 140                     "clli": "NodeSA",
 141                     "subrate-eth-sla": {
 142                         "subrate-eth-sla": {
 143                             "committed-info-rate": "100000",
 144                             "committed-burst-size": "64"
 145                         }
 146                     },
 147                     "tx-direction": {
 148                         "port": {
 149                             "port-device-name": "SPDR-SA1-XPDR1",
 150                             "port-type": "fixed",
 151                             "port-name": "XPDR1-NETWORK1",
 152                             "port-rack": "000000.00",
 153                             "port-shelf": "Chassis#1"
 154                         },
 155                         "lgx": {
 156                             "lgx-device-name": "Some lgx-device-name",
 157                             "lgx-port-name": "Some lgx-port-name",
 158                             "lgx-port-rack": "000000.00",
 159                             "lgx-port-shelf": "00"
 160                         }
 161                     },
 162                     "rx-direction": {
 163                         "port": {
 164                             "port-device-name": "SPDR-SA1-XPDR1",
 165                             "port-type": "fixed",
 166                             "port-name": "XPDR1-NETWORK1",
 167                             "port-rack": "000000.00",
 168                             "port-shelf": "Chassis#1"
 169                         },
 170                         "lgx": {
 171                             "lgx-device-name": "Some lgx-device-name",
 172                             "lgx-port-name": "Some lgx-port-name",
 173                             "lgx-port-rack": "000000.00",
 174                             "lgx-port-shelf": "00"
 175                         }
 176                     },
 177                     "optic-type": "gray"
 178                 },
 179                 "service-z-end": {
 180                     "service-rate": "100",
 181                     "node-id": "SPDR-SC1",
 182                     "service-format": "OTU",
 183                     "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
 184                     "clli": "NodeSC",
 185                     "subrate-eth-sla": {
 186                         "subrate-eth-sla": {
 187                             "committed-info-rate": "100000",
 188                             "committed-burst-size": "64"
 189                         }
 190                     },
 191                     "tx-direction": {
 192                         "port": {
 193                             "port-device-name": "SPDR-SC1-XPDR1",
 194                             "port-type": "fixed",
 195                             "port-name": "XPDR1-NETWORK1",
 196                             "port-rack": "000000.00",
 197                             "port-shelf": "Chassis#1"
 198                         },
 199                         "lgx": {
 200                             "lgx-device-name": "Some lgx-device-name",
 201                             "lgx-port-name": "Some lgx-port-name",
 202                             "lgx-port-rack": "000000.00",
 203                             "lgx-port-shelf": "00"
 204                         }
 205                     },
 206                     "rx-direction": {
 207                         "port": {
 208                             "port-device-name": "SPDR-SC1-XPDR1",
 209                             "port-type": "fixed",
 210                             "port-name": "XPDR1-NETWORK1",
 211                             "port-rack": "000000.00",
 212                             "port-shelf": "Chassis#1"
 213                         },
 214                         "lgx": {
 215                             "lgx-device-name": "Some lgx-device-name",
 216                             "lgx-port-name": "Some lgx-port-name",
 217                             "lgx-port-rack": "000000.00",
 218                             "lgx-port-shelf": "00"
 219                         }
 220                     },
 221                     "optic-type": "gray"
 222                 },
 223                 "due-date": "2018-06-15T00:00:01Z",
 224                 "operator-contact": "pw1234"
 225                 }
 226                 }
 227         response = test_utils.post_request(url, data)
 228         self.assertEqual(response.status_code, requests.codes.ok)
 229         res = response.json()
 230         self.assertIn('PCE calculation in progress',
 231                       res['output']['configuration-response-common']['response-message'])
 232         time.sleep(self.WAITING)
 233
 234     def test_13_get_OCH_OTU4_service1(self):
 235         url = "{}/operational/org-openroadm-service:service-list/services/service1-OCH-OTU4"
 236         response = test_utils.get_request(url)
 237         self.assertEqual(response.status_code, requests.codes.ok)
 238         res = response.json()
 239         self.assertEqual(
 240             res['services'][0]['administrative-state'], 'inService')
 241         self.assertEqual(
 242             res['services'][0]['service-name'], 'service1-OCH-OTU4')
 243         self.assertEqual(
 244             res['services'][0]['connection-type'], 'infrastructure')
 245         self.assertEqual(
 246             res['services'][0]['lifecycle-state'], 'planned')
 247         time.sleep(2)
 248
 249     # Check correct configuration of devices
 250     def test_14_check_interface_och_spdra(self):
 251         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
 252         self.assertEqual(response.status_code, requests.codes.ok)
 253         res = response.json()
 254         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
 255                                    'administrative-state': 'inService',
 256                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 257                                    'type': 'org-openroadm-interfaces:opticalChannel',
 258                                    'supporting-port': 'CP1-CFP0-P1'
 259                                    }, **res['interface'][0]),
 260                              res['interface'][0])
 261
 262         self.assertDictEqual(
 263             {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
 264              u'transmit-power': -5},
 265             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 266
 267     def test_15_check_interface_OTU4_spdra(self):
 268         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
 269         self.assertEqual(response.status_code, requests.codes.ok)
 270         res = response.json()
 271         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 272                         'administrative-state': 'inService',
 273                         'supporting-circuit-pack-name': 'CP1-CFP0',
 274                         'supporting-interface': 'XPDR1-NETWORK1-1',
 275                         'type': 'org-openroadm-interfaces:otnOtu',
 276                         'supporting-port': 'CP1-CFP0-P1'
 277                         }
 278         input_dict_2 = {'tx-sapi': 'Swfw02qXGyI=',
 279                         'expected-dapi': 'Swfw02qXGyI=',
 280                         'rate': 'org-openroadm-otn-common-types:OTU4',
 281                         'fec': 'scfec'
 282                         }
 283         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 284                              res['interface'][0])
 285
 286         self.assertDictEqual(input_dict_2,
 287                              res['interface'][0]
 288                              ['org-openroadm-otn-otu-interfaces:otu'])
 289
 290     def test_16_check_interface_och_spdrc(self):
 291         response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-1")
 292         self.assertEqual(response.status_code, requests.codes.ok)
 293         res = response.json()
 294         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
 295                                    'administrative-state': 'inService',
 296                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 297                                    'type': 'org-openroadm-interfaces:opticalChannel',
 298                                    'supporting-port': 'CP1-CFP0-P1'
 299                                    }, **res['interface'][0]),
 300                              res['interface'][0])
 301
 302         self.assertDictEqual(
 303             {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
 304              u'transmit-power': -5},
 305             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 306
 307     def test_17_check_interface_OTU4_spdrc(self):
 308         response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
 309         self.assertEqual(response.status_code, requests.codes.ok)
 310         res = response.json()
 311         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 312                         'administrative-state': 'inService',
 313                         'supporting-circuit-pack-name': 'CP1-CFP0',
 314                         'supporting-interface': 'XPDR1-NETWORK1-1',
 315                         'type': 'org-openroadm-interfaces:otnOtu',
 316                         'supporting-port': 'CP1-CFP0-P1'
 317                         }
 318         input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
 319                         'expected-sapi': 'Swfw02qXGyI=',
 320                         'tx-sapi': 'fuYZwEO660g=',
 321                         'expected-dapi': 'fuYZwEO660g=',
 322                         'rate': 'org-openroadm-otn-common-types:OTU4',
 323                         'fec': 'scfec'
 324                         }
 325
 326         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 327                              res['interface'][0])
 328
 329         self.assertDictEqual(input_dict_2,
 330                              res['interface'][0]
 331                              ['org-openroadm-otn-otu-interfaces:otu'])
 332
 333     def test_18_check_no_interface_ODU4_spdra(self):
 334         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
 335         self.assertEqual(response.status_code, requests.codes.not_found)
 336         res = response.json()
 337         self.assertIn(
 338             {"error-type": "application", "error-tag": "data-missing",
 339              "error-message": "Request could not be completed because the relevant data model content does not exist"},
 340             res['errors']['error'])
 341
 342     def test_19_check_openroadm_topo_spdra(self):
 343         response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR1")
 344         self.assertEqual(response.status_code, requests.codes.ok)
 345         res = response.json()
 346         ele = res['node'][0]['ietf-network-topology:termination-point'][0]
 347         self.assertEqual('XPDR1-NETWORK1', ele['tp-id'])
 348         self.assertEqual({u'frequency': 196.1,
 349                           u'width': 40},
 350                          ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 351         time.sleep(3)
 352
 353     def test_20_check_openroadm_topo_ROADMA_SRG(self):
 354         response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
 355         self.assertEqual(response.status_code, requests.codes.ok)
 356         res = response.json()
 357         self.assertNotIn({u'index': 1},
 358                          res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
 359         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 360         for ele in liste_tp:
 361             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 362                 self.assertIn({u'index': 1, u'frequency': 196.1,
 363                                u'width': 40},
 364                               ele['org-openroadm-network-topology:pp-attributes']['used-wavelength'])
 365             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 366                 self.assertNotIn('used-wavelength', dict.keys(ele))
 367         time.sleep(3)
 368
 369     def test_21_check_openroadm_topo_ROADMA_DEG(self):
 370         response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2")
 371         self.assertEqual(response.status_code, requests.codes.ok)
 372         res = response.json()
 373         self.assertNotIn({u'index': 1},
 374                          res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
 375         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 376         for ele in liste_tp:
 377             if ele['tp-id'] == 'DEG2-CTP-TXRX':
 378                 self.assertIn({u'index': 1, u'frequency': 196.1,
 379                                u'width': 40},
 380                               ele['org-openroadm-network-topology:ctp-attributes']['used-wavelengths'])
 381             if ele['tp-id'] == 'DEG2-TTP-TXRX':
 382                 self.assertIn({u'index': 1, u'frequency': 196.1,
 383                                u'width': 40},
 384                               ele['org-openroadm-network-topology:tx-ttp-attributes']['used-wavelengths'])
 385         time.sleep(3)
 386
 387     def test_22_check_otn_topo_otu4_links(self):
 388         response = test_utils.get_otn_topo_request()
 389         self.assertEqual(response.status_code, requests.codes.ok)
 390         res = response.json()
 391         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 392         self.assertEqual(nb_links, 2)
 393         listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 394                       'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1']
 395         for link in res['network'][0]['ietf-network-topology:link']:
 396             self.assertIn(link['link-id'], listLinkId)
 397             self.assertEqual(link['transportpce-topology:otn-link-type'], 'OTU4')
 398             self.assertEqual(link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 399             self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 400             self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 401             self.assertIn(link['org-openroadm-common-network:opposite-link'], listLinkId)
 402
 403 # test service-create for ODU4 service from spdr to spdr
 404     def test_23_create_ODU4_service(self):
 405         url = "{}/operations/org-openroadm-service:service-create"
 406         data = {"input": {
 407                 "sdnc-request-header": {
 408                     "request-id": "request-1",
 409                     "rpc-action": "service-create",
 410                     "request-system-id": "appname"
 411                 },
 412                 "service-name": "service1-ODU4",
 413                 "common-id": "commonId",
 414                 "connection-type": "infrastructure",
 415                 "service-a-end": {
 416                     "service-rate": "100",
 417                     "node-id": "SPDR-SA1",
 418                     "service-format": "ODU",
 419                     "odu-service-rate": "org-openroadm-otn-common-types:ODU4",
 420                     "clli": "NodeSA",
 421                     "subrate-eth-sla": {
 422                         "subrate-eth-sla": {
 423                             "committed-info-rate": "100000",
 424                             "committed-burst-size": "64"
 425                         }
 426                     },
 427                     "tx-direction": {
 428                         "port": {
 429                             "port-device-name": "SPDR-SA1-XPDR1",
 430                             "port-type": "fixed",
 431                             "port-name": "XPDR1-NETWORK1",
 432                             "port-rack": "000000.00",
 433                             "port-shelf": "Chassis#1"
 434                         },
 435                         "lgx": {
 436                             "lgx-device-name": "Some lgx-device-name",
 437                             "lgx-port-name": "Some lgx-port-name",
 438                             "lgx-port-rack": "000000.00",
 439                             "lgx-port-shelf": "00"
 440                         }
 441                     },
 442                     "rx-direction": {
 443                         "port": {
 444                             "port-device-name": "SPDR-SA1-XPDR1",
 445                             "port-type": "fixed",
 446                             "port-name": "XPDR1-NETWORK1",
 447                             "port-rack": "000000.00",
 448                             "port-shelf": "Chassis#1"
 449                         },
 450                         "lgx": {
 451                             "lgx-device-name": "Some lgx-device-name",
 452                             "lgx-port-name": "Some lgx-port-name",
 453                             "lgx-port-rack": "000000.00",
 454                             "lgx-port-shelf": "00"
 455                         }
 456                     },
 457                     "optic-type": "gray"
 458                 },
 459                 "service-z-end": {
 460                     "service-rate": "100",
 461                     "node-id": "SPDR-SC1",
 462                     "service-format": "ODU",
 463                     "odu-service-rate": "org-openroadm-otn-common-types:ODU4",
 464                     "clli": "NodeSC",
 465                     "subrate-eth-sla": {
 466                         "subrate-eth-sla": {
 467                             "committed-info-rate": "100000",
 468                             "committed-burst-size": "64"
 469                         }
 470                     },
 471                     "tx-direction": {
 472                         "port": {
 473                             "port-device-name": "SPDR-SC1-XPDR1",
 474                             "port-type": "fixed",
 475                             "port-name": "XPDR1-NETWORK1",
 476                             "port-rack": "000000.00",
 477                             "port-shelf": "Chassis#1"
 478                         },
 479                         "lgx": {
 480                             "lgx-device-name": "Some lgx-device-name",
 481                             "lgx-port-name": "Some lgx-port-name",
 482                             "lgx-port-rack": "000000.00",
 483                             "lgx-port-shelf": "00"
 484                         }
 485                     },
 486                     "rx-direction": {
 487                         "port": {
 488                             "port-device-name": "SPDR-SC1-XPDR1",
 489                             "port-type": "fixed",
 490                             "port-name": "XPDR1-NETWORK1",
 491                             "port-rack": "000000.00",
 492                             "port-shelf": "Chassis#1"
 493                         },
 494                         "lgx": {
 495                             "lgx-device-name": "Some lgx-device-name",
 496                             "lgx-port-name": "Some lgx-port-name",
 497                             "lgx-port-rack": "000000.00",
 498                             "lgx-port-shelf": "00"
 499                         }
 500                     },
 501                     "optic-type": "gray"
 502                 },
 503                 "due-date": "2018-06-15T00:00:01Z",
 504                 "operator-contact": "pw1234"
 505                 }
 506                 }
 507         response = test_utils.post_request(url, data)
 508         self.assertEqual(response.status_code, requests.codes.ok)
 509         res = response.json()
 510         self.assertIn('PCE calculation in progress',
 511                       res['output']['configuration-response-common']['response-message'])
 512         time.sleep(self.WAITING)
 513
 514     def test_24_get_ODU4_service1(self):
 515         url = "{}/operational/org-openroadm-service:service-list/services/service1-ODU4"
 516         response = test_utils.get_request(url)
 517         self.assertEqual(response.status_code, requests.codes.ok)
 518         res = response.json()
 519         self.assertEqual(
 520             res['services'][0]['administrative-state'], 'inService')
 521         self.assertEqual(
 522             res['services'][0]['service-name'], 'service1-ODU4')
 523         self.assertEqual(
 524             res['services'][0]['connection-type'], 'infrastructure')
 525         self.assertEqual(
 526             res['services'][0]['lifecycle-state'], 'planned')
 527         time.sleep(2)
 528
 529     def test_25_check_interface_ODU4_spdra(self):
 530         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
 531         self.assertEqual(response.status_code, requests.codes.ok)
 532         res = response.json()
 533         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 534                         'administrative-state': 'inService',
 535                         'supporting-circuit-pack-name': 'CP1-CFP0',
 536                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 537                         'type': 'org-openroadm-interfaces:otnOdu',
 538                         'supporting-port': 'CP1-CFP0-P1'}
 539         # SAPI/DAPI are added in the Otu4 renderer
 540         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 541                         'rate': 'org-openroadm-otn-common-types:ODU4',
 542                         'expected-dapi': 'Swfw02qXGyI=',
 543                         'expected-sapi': 'fuYZwEO660g=',
 544                         'tx-dapi': 'fuYZwEO660g=',
 545                         'tx-sapi': 'Swfw02qXGyI='}
 546
 547         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 548                              res['interface'][0])
 549         self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 550                                   **input_dict_2),
 551                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 552                              )
 553         self.assertDictEqual(
 554             {u'payload-type': u'21', u'exp-payload-type': u'21'},
 555             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 556
 557     def test_26_check_interface_ODU4_spdrc(self):
 558         response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
 559         self.assertEqual(response.status_code, requests.codes.ok)
 560         res = response.json()
 561         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 562                         'administrative-state': 'inService',
 563                         'supporting-circuit-pack-name': 'CP1-CFP0',
 564                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 565                         'type': 'org-openroadm-interfaces:otnOdu',
 566                         'supporting-port': 'CP1-CFP0-P1'}
 567         # SAPI/DAPI are added in the Otu4 renderer
 568         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 569                         'rate': 'org-openroadm-otn-common-types:ODU4',
 570                         'tx-sapi': 'fuYZwEO660g=',
 571                         'tx-dapi': 'Swfw02qXGyI=',
 572                         'expected-sapi': 'Swfw02qXGyI=',
 573                         'expected-dapi': 'fuYZwEO660g='
 574                         }
 575         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 576                              res['interface'][0])
 577         self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 578                                   **input_dict_2),
 579                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 580                              )
 581         self.assertDictEqual(
 582             {u'payload-type': u'21', u'exp-payload-type': u'21'},
 583             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 584
 585     def test_27_check_otn_topo_links(self):
 586         response = test_utils.get_otn_topo_request()
 587         self.assertEqual(response.status_code, requests.codes.ok)
 588         res = response.json()
 589         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 590         self.assertEqual(nb_links, 4)
 591         for link in res['network'][0]['ietf-network-topology:link']:
 592             linkId = link['link-id']
 593             if (linkId == 'OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
 594                     linkId == 'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
 595                 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 0)
 596                 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
 597             elif (linkId == 'ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
 598                   linkId == 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
 599                 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 600                 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 601                 self.assertEqual(link['transportpce-topology:otn-link-type'], 'ODTU4')
 602                 self.assertEqual(link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 603                 self.assertIn(link['org-openroadm-common-network:opposite-link'],
 604                               ['ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 605                                'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'])
 606             else:
 607                 self.fail("this link should not exist")
 608
 609     def test_28_check_otn_topo_tp(self):
 610         response = test_utils.get_otn_topo_request()
 611         res = response.json()
 612         for node in res['network'][0]['node']:
 613             if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
 614                 tpList = node['ietf-network-topology:termination-point']
 615                 for tp in tpList:
 616                     if (tp['tp-id'] == 'XPDR1-NETWORK1'):
 617                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 618                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
 619                         self.assertEqual(len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
 620                         self.assertEqual(xpdrTpPortConAt['odtu-tpn-pool'][0]['odtu-type'],
 621                                          'org-openroadm-otn-common-types:ODTU4.ts-Allocated')
 622
 623 # test service-create for 10GE service from spdr to spdr
 624     def test_29_create_10GE_service(self):
 625         url = "{}/operations/org-openroadm-service:service-create"
 626         data = {"input": {
 627                 "sdnc-request-header": {
 628                     "request-id": "request-1",
 629                     "rpc-action": "service-create",
 630                     "request-system-id": "appname"
 631                 },
 632                 "service-name": "service1-10GE",
 633                 "common-id": "commonId",
 634                 "connection-type": "service",
 635                 "service-a-end": {
 636                     "service-rate": "10",
 637                     "node-id": "SPDR-SA1",
 638                     "service-format": "Ethernet",
 639                     "clli": "NodeSA",
 640                     "subrate-eth-sla": {
 641                         "subrate-eth-sla": {
 642                             "committed-info-rate": "100000",
 643                             "committed-burst-size": "64"
 644                         }
 645                     },
 646                     "tx-direction": {
 647                         "port": {
 648                             "port-device-name": "SPDR-SA1-XPDR1",
 649                             "port-type": "fixed",
 650                             "port-name": "XPDR1-CLIENT1",
 651                             "port-rack": "000000.00",
 652                             "port-shelf": "Chassis#1"
 653                         },
 654                         "lgx": {
 655                             "lgx-device-name": "Some lgx-device-name",
 656                             "lgx-port-name": "Some lgx-port-name",
 657                             "lgx-port-rack": "000000.00",
 658                             "lgx-port-shelf": "00"
 659                         }
 660                     },
 661                     "rx-direction": {
 662                         "port": {
 663                             "port-device-name": "SPDR-SA1-XPDR1",
 664                             "port-type": "fixed",
 665                             "port-name": "XPDR1-CLIENT1",
 666                             "port-rack": "000000.00",
 667                             "port-shelf": "Chassis#1"
 668                         },
 669                         "lgx": {
 670                             "lgx-device-name": "Some lgx-device-name",
 671                             "lgx-port-name": "Some lgx-port-name",
 672                             "lgx-port-rack": "000000.00",
 673                             "lgx-port-shelf": "00"
 674                         }
 675                     },
 676                     "optic-type": "gray"
 677                 },
 678                 "service-z-end": {
 679                     "service-rate": "10",
 680                     "node-id": "SPDR-SC1",
 681                     "service-format": "Ethernet",
 682                     "clli": "NodeSC",
 683                     "subrate-eth-sla": {
 684                         "subrate-eth-sla": {
 685                             "committed-info-rate": "100000",
 686                             "committed-burst-size": "64"
 687                         }
 688                     },
 689                     "tx-direction": {
 690                         "port": {
 691                             "port-device-name": "SPDR-SC1-XPDR1",
 692                             "port-type": "fixed",
 693                             "port-name": "XPDR1-CLIENT1",
 694                             "port-rack": "000000.00",
 695                             "port-shelf": "Chassis#1"
 696                         },
 697                         "lgx": {
 698                             "lgx-device-name": "Some lgx-device-name",
 699                             "lgx-port-name": "Some lgx-port-name",
 700                             "lgx-port-rack": "000000.00",
 701                             "lgx-port-shelf": "00"
 702                         }
 703                     },
 704                     "rx-direction": {
 705                         "port": {
 706                             "port-device-name": "SPDR-SC1-XPDR1",
 707                             "port-type": "fixed",
 708                             "port-name": "XPDR1-CLIENT1",
 709                             "port-rack": "000000.00",
 710                             "port-shelf": "Chassis#1"
 711                         },
 712                         "lgx": {
 713                             "lgx-device-name": "Some lgx-device-name",
 714                             "lgx-port-name": "Some lgx-port-name",
 715                             "lgx-port-rack": "000000.00",
 716                             "lgx-port-shelf": "00"
 717                         }
 718                     },
 719                     "optic-type": "gray"
 720                 },
 721                 "due-date": "2018-06-15T00:00:01Z",
 722                 "operator-contact": "pw1234"
 723                 }
 724                 }
 725         response = test_utils.post_request(url, data)
 726         self.assertEqual(response.status_code, requests.codes.ok)
 727         res = response.json()
 728         self.assertIn('PCE calculation in progress',
 729                       res['output']['configuration-response-common']['response-message'])
 730         time.sleep(self.WAITING)
 731
 732     def test_30_get_10GE_service1(self):
 733         url = "{}/operational/org-openroadm-service:service-list/services/service1-10GE"
 734         response = test_utils.get_request(url)
 735         self.assertEqual(response.status_code, requests.codes.ok)
 736         res = response.json()
 737         self.assertEqual(
 738             res['services'][0]['administrative-state'], 'inService')
 739         self.assertEqual(
 740             res['services'][0]['service-name'], 'service1-10GE')
 741         self.assertEqual(
 742             res['services'][0]['connection-type'], 'service')
 743         self.assertEqual(
 744             res['services'][0]['lifecycle-state'], 'planned')
 745         time.sleep(2)
 746
 747     def test_31_check_interface_10GE_CLIENT_spdra(self):
 748         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
 749         self.assertEqual(response.status_code, requests.codes.ok)
 750         res = response.json()
 751         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 752                       'administrative-state': 'inService',
 753                       'supporting-circuit-pack-name': 'CP1-SFP4',
 754                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 755                       'supporting-port': 'CP1-SFP4-P1'
 756                       }
 757         self.assertDictEqual(dict(input_dict, **res['interface'][0]),
 758                              res['interface'][0])
 759         self.assertDictEqual(
 760             {u'speed': 10000},
 761             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 762
 763     def test_32_check_interface_ODU2E_CLIENT_spdra(self):
 764         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1-10GE")
 765         self.assertEqual(response.status_code, requests.codes.ok)
 766         res = response.json()
 767         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1-10GE',
 768                         'administrative-state': 'inService',
 769                         'supporting-circuit-pack-name': 'CP1-SFP4',
 770                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 771                         'type': 'org-openroadm-interfaces:otnOdu',
 772                         'supporting-port': 'CP1-SFP4-P1'}
 773         input_dict_2 = {
 774             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 775             'rate': 'org-openroadm-otn-common-types:ODU2e',
 776             'monitoring-mode': 'terminated'}
 777
 778         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 779                              res['interface'][0])
 780         self.assertDictEqual(dict(input_dict_2,
 781                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 782                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 783         self.assertDictEqual(
 784             {u'payload-type': u'03', u'exp-payload-type': u'03'},
 785             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 786
 787     def test_33_check_interface_ODU2E_NETWORK_spdra(self):
 788         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1-10GE")
 789         self.assertEqual(response.status_code, requests.codes.ok)
 790         res = response.json()
 791         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1-10GE',
 792                         'administrative-state': 'inService',
 793                         'supporting-circuit-pack-name': 'CP1-CFP0',
 794                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 795                         'type': 'org-openroadm-interfaces:otnOdu',
 796                         'supporting-port': 'CP1-CFP0-P1'}
 797         input_dict_2 = {
 798             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 799             'rate': 'org-openroadm-otn-common-types:ODU2e',
 800             'monitoring-mode': 'monitored'}
 801         input_dict_3 = {'trib-port-number': 1}
 802
 803         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 804                              res['interface'][0])
 805         self.assertDictEqual(dict(input_dict_2,
 806                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 807                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 808         self.assertDictEqual(dict(input_dict_3,
 809                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 810                                       'parent-odu-allocation']),
 811                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
 812         self.assertIn(1, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
 813                       ['trib-slots'])
 814
 815     def test_34_check_ODU2E_connection_spdra(self):
 816         response = test_utils.check_netconf_node_request(
 817             "SPDR-SA1",
 818             "odu-connection/XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE")
 819         self.assertEqual(response.status_code, requests.codes.ok)
 820         res = response.json()
 821         input_dict_1 = {
 822             'connection-name':
 823             'XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE',
 824             'direction': 'bidirectional'
 825         }
 826
 827         self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
 828                              res['odu-connection'][0])
 829         self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1-10GE'},
 830                              res['odu-connection'][0]['destination'])
 831         self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1-10GE'},
 832                              res['odu-connection'][0]['source'])
 833
 834     def test_35_check_interface_10GE_CLIENT_spdrc(self):
 835         response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
 836         self.assertEqual(response.status_code, requests.codes.ok)
 837         res = response.json()
 838         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 839                       'administrative-state': 'inService',
 840                       'supporting-circuit-pack-name': 'CP1-SFP4',
 841                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 842                       'supporting-port': 'CP1-SFP4-P1'
 843                       }
 844         self.assertDictEqual(dict(input_dict, **res['interface'][0]),
 845                              res['interface'][0])
 846         self.assertDictEqual(
 847             {u'speed': 10000},
 848             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 849
 850     def test_36_check_interface_ODU2E_CLIENT_spdrc(self):
 851         response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-service1-10GE")
 852         self.assertEqual(response.status_code, requests.codes.ok)
 853         res = response.json()
 854         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1-10GE',
 855                         'administrative-state': 'inService',
 856                         'supporting-circuit-pack-name': 'CP1-SFP4',
 857                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 858                         'type': 'org-openroadm-interfaces:otnOdu',
 859                         'supporting-port': 'CP1-SFP4-P1'}
 860         input_dict_2 = {
 861             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 862             'rate': 'org-openroadm-otn-common-types:ODU2e',
 863             'monitoring-mode': 'terminated'}
 864
 865         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 866                              res['interface'][0])
 867         self.assertDictEqual(dict(input_dict_2,
 868                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 869                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 870         self.assertDictEqual(
 871             {u'payload-type': u'03', u'exp-payload-type': u'03'},
 872             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 873
 874     def test_37_check_interface_ODU2E_NETWORK_spdrc(self):
 875         response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-service1-10GE")
 876         self.assertEqual(response.status_code, requests.codes.ok)
 877         res = response.json()
 878         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1-10GE',
 879                         'administrative-state': 'inService',
 880                         'supporting-circuit-pack-name': 'CP1-CFP0',
 881                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 882                         'type': 'org-openroadm-interfaces:otnOdu',
 883                         'supporting-port': 'CP1-CFP0-P1'}
 884         input_dict_2 = {
 885             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 886             'rate': 'org-openroadm-otn-common-types:ODU2e',
 887             'monitoring-mode': 'monitored'}
 888
 889         input_dict_3 = {'trib-port-number': 1}
 890
 891         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 892                              res['interface'][0])
 893         self.assertDictEqual(dict(input_dict_2,
 894                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 895                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 896         self.assertDictEqual(dict(input_dict_3,
 897                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 898                                       'parent-odu-allocation']),
 899                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 900             'parent-odu-allocation'])
 901         self.assertIn(1,
 902                       res['interface'][0][
 903                           'org-openroadm-otn-odu-interfaces:odu'][
 904                           'parent-odu-allocation']['trib-slots'])
 905
 906     def test_38_check_ODU2E_connection_spdrc(self):
 907         response = test_utils.check_netconf_node_request(
 908             "SPDR-SC1",
 909             "odu-connection/XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE")
 910         self.assertEqual(response.status_code, requests.codes.ok)
 911         res = response.json()
 912         input_dict_1 = {
 913             'connection-name':
 914             'XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE',
 915             'direction': 'bidirectional'
 916         }
 917
 918         self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
 919                              res['odu-connection'][0])
 920         self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1-10GE'},
 921                              res['odu-connection'][0]['destination'])
 922         self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1-10GE'},
 923                              res['odu-connection'][0]['source'])
 924
 925     def test_39_check_otn_topo_links(self):
 926         response = test_utils.get_otn_topo_request()
 927         self.assertEqual(response.status_code, requests.codes.ok)
 928         res = response.json()
 929         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 930         self.assertEqual(nb_links, 4)
 931         for link in res['network'][0]['ietf-network-topology:link']:
 932             linkId = link['link-id']
 933             if (linkId == 'ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
 934                     linkId == 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
 935                 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 90000)
 936                 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
 937
 938     def test_40_check_otn_topo_tp(self):
 939         response = test_utils.get_otn_topo_request()
 940         res = response.json()
 941         for node in res['network'][0]['node']:
 942             if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
 943                 tpList = node['ietf-network-topology:termination-point']
 944                 for tp in tpList:
 945                     if (tp['tp-id'] == 'XPDR1-NETWORK1'):
 946                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 947                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 72)
 948                         tsPoolList = [i for i in range(1, 9)]
 949                         self.assertNotIn(tsPoolList, xpdrTpPortConAt['ts-pool'])
 950                         self.assertEqual(len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 79)
 951                         self.assertNotIn(1, xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool'])
 952
 953     def test_41_delete_10GE_service(self):
 954         url = "{}/operations/org-openroadm-service:service-delete"
 955         data = {"input": {
 956                 "sdnc-request-header": {
 957                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 958                     "rpc-action": "service-delete",
 959                     "request-system-id": "appname",
 960                     "notification-url": "http://localhost:8585/NotificationServer/notify"
 961                 },
 962                 "service-delete-req-info": {
 963                     "service-name": "service1-10GE",
 964                     "tail-retention": "no"
 965                 }
 966                 }
 967                 }
 968         response = test_utils.post_request(url, data)
 969         self.assertEqual(response.status_code, requests.codes.ok)
 970         res = response.json()
 971         self.assertIn('Renderer service delete in progress',
 972                       res['output']['configuration-response-common']['response-message'])
 973         time.sleep(20)
 974
 975     def test_42_check_service_list(self):
 976         url = "{}/operational/org-openroadm-service:service-list"
 977         response = test_utils.get_request(url)
 978         self.assertEqual(response.status_code, requests.codes.ok)
 979         res = response.json()
 980         self.assertEqual(len(res['service-list']['services']), 2)
 981         time.sleep(2)
 982
 983     def test_43_check_no_ODU2e_connection_spdra(self):
 984         response = test_utils.check_netconf_node_request("SPDR-SA1", "")
 985         self.assertEqual(response.status_code, requests.codes.ok)
 986         res = response.json()
 987         self.assertNotIn(['odu-connection'][0], res['org-openroadm-device'])
 988         time.sleep(1)
 989
 990     def test_44_check_no_interface_ODU2E_NETWORK_spdra(self):
 991         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1")
 992         self.assertEqual(response.status_code, requests.codes.not_found)
 993
 994     def test_45_check_no_interface_ODU2E_CLIENT_spdra(self):
 995         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1")
 996         self.assertEqual(response.status_code, requests.codes.not_found)
 997
 998     def test_46_check_no_interface_10GE_CLIENT_spdra(self):
 999         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
1000         self.assertEqual(response.status_code, requests.codes.not_found)
1001
1002     def test_47_check_otn_topo_links(self):
1003         response = test_utils.get_otn_topo_request()
1004         self.assertEqual(response.status_code, requests.codes.ok)
1005         res = response.json()
1006         nb_links = len(res['network'][0]['ietf-network-topology:link'])
1007         self.assertEqual(nb_links, 4)
1008         for link in res['network'][0]['ietf-network-topology:link']:
1009             linkId = link['link-id']
1010             if (linkId == 'ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1' or
1011                     linkId == 'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'):
1012                 self.assertEqual(link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
1013                 self.assertEqual(link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
1014
1015     def test_48_check_otn_topo_tp(self):
1016         response = test_utils.get_otn_topo_request()
1017         res = response.json()
1018         for node in res['network'][0]['node']:
1019             if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
1020                 tpList = node['ietf-network-topology:termination-point']
1021                 for tp in tpList:
1022                     if (tp['tp-id'] == 'XPDR1-NETWORK1'):
1023                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1024                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
1025                         self.assertEqual(len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
1026
1027     def test_49_delete_ODU4_service(self):
1028         url = "{}/operations/org-openroadm-service:service-delete"
1029         data = {"input": {
1030                 "sdnc-request-header": {
1031                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1032                     "rpc-action": "service-delete",
1033                     "request-system-id": "appname",
1034                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1035                 },
1036                 "service-delete-req-info": {
1037                     "service-name": "service1-ODU4",
1038                     "tail-retention": "no"
1039                 }
1040                 }
1041                 }
1042         response = test_utils.post_request(url, data)
1043         self.assertEqual(response.status_code, requests.codes.ok)
1044         res = response.json()
1045         self.assertIn('Renderer service delete in progress',
1046                       res['output']['configuration-response-common']['response-message'])
1047         time.sleep(20)
1048
1049     def test_50_check_service_list(self):
1050         url = "{}/operational/org-openroadm-service:service-list"
1051         response = test_utils.get_request(url)
1052         self.assertEqual(response.status_code, requests.codes.ok)
1053         res = response.json()
1054         self.assertEqual(len(res['service-list']['services']), 1)
1055         time.sleep(2)
1056
1057     def test_51_check_no_interface_ODU4_spdra(self):
1058         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
1059         self.assertEqual(response.status_code, requests.codes.not_found)
1060
1061     def test_52_check_otn_topo_links(self):
1062         self.test_22_check_otn_topo_otu4_links()
1063
1064     def test_53_check_otn_topo_tp(self):
1065         response = test_utils.get_otn_topo_request()
1066         res = response.json()
1067         for node in res['network'][0]['node']:
1068             if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
1069                 tpList = node['ietf-network-topology:termination-point']
1070                 for tp in tpList:
1071                     if (tp['tp-id'] == 'XPDR1-NETWORK1'):
1072                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1073                         self.assertNotIn('ts-pool', dict.keys(xpdrTpPortConAt))
1074                         self.assertNotIn('odtu-tpn-pool', dict.keys(xpdrTpPortConAt))
1075
1076     def test_54_delete_OCH_OTU4_service(self):
1077         url = "{}/operations/org-openroadm-service:service-delete"
1078         data = {"input": {
1079                 "sdnc-request-header": {
1080                     "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
1081                     "rpc-action": "service-delete",
1082                     "request-system-id": "appname",
1083                     "notification-url": "http://localhost:8585/NotificationServer/notify"
1084                 },
1085                 "service-delete-req-info": {
1086                     "service-name": "service1-OCH-OTU4",
1087                     "tail-retention": "no"
1088                 }
1089                 }
1090                 }
1091         response = test_utils.post_request(url, data)
1092         self.assertEqual(response.status_code, requests.codes.ok)
1093         res = response.json()
1094         self.assertIn('Renderer service delete in progress',
1095                       res['output']['configuration-response-common']['response-message'])
1096         time.sleep(20)
1097
1098     def test_55_get_no_service(self):
1099         url = "{}/operational/org-openroadm-service:service-list"
1100         response = test_utils.get_request(url)
1101         self.assertEqual(response.status_code, requests.codes.not_found)
1102         res = response.json()
1103         self.assertIn(
1104             {"error-type": "application", "error-tag": "data-missing",
1105              "error-message": "Request could not be completed because the relevant data model content does not exist"},
1106             res['errors']['error'])
1107         time.sleep(1)
1108
1109     def test_56_check_no_interface_OTU4_spdra(self):
1110         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
1111         self.assertEqual(response.status_code, requests.codes.not_found)
1112
1113     def test_57_check_no_interface_OCH_spdra(self):
1114         response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
1115         self.assertEqual(response.status_code, requests.codes.not_found)
1116
1117     def test_58_getLinks_OtnTopology(self):
1118         response = test_utils.get_otn_topo_request()
1119         self.assertEqual(response.status_code, requests.codes.ok)
1120         res = response.json()
1121         self.assertNotIn('ietf-network-topology:link', res['network'][0])
1122
1123     def test_59_check_openroadm_topo_spdra(self):
1124         response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR1")
1125         self.assertEqual(response.status_code, requests.codes.ok)
1126         res = response.json()
1127         tp = res['node'][0]['ietf-network-topology:termination-point'][0]
1128         self.assertEqual('XPDR1-NETWORK1', tp['tp-id'])
1129         self.assertNotIn('wavelength', dict.keys(
1130             tp[u'org-openroadm-network-topology:xpdr-network-attributes']))
1131         time.sleep(3)
1132
1133     def test_60_check_openroadm_topo_ROADMA_SRG(self):
1134         response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
1135         self.assertEqual(response.status_code, requests.codes.ok)
1136         res = response.json()
1137         self.assertIn({u'index': 1},
1138                       res['node'][0][u'org-openroadm-network-topology:srg-attributes']['available-wavelengths'])
1139         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1140         for ele in liste_tp:
1141             if ele['tp-id'] == 'SRG1-PP1-TXRX':
1142                 self.assertNotIn('org-openroadm-network-topology:pp-attributes', dict.keys(ele))
1143         time.sleep(3)
1144
1145     def test_61_check_openroadm_topo_ROADMA_DEG(self):
1146         response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2")
1147         self.assertEqual(response.status_code, requests.codes.ok)
1148         res = response.json()
1149         self.assertIn({u'index': 1},
1150                       res['node'][0][u'org-openroadm-network-topology:degree-attributes']['available-wavelengths'])
1151         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
1152         for ele in liste_tp:
1153             if ele['tp-id'] == 'DEG2-CTP-TXRX':
1154                 self.assertNotIn('org-openroadm-network-topology:ctp-attributes', dict.keys(ele))
1155             if ele['tp-id'] == 'DEG2-TTP-TXRX':
1156                 self.assertNotIn('org-openroadm-network-topology:tx-ttp-attributes', dict.keys(ele))
1157         time.sleep(3)
1158
1159     def test_62_disconnect_spdrA(self):
1160         response = test_utils.unmount_device("SPDR-SA1")
1161         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1162
1163     def test_63_disconnect_spdrC(self):
1164         response = test_utils.unmount_device("SPDR-SC1")
1165         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1166
1167     def test_64_disconnect_roadmA(self):
1168         response = test_utils.unmount_device("ROADM-A1")
1169         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1170
1171     def test_65_disconnect_roadmC(self):
1172         response = test_utils.unmount_device("ROADM-C1")
1173         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1174
1175
1176 if __name__ == "__main__":
1177     unittest.main(verbosity=2)