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 # pylint: disable=no-member
  13 # pylint: disable=too-many-public-methods
  14
  15 import base64
  16 import unittest
  17 import time
  18 import requests
  19 from common import test_utils
  20
  21
  22 class TransportPCEtesting(unittest.TestCase):
  23
  24     processes = None
  25     WAITING = 20  # nominal value is 300
  26
  27     cr_serv_sample_data = {"input": {
  28         "sdnc-request-header": {
  29             "request-id": "request-1",
  30             "rpc-action": "service-create",
  31             "request-system-id": "appname"
  32         },
  33         "service-name": "service1-OCH-OTU4",
  34         "common-id": "commonId",
  35         "connection-type": "infrastructure",
  36         "service-a-end": {
  37             "service-rate": "100",
  38             "node-id": "SPDR-SA1",
  39             "service-format": "OTU",
  40             "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
  41             "clli": "NodeSA",
  42             "subrate-eth-sla": {
  43                     "subrate-eth-sla": {
  44                         "committed-info-rate": "100000",
  45                         "committed-burst-size": "64"
  46                     }
  47             },
  48             "tx-direction": {
  49                 "port": {
  50                     "port-device-name": "SPDR-SA1-XPDR1",
  51                     "port-type": "fixed",
  52                     "port-name": "XPDR1-NETWORK1",
  53                     "port-rack": "000000.00",
  54                     "port-shelf": "Chassis#1"
  55                 },
  56                 "lgx": {
  57                     "lgx-device-name": "Some lgx-device-name",
  58                     "lgx-port-name": "Some lgx-port-name",
  59                     "lgx-port-rack": "000000.00",
  60                     "lgx-port-shelf": "00"
  61                 }
  62             },
  63             "rx-direction": {
  64                 "port": {
  65                     "port-device-name": "SPDR-SA1-XPDR1",
  66                     "port-type": "fixed",
  67                     "port-name": "XPDR1-NETWORK1",
  68                     "port-rack": "000000.00",
  69                     "port-shelf": "Chassis#1"
  70                 },
  71                 "lgx": {
  72                     "lgx-device-name": "Some lgx-device-name",
  73                     "lgx-port-name": "Some lgx-port-name",
  74                     "lgx-port-rack": "000000.00",
  75                     "lgx-port-shelf": "00"
  76                 }
  77             },
  78             "optic-type": "gray"
  79         },
  80         "service-z-end": {
  81             "service-rate": "100",
  82             "node-id": "SPDR-SC1",
  83             "service-format": "OTU",
  84             "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
  85             "clli": "NodeSC",
  86             "subrate-eth-sla": {
  87                     "subrate-eth-sla": {
  88                         "committed-info-rate": "100000",
  89                         "committed-burst-size": "64"
  90                     }
  91             },
  92             "tx-direction": {
  93                 "port": {
  94                     "port-device-name": "SPDR-SC1-XPDR1",
  95                     "port-type": "fixed",
  96                     "port-name": "XPDR1-NETWORK1",
  97                     "port-rack": "000000.00",
  98                     "port-shelf": "Chassis#1"
  99                 },
 100                 "lgx": {
 101                     "lgx-device-name": "Some lgx-device-name",
 102                     "lgx-port-name": "Some lgx-port-name",
 103                     "lgx-port-rack": "000000.00",
 104                     "lgx-port-shelf": "00"
 105                 }
 106             },
 107             "rx-direction": {
 108                 "port": {
 109                     "port-device-name": "SPDR-SC1-XPDR1",
 110                     "port-type": "fixed",
 111                     "port-name": "XPDR1-NETWORK1",
 112                     "port-rack": "000000.00",
 113                     "port-shelf": "Chassis#1"
 114                 },
 115                 "lgx": {
 116                     "lgx-device-name": "Some lgx-device-name",
 117                     "lgx-port-name": "Some lgx-port-name",
 118                     "lgx-port-rack": "000000.00",
 119                     "lgx-port-shelf": "00"
 120                 }
 121             },
 122             "optic-type": "gray"
 123         },
 124         "due-date": "2018-06-15T00:00:01Z",
 125         "operator-contact": "pw1234"
 126     }
 127     }
 128
 129     @classmethod
 130     def setUpClass(cls):
 131         cls.processes = test_utils.start_tpce()
 132         cls.processes = test_utils.start_sims(
 133             ['spdra', 'roadma', 'roadmc', 'spdrc'])
 134
 135     @classmethod
 136     def tearDownClass(cls):
 137         # pylint: disable=not-an-iterable
 138         for process in cls.processes:
 139             test_utils.shutdown_process(process)
 140         print("all processes killed")
 141
 142     def setUp(self):
 143         time.sleep(5)
 144
 145     def test_01_connect_spdrA(self):
 146         response = test_utils.mount_device("SPDR-SA1", 'spdra')
 147         self.assertEqual(response.status_code,
 148                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 149
 150     def test_02_connect_spdrC(self):
 151         response = test_utils.mount_device("SPDR-SC1", 'spdrc')
 152         self.assertEqual(response.status_code,
 153                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 154
 155     def test_03_connect_rdmA(self):
 156         response = test_utils.mount_device("ROADM-A1", 'roadma')
 157         self.assertEqual(response.status_code,
 158                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 159
 160     def test_04_connect_rdmC(self):
 161         response = test_utils.mount_device("ROADM-C1", 'roadmc')
 162         self.assertEqual(response.status_code,
 163                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 164
 165     def test_05_connect_sprdA_1_N1_to_roadmA_PP1(self):
 166         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "1", "1",
 167                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
 168         self.assertEqual(response.status_code, requests.codes.ok)
 169         res = response.json()
 170         self.assertIn('Xponder Roadm Link created successfully',
 171                       res["output"]["result"])
 172         time.sleep(2)
 173
 174     def test_06_connect_roadmA_PP1_to_spdrA_1_N1(self):
 175         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "1", "1",
 176                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
 177         self.assertEqual(response.status_code, requests.codes.ok)
 178         res = response.json()
 179         self.assertIn('Roadm Xponder links created successfully',
 180                       res["output"]["result"])
 181         time.sleep(2)
 182
 183     def test_07_connect_sprdC_1_N1_to_roadmC_PP1(self):
 184         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "1", "1",
 185                                                           "ROADM-C1", "1", "SRG1-PP1-TXRX")
 186         self.assertEqual(response.status_code, requests.codes.ok)
 187         res = response.json()
 188         self.assertIn('Xponder Roadm Link created successfully',
 189                       res["output"]["result"])
 190         time.sleep(2)
 191
 192     def test_08_connect_roadmC_PP1_to_spdrC_1_N1(self):
 193         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "1", "1",
 194                                                           "ROADM-C1", "1", "SRG1-PP1-TXRX")
 195         self.assertEqual(response.status_code, requests.codes.ok)
 196         res = response.json()
 197         self.assertIn('Roadm Xponder links created successfully',
 198                       res["output"]["result"])
 199         time.sleep(2)
 200
 201     def test_09_add_omsAttributes_ROADMA_ROADMC(self):
 202         # Config ROADMA-ROADMC oms-attributes
 203         data = {"span": {
 204             "auto-spanloss": "true",
 205             "spanloss-base": 11.4,
 206             "spanloss-current": 12,
 207             "engineered-spanloss": 12.2,
 208             "link-concatenation": [{
 209                 "SRLG-Id": 0,
 210                 "fiber-type": "smf",
 211                 "SRLG-length": 100000,
 212                 "pmd": 0.5}]}}
 213         response = test_utils.add_oms_attr_request(
 214             "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
 215         self.assertEqual(response.status_code, requests.codes.created)
 216
 217     def test_10_add_omsAttributes_ROADMC_ROADMA(self):
 218         # Config ROADMC-ROADMA oms-attributes
 219         data = {"span": {
 220             "auto-spanloss": "true",
 221             "spanloss-base": 11.4,
 222             "spanloss-current": 12,
 223             "engineered-spanloss": 12.2,
 224             "link-concatenation": [{
 225                 "SRLG-Id": 0,
 226                 "fiber-type": "smf",
 227                 "SRLG-length": 100000,
 228                 "pmd": 0.5}]}}
 229         response = test_utils.add_oms_attr_request(
 230             "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
 231         self.assertEqual(response.status_code, requests.codes.created)
 232
 233 # test service-create for OCH-OTU4 service from spdr to spdr
 234     def test_11_check_otn_topology(self):
 235         response = test_utils.get_otn_topo_request()
 236         self.assertEqual(response.status_code, requests.codes.ok)
 237         res = response.json()
 238         nbNode = len(res['network'][0]['node'])
 239         self.assertEqual(nbNode, 6, 'There should be 6 nodes')
 240         self.assertNotIn('ietf-network-topology:link', res['network'][0])
 241
 242     def test_12_create_OCH_OTU4_service(self):
 243         response = test_utils.service_create_request(self.cr_serv_sample_data)
 244         self.assertEqual(response.status_code, requests.codes.ok)
 245         res = response.json()
 246         self.assertIn('PCE calculation in progress',
 247                       res['output']['configuration-response-common']['response-message'])
 248         time.sleep(self.WAITING)
 249
 250     def test_13_get_OCH_OTU4_service1(self):
 251         response = test_utils.get_service_list_request(
 252             "services/service1-OCH-OTU4")
 253         self.assertEqual(response.status_code, requests.codes.ok)
 254         res = response.json()
 255         self.assertEqual(
 256             res['services'][0]['administrative-state'], 'inService')
 257         self.assertEqual(
 258             res['services'][0]['service-name'], 'service1-OCH-OTU4')
 259         self.assertEqual(
 260             res['services'][0]['connection-type'], 'infrastructure')
 261         self.assertEqual(
 262             res['services'][0]['lifecycle-state'], 'planned')
 263         time.sleep(2)
 264
 265     # Check correct configuration of devices
 266     def test_14_check_interface_och_spdra(self):
 267         response = test_utils.check_netconf_node_request(
 268             "SPDR-SA1", "interface/XPDR1-NETWORK1-761:768")
 269         self.assertEqual(response.status_code, requests.codes.ok)
 270         res = response.json()
 271         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
 272                                    'administrative-state': 'inService',
 273                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 274                                    'type': 'org-openroadm-interfaces:opticalChannel',
 275                                    'supporting-port': 'CP1-CFP0-P1'
 276                                    }, **res['interface'][0]),
 277                              res['interface'][0])
 278
 279         self.assertDictEqual(
 280             {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
 281              u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
 282             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 283
 284     def test_15_check_interface_OTU4_spdra(self):
 285         response = test_utils.check_netconf_node_request(
 286             "SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
 287         self.assertEqual(response.status_code, requests.codes.ok)
 288         res = response.json()
 289         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 290                         'administrative-state': 'inService',
 291                         'supporting-circuit-pack-name': 'CP1-CFP0',
 292                         'supporting-interface': 'XPDR1-NETWORK1-761:768',
 293                         'type': 'org-openroadm-interfaces:otnOtu',
 294                         'supporting-port': 'CP1-CFP0-P1'
 295                         }
 296         input_dict_2 = {'tx-sapi': 'Swfw02qXGyI=',
 297                         'expected-dapi': 'Swfw02qXGyI=',
 298                         'rate': 'org-openroadm-otn-common-types:OTU4',
 299                         'fec': 'scfec'
 300                         }
 301         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 302                              res['interface'][0])
 303
 304         self.assertDictEqual(input_dict_2,
 305                              res['interface'][0]
 306                              ['org-openroadm-otn-otu-interfaces:otu'])
 307
 308     def test_16_check_interface_och_spdrc(self):
 309         response = test_utils.check_netconf_node_request(
 310             "SPDR-SC1", "interface/XPDR1-NETWORK1-761:768")
 311         self.assertEqual(response.status_code, requests.codes.ok)
 312         res = response.json()
 313         self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
 314                                    'administrative-state': 'inService',
 315                                    'supporting-circuit-pack-name': 'CP1-CFP0',
 316                                    'type': 'org-openroadm-interfaces:opticalChannel',
 317                                    'supporting-port': 'CP1-CFP0-P1'
 318                                    }, **res['interface'][0]),
 319                              res['interface'][0])
 320
 321         self.assertDictEqual(
 322             {u'frequency': 196.1, u'rate': u'org-openroadm-common-types:R100G',
 323              u'transmit-power': -5, u'modulation-format': 'dp-qpsk'},
 324             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 325
 326     def test_17_check_interface_OTU4_spdrc(self):
 327         response = test_utils.check_netconf_node_request(
 328             "SPDR-SC1", "interface/XPDR1-NETWORK1-OTU")
 329         self.assertEqual(response.status_code, requests.codes.ok)
 330         res = response.json()
 331         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
 332                         'administrative-state': 'inService',
 333                         'supporting-circuit-pack-name': 'CP1-CFP0',
 334                         'supporting-interface': 'XPDR1-NETWORK1-761:768',
 335                         'type': 'org-openroadm-interfaces:otnOtu',
 336                         'supporting-port': 'CP1-CFP0-P1'
 337                         }
 338         input_dict_2 = {'tx-dapi': 'Swfw02qXGyI=',
 339                         'expected-sapi': 'Swfw02qXGyI=',
 340                         'tx-sapi': 'fuYZwEO660g=',
 341                         'expected-dapi': 'fuYZwEO660g=',
 342                         'rate': 'org-openroadm-otn-common-types:OTU4',
 343                         'fec': 'scfec'
 344                         }
 345
 346         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 347                              res['interface'][0])
 348
 349         self.assertDictEqual(input_dict_2,
 350                              res['interface'][0]
 351                              ['org-openroadm-otn-otu-interfaces:otu'])
 352
 353     def test_18_check_no_interface_ODU4_spdra(self):
 354         response = test_utils.check_netconf_node_request(
 355             "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
 356         self.assertEqual(response.status_code, requests.codes.conflict)
 357         res = response.json()
 358         self.assertIn(
 359             {"error-type": "application", "error-tag": "data-missing",
 360              "error-message": "Request could not be completed because the relevant data model content does not exist"},
 361             res['errors']['error'])
 362
 363     def test_19_check_openroadm_topo_spdra(self):
 364         response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR1")
 365         self.assertEqual(response.status_code, requests.codes.ok)
 366         res = response.json()
 367         ele = res['node'][0]['ietf-network-topology:termination-point'][0]
 368         self.assertEqual('XPDR1-NETWORK1', ele['tp-id'])
 369         self.assertEqual({u'frequency': 196.1,
 370                           u'width': 40},
 371                          ele['org-openroadm-network-topology:xpdr-network-attributes']['wavelength'])
 372         time.sleep(3)
 373
 374     def test_20_check_openroadm_topo_ROADMA_SRG(self):
 375         response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
 376         self.assertEqual(response.status_code, requests.codes.ok)
 377         res = response.json()
 378         freq_map = base64.b64decode(
 379             res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
 380         freq_map_array = [int(x) for x in freq_map]
 381         self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
 382         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 383         for ele in liste_tp:
 384             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 385                 freq_map = base64.b64decode(
 386                     ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map'])
 387                 freq_map_array = [int(x) for x in freq_map]
 388                 self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
 389             if ele['tp-id'] == 'SRG1-PP2-TXRX':
 390                 self.assertNotIn('avail-freq-maps', dict.keys(ele))
 391         time.sleep(3)
 392
 393     def test_21_check_openroadm_topo_ROADMA_DEG(self):
 394         response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2")
 395         self.assertEqual(response.status_code, requests.codes.ok)
 396         res = response.json()
 397         freq_map = base64.b64decode(
 398             res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
 399         freq_map_array = [int(x) for x in freq_map]
 400         self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
 401         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 402         for ele in liste_tp:
 403             if ele['tp-id'] == 'DEG2-CTP-TXRX':
 404                 freq_map = base64.b64decode(
 405                     ele['org-openroadm-network-topology:ctp-attributes']['avail-freq-maps'][0]['freq-map'])
 406                 freq_map_array = [int(x) for x in freq_map]
 407                 self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
 408             if ele['tp-id'] == 'DEG2-TTP-TXRX':
 409                 freq_map = base64.b64decode(
 410                     ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map'])
 411                 freq_map_array = [int(x) for x in freq_map]
 412                 self.assertEqual(freq_map_array[95], 0, "Lambda 1 should not be available")
 413         time.sleep(3)
 414
 415     def test_22_check_otn_topo_otu4_links(self):
 416         response = test_utils.get_otn_topo_request()
 417         self.assertEqual(response.status_code, requests.codes.ok)
 418         res = response.json()
 419         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 420         self.assertEqual(nb_links, 2)
 421         listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 422                       'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1']
 423         for link in res['network'][0]['ietf-network-topology:link']:
 424             self.assertIn(link['link-id'], listLinkId)
 425             self.assertEqual(
 426                 link['transportpce-topology:otn-link-type'], 'OTU4')
 427             self.assertEqual(
 428                 link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 429             self.assertEqual(
 430                 link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 431             self.assertEqual(
 432                 link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 433             self.assertIn(
 434                 link['org-openroadm-common-network:opposite-link'], listLinkId)
 435
 436 # test service-create for ODU4 service from spdr to spdr
 437     def test_23_create_ODU4_service(self):
 438         self.cr_serv_sample_data["input"]["service-name"] = "service1-ODU4"
 439         self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "ODU"
 440         del self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"]
 441         self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
 442         self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "ODU"
 443         del self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"]
 444         self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
 445
 446         response = test_utils.service_create_request(self.cr_serv_sample_data)
 447         self.assertEqual(response.status_code, requests.codes.ok)
 448         res = response.json()
 449         self.assertIn('PCE calculation in progress',
 450                       res['output']['configuration-response-common']['response-message'])
 451         time.sleep(self.WAITING)
 452
 453     def test_24_get_ODU4_service1(self):
 454         response = test_utils.get_service_list_request(
 455             "services/service1-ODU4")
 456         self.assertEqual(response.status_code, requests.codes.ok)
 457         res = response.json()
 458         self.assertEqual(
 459             res['services'][0]['administrative-state'], 'inService')
 460         self.assertEqual(
 461             res['services'][0]['service-name'], 'service1-ODU4')
 462         self.assertEqual(
 463             res['services'][0]['connection-type'], 'infrastructure')
 464         self.assertEqual(
 465             res['services'][0]['lifecycle-state'], 'planned')
 466         time.sleep(2)
 467
 468     def test_25_check_interface_ODU4_spdra(self):
 469         response = test_utils.check_netconf_node_request(
 470             "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
 471         self.assertEqual(response.status_code, requests.codes.ok)
 472         res = response.json()
 473         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 474                         'administrative-state': 'inService',
 475                         'supporting-circuit-pack-name': 'CP1-CFP0',
 476                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 477                         'type': 'org-openroadm-interfaces:otnOdu',
 478                         'supporting-port': 'CP1-CFP0-P1'}
 479         # SAPI/DAPI are added in the Otu4 renderer
 480         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 481                         'rate': 'org-openroadm-otn-common-types:ODU4',
 482                         'expected-dapi': 'Swfw02qXGyI=',
 483                         'expected-sapi': 'fuYZwEO660g=',
 484                         'tx-dapi': 'fuYZwEO660g=',
 485                         'tx-sapi': 'Swfw02qXGyI='}
 486
 487         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 488                              res['interface'][0])
 489         self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 490                                   **input_dict_2),
 491                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 492                              )
 493         self.assertDictEqual(
 494             {u'payload-type': u'21', u'exp-payload-type': u'21'},
 495             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 496
 497     def test_26_check_interface_ODU4_spdrc(self):
 498         response = test_utils.check_netconf_node_request(
 499             "SPDR-SC1", "interface/XPDR1-NETWORK1-ODU4")
 500         self.assertEqual(response.status_code, requests.codes.ok)
 501         res = response.json()
 502         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 503                         'administrative-state': 'inService',
 504                         'supporting-circuit-pack-name': 'CP1-CFP0',
 505                         'supporting-interface': 'XPDR1-NETWORK1-OTU',
 506                         'type': 'org-openroadm-interfaces:otnOdu',
 507                         'supporting-port': 'CP1-CFP0-P1'}
 508         # SAPI/DAPI are added in the Otu4 renderer
 509         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 510                         'rate': 'org-openroadm-otn-common-types:ODU4',
 511                         'tx-sapi': 'fuYZwEO660g=',
 512                         'tx-dapi': 'Swfw02qXGyI=',
 513                         'expected-sapi': 'Swfw02qXGyI=',
 514                         'expected-dapi': 'fuYZwEO660g='
 515                         }
 516         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 517                              res['interface'][0])
 518         self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 519                                   **input_dict_2),
 520                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 521                              )
 522         self.assertDictEqual(
 523             {u'payload-type': u'21', u'exp-payload-type': u'21'},
 524             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 525
 526     def test_27_check_otn_topo_links(self):
 527         response = test_utils.get_otn_topo_request()
 528         self.assertEqual(response.status_code, requests.codes.ok)
 529         res = response.json()
 530         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 531         self.assertEqual(nb_links, 4)
 532         for link in res['network'][0]['ietf-network-topology:link']:
 533             linkId = link['link-id']
 534             if (linkId in ('OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 535                            'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')):
 536                 self.assertEqual(
 537                     link['org-openroadm-otn-network-topology:available-bandwidth'], 0)
 538                 self.assertEqual(
 539                     link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
 540             elif (linkId in ('ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 541                              'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')):
 542                 self.assertEqual(
 543                     link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 544                 self.assertEqual(
 545                     link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 546                 self.assertEqual(
 547                     link['transportpce-topology:otn-link-type'], 'ODTU4')
 548                 self.assertEqual(
 549                     link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 550                 self.assertIn(link['org-openroadm-common-network:opposite-link'],
 551                               ['ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 552                                'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'])
 553             else:
 554                 self.fail("this link should not exist")
 555
 556     def test_28_check_otn_topo_tp(self):
 557         response = test_utils.get_otn_topo_request()
 558         res = response.json()
 559         for node in res['network'][0]['node']:
 560             if node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1':
 561                 tpList = node['ietf-network-topology:termination-point']
 562                 for tp in tpList:
 563                     if tp['tp-id'] == 'XPDR1-NETWORK1':
 564                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 565                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
 566                         self.assertEqual(
 567                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
 568                         self.assertEqual(xpdrTpPortConAt['odtu-tpn-pool'][0]['odtu-type'],
 569                                          'org-openroadm-otn-common-types:ODTU4.ts-Allocated')
 570
 571 # test service-create for 10GE service from spdr to spdr
 572     def test_29_create_10GE_service(self):
 573         self.cr_serv_sample_data["input"]["service-name"] = "service1-10GE"
 574         self.cr_serv_sample_data["input"]["connection-type"] = "service"
 575         self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "10"
 576         self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet"
 577         del self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"]
 578         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-name"] = "XPDR1-CLIENT1"
 579         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-name"] = "XPDR1-CLIENT1"
 580         self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "10"
 581         self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet"
 582         del self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"]
 583         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-name"] = "XPDR1-CLIENT1"
 584         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-name"] = "XPDR1-CLIENT1"
 585         response = test_utils.service_create_request(self.cr_serv_sample_data)
 586         self.assertEqual(response.status_code, requests.codes.ok)
 587         res = response.json()
 588         self.assertIn('PCE calculation in progress',
 589                       res['output']['configuration-response-common']['response-message'])
 590         time.sleep(self.WAITING)
 591
 592     def test_30_get_10GE_service1(self):
 593         response = test_utils.get_service_list_request(
 594             "services/service1-10GE")
 595         self.assertEqual(response.status_code, requests.codes.ok)
 596         res = response.json()
 597         self.assertEqual(
 598             res['services'][0]['administrative-state'], 'inService')
 599         self.assertEqual(
 600             res['services'][0]['service-name'], 'service1-10GE')
 601         self.assertEqual(
 602             res['services'][0]['connection-type'], 'service')
 603         self.assertEqual(
 604             res['services'][0]['lifecycle-state'], 'planned')
 605         time.sleep(2)
 606
 607     def test_31_check_interface_10GE_CLIENT_spdra(self):
 608         response = test_utils.check_netconf_node_request(
 609             "SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
 610         self.assertEqual(response.status_code, requests.codes.ok)
 611         res = response.json()
 612         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 613                       'administrative-state': 'inService',
 614                       'supporting-circuit-pack-name': 'CP1-SFP4',
 615                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 616                       'supporting-port': 'CP1-SFP4-P1'
 617                       }
 618         self.assertDictEqual(dict(input_dict, **res['interface'][0]),
 619                              res['interface'][0])
 620         self.assertDictEqual(
 621             {u'speed': 10000},
 622             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 623
 624     def test_32_check_interface_ODU2E_CLIENT_spdra(self):
 625         response = test_utils.check_netconf_node_request(
 626             "SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1-10GE")
 627         self.assertEqual(response.status_code, requests.codes.ok)
 628         res = response.json()
 629         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1-10GE',
 630                         'administrative-state': 'inService',
 631                         'supporting-circuit-pack-name': 'CP1-SFP4',
 632                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 633                         'type': 'org-openroadm-interfaces:otnOdu',
 634                         'supporting-port': 'CP1-SFP4-P1'}
 635         input_dict_2 = {
 636             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 637             'rate': 'org-openroadm-otn-common-types:ODU2e',
 638             'monitoring-mode': 'terminated'}
 639
 640         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 641                              res['interface'][0])
 642         self.assertDictEqual(dict(input_dict_2,
 643                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 644                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 645         self.assertDictEqual(
 646             {u'payload-type': u'03', u'exp-payload-type': u'03'},
 647             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 648
 649     def test_33_check_interface_ODU2E_NETWORK_spdra(self):
 650         response = test_utils.check_netconf_node_request(
 651             "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1-10GE")
 652         self.assertEqual(response.status_code, requests.codes.ok)
 653         res = response.json()
 654         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1-10GE',
 655                         'administrative-state': 'inService',
 656                         'supporting-circuit-pack-name': 'CP1-CFP0',
 657                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 658                         'type': 'org-openroadm-interfaces:otnOdu',
 659                         'supporting-port': 'CP1-CFP0-P1'}
 660         input_dict_2 = {
 661             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 662             'rate': 'org-openroadm-otn-common-types:ODU2e',
 663             'monitoring-mode': 'monitored'}
 664         input_dict_3 = {'trib-port-number': 1}
 665
 666         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 667                              res['interface'][0])
 668         self.assertDictEqual(dict(input_dict_2,
 669                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 670                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 671         self.assertDictEqual(dict(input_dict_3,
 672                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 673                                       'parent-odu-allocation']),
 674                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
 675         self.assertIn(1, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
 676                       ['trib-slots'])
 677
 678     def test_34_check_ODU2E_connection_spdra(self):
 679         response = test_utils.check_netconf_node_request(
 680             "SPDR-SA1",
 681             "odu-connection/XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE")
 682         self.assertEqual(response.status_code, requests.codes.ok)
 683         res = response.json()
 684         input_dict_1 = {
 685             'connection-name':
 686             'XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE',
 687             'direction': 'bidirectional'
 688         }
 689
 690         self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
 691                              res['odu-connection'][0])
 692         self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1-10GE'},
 693                              res['odu-connection'][0]['destination'])
 694         self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1-10GE'},
 695                              res['odu-connection'][0]['source'])
 696
 697     def test_35_check_interface_10GE_CLIENT_spdrc(self):
 698         response = test_utils.check_netconf_node_request(
 699             "SPDR-SC1", "interface/XPDR1-CLIENT1-ETHERNET10G")
 700         self.assertEqual(response.status_code, requests.codes.ok)
 701         res = response.json()
 702         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 703                       'administrative-state': 'inService',
 704                       'supporting-circuit-pack-name': 'CP1-SFP4',
 705                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 706                       'supporting-port': 'CP1-SFP4-P1'
 707                       }
 708         self.assertDictEqual(dict(input_dict, **res['interface'][0]),
 709                              res['interface'][0])
 710         self.assertDictEqual(
 711             {u'speed': 10000},
 712             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 713
 714     def test_36_check_interface_ODU2E_CLIENT_spdrc(self):
 715         response = test_utils.check_netconf_node_request(
 716             "SPDR-SC1", "interface/XPDR1-CLIENT1-ODU2e-service1-10GE")
 717         self.assertEqual(response.status_code, requests.codes.ok)
 718         res = response.json()
 719         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e-service1-10GE',
 720                         'administrative-state': 'inService',
 721                         'supporting-circuit-pack-name': 'CP1-SFP4',
 722                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 723                         'type': 'org-openroadm-interfaces:otnOdu',
 724                         'supporting-port': 'CP1-SFP4-P1'}
 725         input_dict_2 = {
 726             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 727             'rate': 'org-openroadm-otn-common-types:ODU2e',
 728             'monitoring-mode': 'terminated'}
 729
 730         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 731                              res['interface'][0])
 732         self.assertDictEqual(dict(input_dict_2,
 733                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 734                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 735         self.assertDictEqual(
 736             {u'payload-type': u'03', u'exp-payload-type': u'03'},
 737             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 738
 739     def test_37_check_interface_ODU2E_NETWORK_spdrc(self):
 740         response = test_utils.check_netconf_node_request(
 741             "SPDR-SC1", "interface/XPDR1-NETWORK1-ODU2e-service1-10GE")
 742         self.assertEqual(response.status_code, requests.codes.ok)
 743         res = response.json()
 744         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1-10GE',
 745                         'administrative-state': 'inService',
 746                         'supporting-circuit-pack-name': 'CP1-CFP0',
 747                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 748                         'type': 'org-openroadm-interfaces:otnOdu',
 749                         'supporting-port': 'CP1-CFP0-P1'}
 750         input_dict_2 = {
 751             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 752             'rate': 'org-openroadm-otn-common-types:ODU2e',
 753             'monitoring-mode': 'monitored'}
 754
 755         input_dict_3 = {'trib-port-number': 1}
 756
 757         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
 758                              res['interface'][0])
 759         self.assertDictEqual(dict(input_dict_2,
 760                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 761                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 762         self.assertDictEqual(dict(input_dict_3,
 763                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 764                                       'parent-odu-allocation']),
 765                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
 766             'parent-odu-allocation'])
 767         self.assertIn(1,
 768                       res['interface'][0][
 769                           'org-openroadm-otn-odu-interfaces:odu'][
 770                           'parent-odu-allocation']['trib-slots'])
 771
 772     def test_38_check_ODU2E_connection_spdrc(self):
 773         response = test_utils.check_netconf_node_request(
 774             "SPDR-SC1",
 775             "odu-connection/XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE")
 776         self.assertEqual(response.status_code, requests.codes.ok)
 777         res = response.json()
 778         input_dict_1 = {
 779             'connection-name':
 780             'XPDR1-CLIENT1-ODU2e-service1-10GE-x-XPDR1-NETWORK1-ODU2e-service1-10GE',
 781             'direction': 'bidirectional'
 782         }
 783
 784         self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
 785                              res['odu-connection'][0])
 786         self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1-10GE'},
 787                              res['odu-connection'][0]['destination'])
 788         self.assertDictEqual({u'src-if': u'XPDR1-CLIENT1-ODU2e-service1-10GE'},
 789                              res['odu-connection'][0]['source'])
 790
 791     def test_39_check_otn_topo_links(self):
 792         response = test_utils.get_otn_topo_request()
 793         self.assertEqual(response.status_code, requests.codes.ok)
 794         res = response.json()
 795         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 796         self.assertEqual(nb_links, 4)
 797         for link in res['network'][0]['ietf-network-topology:link']:
 798             linkId = link['link-id']
 799             if (linkId in ('ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 800                            'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')):
 801                 self.assertEqual(
 802                     link['org-openroadm-otn-network-topology:available-bandwidth'], 90000)
 803                 self.assertEqual(
 804                     link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
 805
 806     def test_40_check_otn_topo_tp(self):
 807         response = test_utils.get_otn_topo_request()
 808         res = response.json()
 809         for node in res['network'][0]['node']:
 810             if node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1':
 811                 tpList = node['ietf-network-topology:termination-point']
 812                 for tp in tpList:
 813                     if tp['tp-id'] == 'XPDR1-NETWORK1':
 814                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 815                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 72)
 816                         tsPoolList = list(range(1, 9))
 817                         self.assertNotIn(
 818                             tsPoolList, xpdrTpPortConAt['ts-pool'])
 819                         self.assertEqual(
 820                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 79)
 821                         self.assertNotIn(
 822                             1, xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool'])
 823
 824     def test_41_delete_10GE_service(self):
 825         response = test_utils.service_delete_request("service1-10GE")
 826         self.assertEqual(response.status_code, requests.codes.ok)
 827         res = response.json()
 828         self.assertIn('Renderer service delete in progress',
 829                       res['output']['configuration-response-common']['response-message'])
 830         time.sleep(self.WAITING)
 831
 832     def test_42_check_service_list(self):
 833         response = test_utils.get_service_list_request("")
 834         self.assertEqual(response.status_code, requests.codes.ok)
 835         res = response.json()
 836         self.assertEqual(len(res['service-list']['services']), 2)
 837         time.sleep(2)
 838
 839     def test_43_check_no_ODU2e_connection_spdra(self):
 840         response = test_utils.check_netconf_node_request("SPDR-SA1", "")
 841         self.assertEqual(response.status_code, requests.codes.ok)
 842         res = response.json()
 843         self.assertNotIn(['odu-connection'][0], res['org-openroadm-device'])
 844         time.sleep(1)
 845
 846     def test_44_check_no_interface_ODU2E_NETWORK_spdra(self):
 847         response = test_utils.check_netconf_node_request(
 848             "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1")
 849         self.assertEqual(response.status_code, requests.codes.conflict)
 850
 851     def test_45_check_no_interface_ODU2E_CLIENT_spdra(self):
 852         response = test_utils.check_netconf_node_request(
 853             "SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1")
 854         self.assertEqual(response.status_code, requests.codes.conflict)
 855
 856     def test_46_check_no_interface_10GE_CLIENT_spdra(self):
 857         response = test_utils.check_netconf_node_request(
 858             "SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
 859         self.assertEqual(response.status_code, requests.codes.conflict)
 860
 861     def test_47_check_otn_topo_links(self):
 862         response = test_utils.get_otn_topo_request()
 863         self.assertEqual(response.status_code, requests.codes.ok)
 864         res = response.json()
 865         nb_links = len(res['network'][0]['ietf-network-topology:link'])
 866         self.assertEqual(nb_links, 4)
 867         for link in res['network'][0]['ietf-network-topology:link']:
 868             linkId = link['link-id']
 869             if (linkId in ('ODU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 870                            'ODU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')):
 871                 self.assertEqual(
 872                     link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 873                 self.assertEqual(
 874                     link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 875
 876     def test_48_check_otn_topo_tp(self):
 877         response = test_utils.get_otn_topo_request()
 878         res = response.json()
 879         for node in res['network'][0]['node']:
 880             if (node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1'):
 881                 tpList = node['ietf-network-topology:termination-point']
 882                 for tp in tpList:
 883                     if tp['tp-id'] == 'XPDR1-NETWORK1':
 884                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 885                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
 886                         self.assertEqual(
 887                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
 888
 889     def test_49_delete_ODU4_service(self):
 890         response = test_utils.service_delete_request("service1-ODU4")
 891         self.assertEqual(response.status_code, requests.codes.ok)
 892         res = response.json()
 893         self.assertIn('Renderer service delete in progress',
 894                       res['output']['configuration-response-common']['response-message'])
 895         time.sleep(self.WAITING)
 896
 897     def test_50_check_service_list(self):
 898         response = test_utils.get_service_list_request("")
 899         self.assertEqual(response.status_code, requests.codes.ok)
 900         res = response.json()
 901         self.assertEqual(len(res['service-list']['services']), 1)
 902         time.sleep(2)
 903
 904     def test_51_check_no_interface_ODU4_spdra(self):
 905         response = test_utils.check_netconf_node_request(
 906             "SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
 907         self.assertEqual(response.status_code, requests.codes.conflict)
 908
 909     def test_52_check_otn_topo_links(self):
 910         self.test_22_check_otn_topo_otu4_links()
 911
 912     def test_53_check_otn_topo_tp(self):
 913         response = test_utils.get_otn_topo_request()
 914         res = response.json()
 915         for node in res['network'][0]['node']:
 916             if node['node-id'] == 'SPDR-SA1-XPDR1' or 'SPDR-SC1-XPDR1':
 917                 tpList = node['ietf-network-topology:termination-point']
 918                 for tp in tpList:
 919                     if tp['tp-id'] == 'XPDR1-NETWORK1':
 920                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 921                         self.assertNotIn('ts-pool', dict.keys(xpdrTpPortConAt))
 922                         self.assertNotIn(
 923                             'odtu-tpn-pool', dict.keys(xpdrTpPortConAt))
 924
 925     def test_54_delete_OCH_OTU4_service(self):
 926         response = test_utils.service_delete_request("service1-OCH-OTU4")
 927         self.assertEqual(response.status_code, requests.codes.ok)
 928         res = response.json()
 929         self.assertIn('Renderer service delete in progress',
 930                       res['output']['configuration-response-common']['response-message'])
 931         time.sleep(self.WAITING)
 932
 933     def test_55_get_no_service(self):
 934         response = test_utils.get_service_list_request("")
 935         self.assertEqual(response.status_code, requests.codes.conflict)
 936         res = response.json()
 937         self.assertIn(
 938             {"error-type": "application", "error-tag": "data-missing",
 939              "error-message": "Request could not be completed because the relevant data model content does not exist"},
 940             res['errors']['error'])
 941         time.sleep(1)
 942
 943     def test_56_check_no_interface_OTU4_spdra(self):
 944         response = test_utils.check_netconf_node_request(
 945             "SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
 946         self.assertEqual(response.status_code, requests.codes.conflict)
 947
 948     def test_57_check_no_interface_OCH_spdra(self):
 949         response = test_utils.check_netconf_node_request(
 950             "SPDR-SA1", "interface/XPDR1-NETWORK1-1")
 951         self.assertEqual(response.status_code, requests.codes.conflict)
 952
 953     def test_58_getLinks_OtnTopology(self):
 954         response = test_utils.get_otn_topo_request()
 955         self.assertEqual(response.status_code, requests.codes.ok)
 956         res = response.json()
 957         self.assertNotIn('ietf-network-topology:link', res['network'][0])
 958
 959     def test_59_check_openroadm_topo_spdra(self):
 960         response = test_utils.get_ordm_topo_request("node/SPDR-SA1-XPDR1")
 961         self.assertEqual(response.status_code, requests.codes.ok)
 962         res = response.json()
 963         tp = res['node'][0]['ietf-network-topology:termination-point'][0]
 964         self.assertEqual('XPDR1-NETWORK1', tp['tp-id'])
 965         self.assertNotIn('wavelength', dict.keys(
 966             tp[u'org-openroadm-network-topology:xpdr-network-attributes']))
 967         time.sleep(3)
 968
 969     def test_60_check_openroadm_topo_ROADMA_SRG(self):
 970         response = test_utils.get_ordm_topo_request("node/ROADM-A1-SRG1")
 971         self.assertEqual(response.status_code, requests.codes.ok)
 972         res = response.json()
 973         freq_map = base64.b64decode(
 974             res['node'][0]['org-openroadm-network-topology:srg-attributes']['avail-freq-maps'][0]['freq-map'])
 975         freq_map_array = [int(x) for x in freq_map]
 976         self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
 977         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 978         for ele in liste_tp:
 979             if ele['tp-id'] == 'SRG1-PP1-TXRX':
 980                 freq_map = base64.b64decode(
 981                     ele['org-openroadm-network-topology:pp-attributes']['avail-freq-maps'][0]['freq-map'])
 982                 freq_map_array = [int(x) for x in freq_map]
 983                 self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
 984         time.sleep(3)
 985
 986     def test_61_check_openroadm_topo_ROADMA_DEG(self):
 987         response = test_utils.get_ordm_topo_request("node/ROADM-A1-DEG2")
 988         self.assertEqual(response.status_code, requests.codes.ok)
 989         res = response.json()
 990         freq_map = base64.b64decode(
 991             res['node'][0]['org-openroadm-network-topology:degree-attributes']['avail-freq-maps'][0]['freq-map'])
 992         freq_map_array = [int(x) for x in freq_map]
 993         self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
 994         liste_tp = res['node'][0]['ietf-network-topology:termination-point']
 995         for ele in liste_tp:
 996             if ele['tp-id'] == 'DEG2-CTP-TXRX':
 997                 freq_map = base64.b64decode(
 998                     ele['org-openroadm-network-topology:ctp-attributes']['avail-freq-maps'][0]['freq-map'])
 999                 freq_map_array = [int(x) for x in freq_map]
1000                 self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
1001             if ele['tp-id'] == 'DEG2-TTP-TXRX':
1002                 freq_map = base64.b64decode(
1003                     ele['org-openroadm-network-topology:tx-ttp-attributes']['avail-freq-maps'][0]['freq-map'])
1004                 freq_map_array = [int(x) for x in freq_map]
1005                 self.assertEqual(freq_map_array[95], 255, "Lambda 1 should be available")
1006         time.sleep(3)
1007
1008     def test_62_connect_sprdA_3_N1_to_roadmA_PP2(self):
1009         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SA1", "3", "1",
1010                                                           "ROADM-A1", "1", "SRG1-PP2-TXRX")
1011         self.assertEqual(response.status_code, requests.codes.ok)
1012         res = response.json()
1013         self.assertIn('Xponder Roadm Link created successfully',
1014                       res["output"]["result"])
1015         time.sleep(2)
1016
1017     def test_63_connect_roadmA_PP2_to_spdrA_3_N1(self):
1018         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SA1", "3", "1",
1019                                                           "ROADM-A1", "1", "SRG1-PP2-TXRX")
1020         self.assertEqual(response.status_code, requests.codes.ok)
1021         res = response.json()
1022         self.assertIn('Roadm Xponder links created successfully',
1023                       res["output"]["result"])
1024         time.sleep(2)
1025
1026     def test_64_connect_sprdC_3_N1_to_roadmC_PP2(self):
1027         response = test_utils.connect_xpdr_to_rdm_request("SPDR-SC1", "3", "1",
1028                                                           "ROADM-C1", "1", "SRG1-PP2-TXRX")
1029         self.assertEqual(response.status_code, requests.codes.ok)
1030         res = response.json()
1031         self.assertIn('Xponder Roadm Link created successfully',
1032                       res["output"]["result"])
1033         time.sleep(2)
1034
1035     def test_65_connect_roadmC_PP2_to_spdrC_3_N1(self):
1036         response = test_utils.connect_rdm_to_xpdr_request("SPDR-SC1", "3", "1",
1037                                                           "ROADM-C1", "1", "SRG1-PP2-TXRX")
1038         self.assertEqual(response.status_code, requests.codes.ok)
1039         res = response.json()
1040         self.assertIn('Roadm Xponder links created successfully',
1041                       res["output"]["result"])
1042         time.sleep(2)
1043
1044     def test_66_create_OCH_OTU4_service_2(self):
1045         self.cr_serv_sample_data["input"]["service-name"] = "service2-OCH-OTU4"
1046         self.cr_serv_sample_data["input"]["connection-type"] = "infrastructure"
1047         self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "100"
1048         self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "OTU"
1049         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-device-name"] = "SPDR-SA1-XPDR3"
1050         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1051         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-device-name"] = "SPDR-SA1-XPDR3"
1052         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1053         self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"] = "org-openroadm-otn-common-types:OTU4"
1054         self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "100"
1055         self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "OTU"
1056         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
1057         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1058         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
1059         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1060         self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"] = "org-openroadm-otn-common-types:OTU4"
1061         response = test_utils.service_create_request(self.cr_serv_sample_data)
1062         self.assertEqual(response.status_code, requests.codes.ok)
1063         res = response.json()
1064         self.assertIn('PCE calculation in progress',
1065                       res['output']['configuration-response-common']['response-message'])
1066         time.sleep(self.WAITING)
1067
1068     def test_67_get_OCH_OTU4_service2(self):
1069         response = test_utils.get_service_list_request(
1070             "services/service2-OCH-OTU4")
1071         self.assertEqual(response.status_code, requests.codes.ok)
1072         res = response.json()
1073         self.assertEqual(
1074             res['services'][0]['administrative-state'], 'inService')
1075         self.assertEqual(
1076             res['services'][0]['service-name'], 'service2-OCH-OTU4')
1077         self.assertEqual(
1078             res['services'][0]['connection-type'], 'infrastructure')
1079         self.assertEqual(
1080             res['services'][0]['lifecycle-state'], 'planned')
1081         time.sleep(2)
1082
1083     def test_68_create_ODU4_service_2(self):
1084         self.cr_serv_sample_data["input"]["service-name"] = "service2-ODU4"
1085         self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "ODU"
1086         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-device-name"] = "SPDR-SA1-XPDR3"
1087         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1088         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-device-name"] = "SPDR-SA1-XPDR3"
1089         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1090         self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
1091         del self.cr_serv_sample_data["input"]["service-a-end"]["otu-service-rate"]
1092         self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "ODU"
1093         self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
1094         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
1095         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1096         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
1097         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-name"] = "XPDR3-NETWORK1"
1098         del self.cr_serv_sample_data["input"]["service-z-end"]["otu-service-rate"]
1099
1100         response = test_utils.service_create_request(self.cr_serv_sample_data)
1101         self.assertEqual(response.status_code, requests.codes.ok)
1102         res = response.json()
1103         self.assertIn('PCE calculation in progress',
1104                       res['output']['configuration-response-common']['response-message'])
1105         time.sleep(self.WAITING)
1106
1107     def test_69_get_ODU4_service2(self):
1108         response = test_utils.get_service_list_request(
1109             "services/service2-ODU4")
1110         self.assertEqual(response.status_code, requests.codes.ok)
1111         res = response.json()
1112         self.assertEqual(
1113             res['services'][0]['administrative-state'], 'inService')
1114         self.assertEqual(
1115             res['services'][0]['service-name'], 'service2-ODU4')
1116         self.assertEqual(
1117             res['services'][0]['connection-type'], 'infrastructure')
1118         self.assertEqual(
1119             res['services'][0]['lifecycle-state'], 'planned')
1120         time.sleep(2)
1121
1122     def test_70_create_1GE_service(self):
1123         self.cr_serv_sample_data["input"]["service-name"] = "service1-1GE"
1124         self.cr_serv_sample_data["input"]["connection-type"] = "service"
1125         self.cr_serv_sample_data["input"]["service-a-end"]["service-rate"] = "1"
1126         self.cr_serv_sample_data["input"]["service-a-end"]["service-format"] = "Ethernet"
1127         self.cr_serv_sample_data["input"]["service-z-end"]["service-rate"] = "1"
1128         self.cr_serv_sample_data["input"]["service-z-end"]["service-format"] = "Ethernet"
1129         del self.cr_serv_sample_data["input"]["service-a-end"]["odu-service-rate"]
1130         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-device-name"] = "SPDR-SA1-XPDR3"
1131         self.cr_serv_sample_data["input"]["service-a-end"]["tx-direction"]["port"]["port-name"] = "XPDR3-CLIENT1"
1132         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-device-name"] = "SPDR-SA1-XPDR3"
1133         self.cr_serv_sample_data["input"]["service-a-end"]["rx-direction"]["port"]["port-name"] = "XPDR3-CLIENT1"
1134         del self.cr_serv_sample_data["input"]["service-z-end"]["odu-service-rate"]
1135         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
1136         self.cr_serv_sample_data["input"]["service-z-end"]["tx-direction"]["port"]["port-name"] = "XPDR3-CLIENT1"
1137         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-device-name"] = "SPDR-SC1-XPDR3"
1138         self.cr_serv_sample_data["input"]["service-z-end"]["rx-direction"]["port"]["port-name"] = "XPDR3-CLIENT1"
1139         response = test_utils.service_create_request(self.cr_serv_sample_data)
1140         self.assertEqual(response.status_code, requests.codes.ok)
1141         res = response.json()
1142         self.assertIn('PCE calculation in progress',
1143                       res['output']['configuration-response-common']['response-message'])
1144         time.sleep(self.WAITING)
1145
1146     def test_71_get_1GE_service1(self):
1147         response = test_utils.get_service_list_request("services/service1-1GE")
1148         self.assertEqual(response.status_code, requests.codes.ok)
1149         res = response.json()
1150         self.assertEqual(
1151             res['services'][0]['administrative-state'], 'inService')
1152         self.assertEqual(
1153             res['services'][0]['service-name'], 'service1-1GE')
1154         self.assertEqual(
1155             res['services'][0]['connection-type'], 'service')
1156         self.assertEqual(
1157             res['services'][0]['lifecycle-state'], 'planned')
1158         time.sleep(2)
1159
1160     def test_72_check_interface_1GE_CLIENT_spdra(self):
1161         response = test_utils.check_netconf_node_request(
1162             "SPDR-SA1", "interface/XPDR3-CLIENT1-ETHERNET1G")
1163         self.assertEqual(response.status_code, requests.codes.ok)
1164         res = response.json()
1165         input_dict = {'name': 'XPDR3-CLIENT1-ETHERNET1G',
1166                       'administrative-state': 'inService',
1167                       'supporting-circuit-pack-name': 'CP1-SFP4',
1168                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
1169                       'supporting-port': 'CP1-SFP4-P1'
1170                       }
1171         self.assertDictEqual(dict(input_dict, **res['interface'][0]),
1172                              res['interface'][0])
1173         self.assertDictEqual(
1174             {u'speed': 1000},
1175             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
1176
1177     def test_73_check_interface_ODU0_CLIENT_spdra(self):
1178         response = test_utils.check_netconf_node_request(
1179             "SPDR-SA1", "interface/XPDR3-CLIENT1-ODU0-service1-1GE")
1180         self.assertEqual(response.status_code, requests.codes.ok)
1181         res = response.json()
1182         input_dict_1 = {'name': 'XPDR3-CLIENT1-ODU0-service1-1GE',
1183                         'administrative-state': 'inService',
1184                         'supporting-circuit-pack-name': 'CP3-SFP1',
1185                         'supporting-interface': 'XPDR3-CLIENT1-ETHERNET1G',
1186                         'type': 'org-openroadm-interfaces:otnOdu',
1187                         'supporting-port': 'CP3-SFP1-P1'}
1188         input_dict_2 = {
1189             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
1190             'rate': 'org-openroadm-otn-common-types:ODU0',
1191             'monitoring-mode': 'terminated'}
1192
1193         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
1194                              res['interface'][0])
1195         self.assertDictEqual(dict(input_dict_2,
1196                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
1197                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
1198         self.assertDictEqual(
1199             {u'payload-type': u'07', u'exp-payload-type': u'07'},
1200             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
1201
1202     def test_74_check_interface_ODU0_NETWORK_spdra(self):
1203         response = test_utils.check_netconf_node_request(
1204             "SPDR-SA1", "interface/XPDR3-NETWORK1-ODU0-service1-1GE")
1205         self.assertEqual(response.status_code, requests.codes.ok)
1206         res = response.json()
1207         input_dict_1 = {'name': 'XPDR3-NETWORK1-ODU0-service1-1GE',
1208                         'administrative-state': 'inService',
1209                         'supporting-circuit-pack-name': 'CP3-CFP0',
1210                         'supporting-interface': 'XPDR3-NETWORK1-ODU4',
1211                         'type': 'org-openroadm-interfaces:otnOdu',
1212                         'supporting-port': 'CP3-CFP0-P1'}
1213         input_dict_2 = {
1214             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
1215             'rate': 'org-openroadm-otn-common-types:ODU0',
1216             'monitoring-mode': 'monitored'}
1217         input_dict_3 = {'trib-port-number': 1}
1218
1219         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
1220                              res['interface'][0])
1221         self.assertDictEqual(dict(input_dict_2,
1222                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
1223                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
1224         self.assertDictEqual(dict(input_dict_3,
1225                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
1226                                       'parent-odu-allocation']),
1227                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
1228         self.assertIn(1, res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
1229                       ['trib-slots'])
1230
1231     def test_75_check_ODU0_connection_spdra(self):
1232         response = test_utils.check_netconf_node_request(
1233             "SPDR-SA1",
1234             "odu-connection/XPDR3-CLIENT1-ODU0-service1-1GE-x-XPDR3-NETWORK1-ODU0-service1-1GE")
1235         self.assertEqual(response.status_code, requests.codes.ok)
1236         res = response.json()
1237         input_dict_1 = {
1238             'connection-name':
1239             'XPDR3-CLIENT1-ODU0-service1-1GE-x-XPDR3-NETWORK1-ODU0-service1-1GE',
1240             'direction': 'bidirectional'
1241         }
1242
1243         self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
1244                              res['odu-connection'][0])
1245         self.assertDictEqual({u'dst-if': u'XPDR3-NETWORK1-ODU0-service1-1GE'},
1246                              res['odu-connection'][0]['destination'])
1247         self.assertDictEqual({u'src-if': u'XPDR3-CLIENT1-ODU0-service1-1GE'},
1248                              res['odu-connection'][0]['source'])
1249
1250     def test_76_check_interface_1GE_CLIENT_spdrc(self):
1251         response = test_utils.check_netconf_node_request(
1252             "SPDR-SC1", "interface/XPDR3-CLIENT1-ETHERNET1G")
1253         self.assertEqual(response.status_code, requests.codes.ok)
1254         res = response.json()
1255         input_dict = {'name': 'XPDR3-CLIENT1-ETHERNET1G',
1256                       'administrative-state': 'inService',
1257                       'supporting-circuit-pack-name': 'CP3-SFP1',
1258                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
1259                       'supporting-port': 'CP3-SFP1-P1'
1260                       }
1261         self.assertDictEqual(dict(input_dict, **res['interface'][0]),
1262                              res['interface'][0])
1263         self.assertDictEqual(
1264             {u'speed': 1000},
1265             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
1266
1267     def test_77_check_interface_ODU0_CLIENT_spdrc(self):
1268         response = test_utils.check_netconf_node_request(
1269             "SPDR-SC1", "interface/XPDR3-CLIENT1-ODU0-service1-1GE")
1270         self.assertEqual(response.status_code, requests.codes.ok)
1271         res = response.json()
1272         input_dict_1 = {'name': 'XPDR3-CLIENT1-ODU0-service1-1GE',
1273                         'administrative-state': 'inService',
1274                         'supporting-circuit-pack-name': 'CP3-SFP1',
1275                         'supporting-interface': 'XPDR3-CLIENT1-ETHERNET1G',
1276                         'type': 'org-openroadm-interfaces:otnOdu',
1277                         'supporting-port': 'CP3-SFP1-P1'}
1278         input_dict_2 = {
1279             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
1280             'rate': 'org-openroadm-otn-common-types:ODU0',
1281             'monitoring-mode': 'terminated'}
1282
1283         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
1284                              res['interface'][0])
1285         self.assertDictEqual(dict(input_dict_2,
1286                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
1287                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
1288         self.assertDictEqual(
1289             {u'payload-type': u'07', u'exp-payload-type': u'07'},
1290             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
1291
1292     def test_78_check_interface_ODU0_NETWORK_spdrc(self):
1293         response = test_utils.check_netconf_node_request(
1294             "SPDR-SC1", "interface/XPDR3-NETWORK1-ODU0-service1-1GE")
1295         self.assertEqual(response.status_code, requests.codes.ok)
1296         res = response.json()
1297         input_dict_1 = {'name': 'XPDR3-NETWORK1-ODU0-service1-1GE',
1298                         'administrative-state': 'inService',
1299                         'supporting-circuit-pack-name': 'CP3-CFP0',
1300                         'supporting-interface': 'XPDR3-NETWORK1-ODU4',
1301                         'type': 'org-openroadm-interfaces:otnOdu',
1302                         'supporting-port': 'CP3-CFP0-P1'}
1303         input_dict_2 = {
1304             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
1305             'rate': 'org-openroadm-otn-common-types:ODU0',
1306             'monitoring-mode': 'monitored'}
1307
1308         input_dict_3 = {'trib-port-number': 1}
1309
1310         self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
1311                              res['interface'][0])
1312         self.assertDictEqual(dict(input_dict_2,
1313                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
1314                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
1315         self.assertDictEqual(dict(input_dict_3,
1316                                   **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
1317                                       'parent-odu-allocation']),
1318                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
1319             'parent-odu-allocation'])
1320         self.assertIn(1,
1321                       res['interface'][0][
1322                           'org-openroadm-otn-odu-interfaces:odu'][
1323                           'parent-odu-allocation']['trib-slots'])
1324
1325     def test_79_check_ODU0_connection_spdrc(self):
1326         response = test_utils.check_netconf_node_request(
1327             "SPDR-SC1",
1328             "odu-connection/XPDR3-CLIENT1-ODU0-service1-1GE-x-XPDR3-NETWORK1-ODU0-service1-1GE")
1329         self.assertEqual(response.status_code, requests.codes.ok)
1330         res = response.json()
1331         input_dict_1 = {
1332             'connection-name':
1333             'XPDR3-CLIENT1-ODU0-service1-1GE-x-XPDR3-NETWORK1-ODU0-service1-1GE',
1334             'direction': 'bidirectional'
1335         }
1336
1337         self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
1338                              res['odu-connection'][0])
1339         self.assertDictEqual({u'dst-if': u'XPDR3-NETWORK1-ODU0-service1-1GE'},
1340                              res['odu-connection'][0]['destination'])
1341         self.assertDictEqual({u'src-if': u'XPDR3-CLIENT1-ODU0-service1-1GE'},
1342                              res['odu-connection'][0]['source'])
1343
1344     def test_80_check_otn_topo_links(self):
1345         response = test_utils.get_otn_topo_request()
1346         self.assertEqual(response.status_code, requests.codes.ok)
1347         res = response.json()
1348         nb_links = len(res['network'][0]['ietf-network-topology:link'])
1349         self.assertEqual(nb_links, 4)
1350         for link in res['network'][0]['ietf-network-topology:link']:
1351             linkId = link['link-id']
1352             if (linkId in ('ODU4-SPDR-SA1-XPDR3-XPDR3-NETWORK1toSPDR-SC1-XPDR3-XPDR3-NETWORK1',
1353                            'ODU4-SPDR-SC1-XPDR3-XPDR3-NETWORK1toSPDR-SA1-XPDR3-XPDR3-NETWORK1')):
1354                 self.assertEqual(
1355                     link['org-openroadm-otn-network-topology:available-bandwidth'], 99000)
1356                 self.assertEqual(
1357                     link['org-openroadm-otn-network-topology:used-bandwidth'], 1000)
1358
1359     def test_81_check_otn_topo_tp(self):
1360         response = test_utils.get_otn_topo_request()
1361         res = response.json()
1362         for node in res['network'][0]['node']:
1363             if node['node-id'] == 'SPDR-SA1-XPDR3' or 'SPDR-SC1-XPDR3':
1364                 tpList = node['ietf-network-topology:termination-point']
1365                 for tp in tpList:
1366                     if tp['tp-id'] == 'XPDR3-NETWORK1':
1367                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1368                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 79)
1369                         tsPoolList = list(range(1, 2))
1370                         self.assertNotIn(
1371                             tsPoolList, xpdrTpPortConAt['ts-pool'])
1372                         self.assertEqual(
1373                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 79)
1374                         self.assertNotIn(
1375                             1, xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool'])
1376
1377     def test_82_delete_1GE_service(self):
1378         response = test_utils.service_delete_request("service1-1GE")
1379         self.assertEqual(response.status_code, requests.codes.ok)
1380         res = response.json()
1381         self.assertIn('Renderer service delete in progress',
1382                       res['output']['configuration-response-common']['response-message'])
1383         time.sleep(self.WAITING)
1384
1385     def test_83_check_service_list(self):
1386         response = test_utils.get_service_list_request("")
1387         self.assertEqual(response.status_code, requests.codes.ok)
1388         res = response.json()
1389         self.assertEqual(len(res['service-list']['services']), 2)
1390         time.sleep(2)
1391
1392     def test_84_check_no_ODU0_connection_spdra(self):
1393         response = test_utils.check_netconf_node_request("SPDR-SA1", "")
1394         self.assertEqual(response.status_code, requests.codes.ok)
1395         res = response.json()
1396         self.assertNotIn(['odu-connection'][0], res['org-openroadm-device'])
1397         time.sleep(1)
1398
1399     def test_85_check_no_interface_ODU0_NETWORK_spdra(self):
1400         response = test_utils.check_netconf_node_request(
1401             "SPDR-SA1", "interface/XPDR3-NETWORK1-ODU0-service1")
1402         self.assertEqual(response.status_code, requests.codes.conflict)
1403
1404     def test_86_check_no_interface_ODU0_CLIENT_spdra(self):
1405         response = test_utils.check_netconf_node_request(
1406             "SPDR-SA1", "interface/XPDR3-CLIENT1-ODU0-service1")
1407         self.assertEqual(response.status_code, requests.codes.conflict)
1408
1409     def test_87_check_no_interface_10GE_CLIENT_spdra(self):
1410         response = test_utils.check_netconf_node_request(
1411             "SPDR-SA1", "interface/XPDR3-CLIENT1-ETHERNET1G")
1412         self.assertEqual(response.status_code, requests.codes.conflict)
1413
1414     def test_88_check_otn_topo_links(self):
1415         response = test_utils.get_otn_topo_request()
1416         self.assertEqual(response.status_code, requests.codes.ok)
1417         res = response.json()
1418         nb_links = len(res['network'][0]['ietf-network-topology:link'])
1419         self.assertEqual(nb_links, 4)
1420         for link in res['network'][0]['ietf-network-topology:link']:
1421             linkId = link['link-id']
1422             if (linkId in ('ODU4-SPDR-SA1-XPDR3-XPDR3-NETWORK1toSPDR-SC1-XPDR3-XPDR3-NETWORK1',
1423                            'ODU4-SPDR-SC1-XPDR3-XPDR3-NETWORK1toSPDR-SA1-XPDR3-XPDR3-NETWORK1')):
1424                 self.assertEqual(
1425                     link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
1426                 self.assertEqual(
1427                     link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
1428
1429     def test_89_check_otn_topo_tp(self):
1430         response = test_utils.get_otn_topo_request()
1431         res = response.json()
1432         for node in res['network'][0]['node']:
1433             if (node['node-id'] == 'SPDR-SA1-XPDR3' or 'SPDR-SC1-XPDR3'):
1434                 tpList = node['ietf-network-topology:termination-point']
1435                 for tp in tpList:
1436                     if tp['tp-id'] == 'XPDR3-NETWORK1':
1437                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1438                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
1439                         self.assertEqual(
1440                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
1441
1442     def test_90_delete_ODU4_service(self):
1443         response = test_utils.service_delete_request("service2-ODU4")
1444         self.assertEqual(response.status_code, requests.codes.ok)
1445         res = response.json()
1446         self.assertIn('Renderer service delete in progress',
1447                       res['output']['configuration-response-common']['response-message'])
1448         time.sleep(self.WAITING)
1449
1450     def test_91_delete_OCH_OTU4_service(self):
1451         response = test_utils.service_delete_request("service2-OCH-OTU4")
1452         self.assertEqual(response.status_code, requests.codes.ok)
1453         res = response.json()
1454         self.assertIn('Renderer service delete in progress',
1455                       res['output']['configuration-response-common']['response-message'])
1456         time.sleep(self.WAITING)
1457
1458     def test_92_disconnect_xponders_from_roadm(self):
1459         url = "{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
1460         response = test_utils.get_ordm_topo_request("")
1461         self.assertEqual(response.status_code, requests.codes.ok)
1462         res = response.json()
1463         links = res['network'][0]['ietf-network-topology:link']
1464         for link in links:
1465             if (link["org-openroadm-common-network:link-type"] == "XPONDER-OUTPUT" or
1466                     link["org-openroadm-common-network:link-type"] == "XPONDER-INPUT"):
1467                 link_name = link["link-id"]
1468                 response = test_utils.delete_request(url+link_name)
1469                 self.assertEqual(response.status_code, requests.codes.ok)
1470
1471     def test_93_check_openroadm_topology(self):
1472         response = test_utils.get_ordm_topo_request("")
1473         self.assertEqual(response.status_code, requests.codes.ok)
1474         res = response.json()
1475         links = res['network'][0]['ietf-network-topology:link']
1476         self.assertEqual(18, len(links), 'Topology should contain 18 links')
1477
1478     def test_94_disconnect_spdrA(self):
1479         response = test_utils.unmount_device("SPDR-SA1")
1480         self.assertEqual(response.status_code, requests.codes.ok,
1481                          test_utils.CODE_SHOULD_BE_200)
1482
1483     def test_95_disconnect_spdrC(self):
1484         response = test_utils.unmount_device("SPDR-SC1")
1485         self.assertEqual(response.status_code, requests.codes.ok,
1486                          test_utils.CODE_SHOULD_BE_200)
1487
1488     def test_96_disconnect_roadmA(self):
1489         response = test_utils.unmount_device("ROADM-A1")
1490         self.assertEqual(response.status_code, requests.codes.ok,
1491                          test_utils.CODE_SHOULD_BE_200)
1492
1493     def test_97_disconnect_roadmC(self):
1494         response = test_utils.unmount_device("ROADM-C1")
1495         self.assertEqual(response.status_code, requests.codes.ok,
1496                          test_utils.CODE_SHOULD_BE_200)
1497
1498
1499 if __name__ == "__main__":
1500     unittest.main(verbosity=2)