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