tests/transportpce_tests/2.2.1/test15_otn_end2end_with_intermediate_switch.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2021 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 # pylint: disable=too-many-lines
  15
  16 import unittest
  17 import time
  18 import requests
  19 # pylint: disable=wrong-import-order
  20 import sys
  21 sys.path.append('transportpce_tests/common/')
  22 # pylint: disable=wrong-import-position
  23 # pylint: disable=import-error
  24 import test_utils  # nopep8
  25
  26
  27 class TransportPCEtesting(unittest.TestCase):
  28
  29     processes = None
  30     WAITING = 20  # nominal value is 300
  31     NODE_VERSION = '2.2.1'
  32
  33     cr_serv_input_data = {
  34         "sdnc-request-header": {
  35             "request-id": "request-1",
  36             "rpc-action": "service-create",
  37             "request-system-id": "appname"
  38         },
  39         "service-name": "service-OCH-OTU4-AB",
  40         "common-id": "commonId",
  41         "connection-type": "infrastructure",
  42         "service-a-end": {
  43             "service-rate": "100",
  44             "node-id": "SPDR-SA1",
  45             "service-format": "OTU",
  46             "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
  47             "clli": "NodeSA",
  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                 "index": 0
  63             }],
  64             "rx-direction": [{
  65                 "port": {
  66                     "port-device-name": "SPDR-SA1-XPDR1",
  67                     "port-type": "fixed",
  68                     "port-name": "XPDR1-NETWORK1",
  69                     "port-rack": "000000.00",
  70                     "port-shelf": "Chassis#1"
  71                 },
  72                 "lgx": {
  73                     "lgx-device-name": "Some lgx-device-name",
  74                     "lgx-port-name": "Some lgx-port-name",
  75                     "lgx-port-rack": "000000.00",
  76                     "lgx-port-shelf": "00"
  77                 },
  78                 "index": 0
  79             }],
  80             "optic-type": "gray"
  81         },
  82         "service-z-end": {
  83             "service-rate": "100",
  84             "node-id": "SPDR-SB1",
  85             "service-format": "OTU",
  86             "otu-service-rate": "org-openroadm-otn-common-types:OTU4",
  87             "clli": "NodeSB",
  88             "tx-direction": [{
  89                 "port": {
  90                     "port-device-name": "SPDR-SB1-XPDR2",
  91                     "port-type": "fixed",
  92                     "port-name": "XPDR2-NETWORK1",
  93                     "port-rack": "000000.00",
  94                     "port-shelf": "Chassis#1"
  95                 },
  96                 "lgx": {
  97                     "lgx-device-name": "Some lgx-device-name",
  98                     "lgx-port-name": "Some lgx-port-name",
  99                     "lgx-port-rack": "000000.00",
 100                     "lgx-port-shelf": "00"
 101                 },
 102                 "index": 0
 103             }],
 104             "rx-direction": [{
 105                 "port": {
 106                     "port-device-name": "SPDR-SB1-XPDR2",
 107                     "port-type": "fixed",
 108                     "port-name": "XPDR2-NETWORK1",
 109                     "port-rack": "000000.00",
 110                     "port-shelf": "Chassis#1"
 111                 },
 112                 "lgx": {
 113                     "lgx-device-name": "Some lgx-device-name",
 114                     "lgx-port-name": "Some lgx-port-name",
 115                     "lgx-port-rack": "000000.00",
 116                     "lgx-port-shelf": "00"
 117                 },
 118                 "index": 0
 119             }],
 120             "optic-type": "gray"
 121         },
 122         "due-date": "2018-06-15T00:00:01Z",
 123         "operator-contact": "pw1234"
 124     }
 125     del_serv_input_data = {
 126         "sdnc-request-header": {
 127             "request-id": "e3028bae-a90f-4ddd-a83f-cf224eba0e58",
 128             "rpc-action": "service-delete",
 129             "request-system-id": "appname",
 130             "notification-url": "http://localhost:8585/NotificationServer/notify"},
 131         "service-delete-req-info": {
 132             "service-name": "TBD",
 133             "tail-retention": "no"}
 134     }
 135
 136     @classmethod
 137     def setUpClass(cls):
 138         cls.processes = test_utils.start_tpce()
 139         cls.processes = test_utils.start_sims([('spdra', cls.NODE_VERSION),
 140                                                ('spdrb', cls.NODE_VERSION),
 141                                                ('spdrc', cls.NODE_VERSION),
 142                                                ('roadma', cls.NODE_VERSION),
 143                                                ('roadmb', cls.NODE_VERSION),
 144                                                ('roadmc', cls.NODE_VERSION)])
 145
 146     @classmethod
 147     def tearDownClass(cls):
 148         # pylint: disable=not-an-iterable
 149         for process in cls.processes:
 150             test_utils.shutdown_process(process)
 151         print("all processes killed")
 152
 153     def setUp(self):
 154         time.sleep(2)
 155
 156     def test_001_connect_spdrA(self):
 157         response = test_utils.mount_device("SPDR-SA1", ('spdra', self.NODE_VERSION))
 158         self.assertEqual(response.status_code,
 159                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 160
 161     def test_002_connect_spdrB(self):
 162         response = test_utils.mount_device("SPDR-SB1", ('spdrb', self.NODE_VERSION))
 163         self.assertEqual(response.status_code,
 164                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 165
 166     def test_003_connect_spdrC(self):
 167         response = test_utils.mount_device("SPDR-SC1", ('spdrc', self.NODE_VERSION))
 168         self.assertEqual(response.status_code,
 169                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 170
 171     def test_004_connect_rdmA(self):
 172         response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
 173         self.assertEqual(response.status_code,
 174                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 175
 176     def test_005_connect_rdmB(self):
 177         response = test_utils.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
 178         self.assertEqual(response.status_code,
 179                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 180
 181     def test_006_connect_rdmC(self):
 182         response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
 183         self.assertEqual(response.status_code,
 184                          requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 185
 186     def test_007_connect_sprdA_1_N1_to_roadmA_PP1(self):
 187         response = test_utils.transportpce_api_rpc_request(
 188             'transportpce-networkutils', 'init-xpdr-rdm-links',
 189             {'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '1', 'network-num': '1',
 190                              'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 191         self.assertEqual(response['status_code'], requests.codes.ok)
 192         self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
 193         time.sleep(2)
 194
 195     def test_008_connect_roadmA_PP1_to_spdrA_1_N1(self):
 196         response = test_utils.transportpce_api_rpc_request(
 197             'transportpce-networkutils', 'init-rdm-xpdr-links',
 198             {'links-input': {'xpdr-node': 'SPDR-SA1', 'xpdr-num': '1', 'network-num': '1',
 199                              'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 200         self.assertEqual(response['status_code'], requests.codes.ok)
 201         self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
 202         time.sleep(2)
 203
 204     def test_009_connect_sprdC_1_N1_to_roadmC_PP1(self):
 205         response = test_utils.transportpce_api_rpc_request(
 206             'transportpce-networkutils', 'init-xpdr-rdm-links',
 207             {'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '1', 'network-num': '1',
 208                              'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 209         self.assertEqual(response['status_code'], requests.codes.ok)
 210         self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
 211         time.sleep(2)
 212
 213     def test_010_connect_roadmC_PP1_to_spdrC_1_N1(self):
 214         response = test_utils.transportpce_api_rpc_request(
 215             'transportpce-networkutils', 'init-rdm-xpdr-links',
 216             {'links-input': {'xpdr-node': 'SPDR-SC1', 'xpdr-num': '1', 'network-num': '1',
 217                              'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 218         self.assertEqual(response['status_code'], requests.codes.ok)
 219         self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
 220         time.sleep(2)
 221
 222     def test_011_connect_sprdB_2_N1_to_roadmB_PP1(self):
 223         response = test_utils.transportpce_api_rpc_request(
 224             'transportpce-networkutils', 'init-xpdr-rdm-links',
 225             {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '1',
 226                              'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 227         self.assertEqual(response['status_code'], requests.codes.ok)
 228         self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
 229         time.sleep(2)
 230
 231     def test_012_connect_roadmB_PP1_to_spdrB_2_N1(self):
 232         response = test_utils.transportpce_api_rpc_request(
 233             'transportpce-networkutils', 'init-rdm-xpdr-links',
 234             {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '1',
 235                              'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 236         self.assertEqual(response['status_code'], requests.codes.ok)
 237         self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
 238         time.sleep(2)
 239
 240     def test_013_connect_sprdB_2_N2_to_roadmB_PP2(self):
 241         response = test_utils.transportpce_api_rpc_request(
 242             'transportpce-networkutils', 'init-xpdr-rdm-links',
 243             {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '2',
 244                              'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
 245         self.assertEqual(response['status_code'], requests.codes.ok)
 246         self.assertIn('Xponder Roadm Link created successfully', response["output"]["result"])
 247         time.sleep(2)
 248
 249     def test_014_connect_roadmB_PP2_to_spdrB_2_N2(self):
 250         response = test_utils.transportpce_api_rpc_request(
 251             'transportpce-networkutils', 'init-rdm-xpdr-links',
 252             {'links-input': {'xpdr-node': 'SPDR-SB1', 'xpdr-num': '2', 'network-num': '2',
 253                              'rdm-node': 'ROADM-B1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP2-TXRX'}})
 254         self.assertEqual(response['status_code'], requests.codes.ok)
 255         self.assertIn('Roadm Xponder links created successfully', response["output"]["result"])
 256         time.sleep(2)
 257
 258     def test_015_add_omsAttributes_ROADMA_ROADMB(self):
 259         # Config ROADMA-ROADMC oms-attributes
 260         data = {"span": {
 261             "auto-spanloss": "true",
 262             "spanloss-base": 11.4,
 263             "spanloss-current": 12,
 264             "engineered-spanloss": 12.2,
 265             "link-concatenation": [{
 266                 "SRLG-Id": 0,
 267                 "fiber-type": "smf",
 268                 "SRLG-length": 100000,
 269                 "pmd": 0.5}]}}
 270         response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX",
 271                                                    data)
 272         self.assertEqual(response.status_code, requests.codes.created)
 273
 274     def test_016_add_omsAttributes_ROADMB_ROADMA(self):
 275         # Config ROADMC-ROADMA oms-attributes
 276         data = {"span": {
 277             "auto-spanloss": "true",
 278             "spanloss-base": 11.4,
 279             "spanloss-current": 12,
 280             "engineered-spanloss": 12.2,
 281             "link-concatenation": [{
 282                 "SRLG-Id": 0,
 283                 "fiber-type": "smf",
 284                 "SRLG-length": 100000,
 285                 "pmd": 0.5}]}}
 286         response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX",
 287                                                    data)
 288         self.assertEqual(response.status_code, requests.codes.created)
 289
 290     def test_017_add_omsAttributes_ROADMB_ROADMC(self):
 291         # Config ROADMA-ROADMC oms-attributes
 292         data = {"span": {
 293             "auto-spanloss": "true",
 294             "spanloss-base": 11.4,
 295             "spanloss-current": 12,
 296             "engineered-spanloss": 12.2,
 297             "link-concatenation": [{
 298                 "SRLG-Id": 0,
 299                 "fiber-type": "smf",
 300                 "SRLG-length": 100000,
 301                 "pmd": 0.5}]}}
 302         response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX",
 303                                                    data)
 304         self.assertEqual(response.status_code, requests.codes.created)
 305
 306     def test_018_add_omsAttributes_ROADMC_ROADMB(self):
 307         # Config ROADMC-ROADMA oms-attributes
 308         data = {"span": {
 309             "auto-spanloss": "true",
 310             "spanloss-base": 11.4,
 311             "spanloss-current": 12,
 312             "engineered-spanloss": 12.2,
 313             "link-concatenation": [{
 314                 "SRLG-Id": 0,
 315                 "fiber-type": "smf",
 316                 "SRLG-length": 100000,
 317                 "pmd": 0.5}]}}
 318         response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX",
 319                                                    data)
 320         self.assertEqual(response.status_code, requests.codes.created)
 321
 322     def test_019_create_OTS_ROADMA_DEG1(self):
 323         response = test_utils.transportpce_api_rpc_request(
 324             'transportpce-device-renderer', 'create-ots-oms',
 325             {
 326                 'node-id': 'ROADM-A1',
 327                 'logical-connection-point': 'DEG1-TTP-TXRX'
 328             })
 329         self.assertEqual(response['status_code'], requests.codes.ok)
 330         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-A1',
 331                       response["output"]["result"])
 332
 333     def test_020_create_OTS_ROADMB_DEG1(self):
 334         response = test_utils.transportpce_api_rpc_request(
 335             'transportpce-device-renderer', 'create-ots-oms',
 336             {
 337                 'node-id': 'ROADM-B1',
 338                 'logical-connection-point': 'DEG1-TTP-TXRX'
 339             })
 340         self.assertEqual(response['status_code'], requests.codes.ok)
 341         self.assertIn('Interfaces OTS-DEG1-TTP-TXRX - OMS-DEG1-TTP-TXRX successfully created on node ROADM-B1',
 342                       response["output"]["result"])
 343
 344     def test_021_create_OTS_ROADMB_DEG2(self):
 345         response = test_utils.transportpce_api_rpc_request(
 346             'transportpce-device-renderer', 'create-ots-oms',
 347             {
 348                 'node-id': 'ROADM-B1',
 349                 'logical-connection-point': 'DEG2-TTP-TXRX'
 350             })
 351         self.assertEqual(response['status_code'], requests.codes.ok)
 352         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-B1',
 353                       response["output"]["result"])
 354
 355     def test_022_create_OTS_ROADMC_DEG2(self):
 356         response = test_utils.transportpce_api_rpc_request(
 357             'transportpce-device-renderer', 'create-ots-oms',
 358             {
 359                 'node-id': 'ROADM-C1',
 360                 'logical-connection-point': 'DEG2-TTP-TXRX'
 361             })
 362         self.assertEqual(response['status_code'], requests.codes.ok)
 363         self.assertIn('Interfaces OTS-DEG2-TTP-TXRX - OMS-DEG2-TTP-TXRX successfully created on node ROADM-C1',
 364                       response["output"]["result"])
 365
 366     def test_023_calculate_span_loss_base_all(self):
 367         response = test_utils.transportpce_api_rpc_request(
 368             'transportpce-olm', 'calculate-spanloss-base',
 369             {
 370                 'src-type': 'all'
 371             })
 372         self.assertEqual(response['status_code'], requests.codes.ok)
 373         self.assertIn('Success', response["output"]["result"])
 374         self.assertIn({
 375             "spanloss": "25.7",
 376             "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX"
 377         }, response["output"]["spans"])
 378         self.assertIn({
 379             "spanloss": "17.6",
 380             "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX"
 381         }, response["output"]["spans"])
 382         self.assertIn({
 383             "spanloss": "23.6",
 384             "link-id": "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX"
 385         }, response["output"]["spans"])
 386         self.assertIn({
 387             "spanloss": "23.6",
 388             "link-id": "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX"
 389         }, response["output"]["spans"])
 390         self.assertIn({
 391             "spanloss": "25.7",
 392             "link-id": "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX"
 393         }, response["output"]["spans"])
 394         self.assertIn({
 395             "spanloss": "17.6",
 396             "link-id": "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX"
 397         }, response["output"]["spans"])
 398         time.sleep(5)
 399
 400     def test_024_check_otn_topology(self):
 401         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 402         self.assertEqual(response['status_code'], requests.codes.ok)
 403         self.assertEqual(len(response['network'][0]['node']), 9, 'There should be 9 nodes')
 404         self.assertNotIn('ietf-network-topology:link', response['network'][0],
 405                          'otn-topology should have no link')
 406
 407 # test service-create for OCH-OTU4 service from spdrA to spdrB
 408     def test_025_create_OCH_OTU4_service_AB(self):
 409         response = test_utils.transportpce_api_rpc_request(
 410             'org-openroadm-service', 'service-create',
 411             self.cr_serv_input_data)
 412         self.assertEqual(response['status_code'], requests.codes.ok)
 413         self.assertIn('PCE calculation in progress',
 414                       response['output']['configuration-response-common']['response-message'])
 415         time.sleep(self.WAITING)
 416
 417     def test_026_get_OCH_OTU4_service_AB(self):
 418         response = test_utils.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-AB")
 419         self.assertEqual(response['status_code'], requests.codes.ok)
 420         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
 421         self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-AB')
 422         self.assertEqual(response['services'][0]['connection-type'], 'infrastructure')
 423         self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
 424         time.sleep(1)
 425
 426     def test_027_check_otn_topo_otu4_links(self):
 427         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 428         self.assertEqual(response['status_code'], requests.codes.ok)
 429         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 2)
 430         listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1',
 431                       'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1']
 432         for link in response['network'][0]['ietf-network-topology:link']:
 433             self.assertIn(link['link-id'], listLinkId)
 434             self.assertEqual(
 435                 link['transportpce-networkutils:otn-link-type'], 'OTU4')
 436             self.assertEqual(
 437                 link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 438             self.assertEqual(
 439                 link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 440             self.assertEqual(
 441                 link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 442             self.assertIn(
 443                 link['org-openroadm-common-network:opposite-link'], listLinkId)
 444
 445 # test service-create for OCH-OTU4 service from spdrB to spdrC
 446     def test_028_create_OCH_OTU4_service_BC(self):
 447         self.cr_serv_input_data["service-name"] = "service-OCH-OTU4-BC"
 448         self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SB1"
 449         self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSB"
 450         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2"
 451         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2"
 452         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2"
 453         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2"
 454         self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1"
 455         self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC"
 456         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
 457         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
 458         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
 459         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
 460         response = test_utils.transportpce_api_rpc_request(
 461             'org-openroadm-service', 'service-create',
 462             self.cr_serv_input_data)
 463         self.assertEqual(response['status_code'], requests.codes.ok)
 464         self.assertIn('PCE calculation in progress',
 465                       response['output']['configuration-response-common']['response-message'])
 466         time.sleep(self.WAITING)
 467
 468     def test_029_get_OCH_OTU4_service_BC(self):
 469         response = test_utils.get_ordm_serv_list_attr_request("services", "service-OCH-OTU4-BC")
 470         self.assertEqual(response['status_code'], requests.codes.ok)
 471         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
 472         self.assertEqual(response['services'][0]['service-name'], 'service-OCH-OTU4-BC')
 473         self.assertEqual(response['services'][0]['connection-type'], 'infrastructure')
 474         self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
 475         time.sleep(1)
 476
 477     def test_030_check_otn_topo_otu4_links(self):
 478         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 479         self.assertEqual(response['status_code'], requests.codes.ok)
 480         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 4)
 481         listLinkId = ['OTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1',
 482                       'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1',
 483                       'OTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK2toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 484                       'OTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK2']
 485         for link in response['network'][0]['ietf-network-topology:link']:
 486             self.assertIn(link['link-id'], listLinkId)
 487             self.assertEqual(
 488                 link['transportpce-networkutils:otn-link-type'], 'OTU4')
 489             self.assertEqual(
 490                 link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 491             self.assertEqual(
 492                 link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 493             self.assertEqual(
 494                 link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 495             self.assertIn(
 496                 link['org-openroadm-common-network:opposite-link'], listLinkId)
 497
 498
 499 # test service-create for ODU4 service from spdrA to spdrC via spdrB
 500
 501
 502     def test_031_create_ODU4_service(self):
 503         self.cr_serv_input_data["service-name"] = "service-ODU4-ABC"
 504         self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SA1"
 505         self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSA"
 506         self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU"
 507         del self.cr_serv_input_data["service-a-end"]["otu-service-rate"]
 508         self.cr_serv_input_data["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
 509         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1"
 510         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
 511         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1"
 512         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
 513         self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1"
 514         self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC"
 515         self.cr_serv_input_data["service-z-end"]["service-format"] = "ODU"
 516         del self.cr_serv_input_data["service-z-end"]["otu-service-rate"]
 517         self.cr_serv_input_data["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
 518         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
 519         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
 520         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
 521         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
 522
 523         response = test_utils.transportpce_api_rpc_request(
 524             'org-openroadm-service', 'service-create',
 525             self.cr_serv_input_data)
 526         self.assertEqual(response['status_code'], requests.codes.ok)
 527         self.assertIn('PCE calculation in progress',
 528                       response['output']['configuration-response-common']['response-message'])
 529         time.sleep(self.WAITING)
 530
 531     def test_032_get_ODU4_service_ABC(self):
 532         response = test_utils.get_ordm_serv_list_attr_request("services", "service-ODU4-ABC")
 533         self.assertEqual(response['status_code'], requests.codes.ok)
 534         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
 535         self.assertEqual(response['services'][0]['service-name'], 'service-ODU4-ABC')
 536         self.assertEqual(response['services'][0]['connection-type'], 'infrastructure')
 537         self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
 538         time.sleep(1)
 539
 540     def test_033_check_interface_ODU4_spdra(self):
 541         response = test_utils.check_node_attribute_request(
 542             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4')
 543         self.assertEqual(response['status_code'], requests.codes.ok)
 544         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 545                         'administrative-state': 'inService',
 546                         'supporting-circuit-pack-name': 'CP1-CFP0',
 547                         'type': 'org-openroadm-interfaces:otnOdu',
 548                         'supporting-port': 'CP1-CFP0-P1'}
 549         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 550                         'rate': 'org-openroadm-otn-common-types:ODU4',
 551                         'expected-dapi': 'H/OelLynehI=',
 552                         'expected-sapi': 'AMf1n5hK6Xkk',
 553                         'tx-dapi': 'AMf1n5hK6Xkk',
 554                         'tx-sapi': 'H/OelLynehI='}
 555
 556         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 557                              response['interface'][0])
 558         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 559                                   **input_dict_2),
 560                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 561         self.assertDictEqual(
 562             {'payload-type': '21', 'exp-payload-type': '21'},
 563             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 564
 565         response2 = test_utils.check_node_attribute2_request(
 566             'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4', 'org-openroadm-otn-odu-interfaces:odu')
 567         self.assertEqual(response2['status_code'], requests.codes.ok)
 568         self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
 569         self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
 570         self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
 571         self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
 572
 573     def test_034_check_interface_ODU4_spdrc(self):
 574         response = test_utils.check_node_attribute_request(
 575             'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4')
 576         self.assertEqual(response['status_code'], requests.codes.ok)
 577         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
 578                         'administrative-state': 'inService',
 579                         'supporting-circuit-pack-name': 'CP1-CFP0',
 580                         'type': 'org-openroadm-interfaces:otnOdu',
 581                         'supporting-port': 'CP1-CFP0-P1'}
 582         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
 583                         'rate': 'org-openroadm-otn-common-types:ODU4',
 584                         'expected-dapi': 'AMf1n5hK6Xkk',
 585                         'expected-sapi': 'H/OelLynehI=',
 586                         'tx-dapi': 'H/OelLynehI=',
 587                         'tx-sapi': 'AMf1n5hK6Xkk'}
 588         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 589                              response['interface'][0])
 590         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 591                                   **input_dict_2),
 592                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 593         self.assertDictEqual(
 594             {'payload-type': '21', 'exp-payload-type': '21'},
 595             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 596
 597         response2 = test_utils.check_node_attribute2_request(
 598             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4', 'org-openroadm-otn-odu-interfaces:odu')
 599         self.assertEqual(response2['status_code'], requests.codes.ok)
 600         self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
 601         self.assertEqual(input_dict_2['tx-sapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
 602         self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
 603         self.assertEqual(input_dict_2['tx-dapi'], response2['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
 604
 605     def test_035_check_interface_ODU4_NETWORK1_spdrb(self):
 606         response = test_utils.check_node_attribute_request(
 607             'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4')
 608         self.assertEqual(response['status_code'], requests.codes.ok)
 609         input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
 610                         'administrative-state': 'inService',
 611                         'supporting-circuit-pack-name': 'CP5-CFP',
 612                         'type': 'org-openroadm-interfaces:otnOdu',
 613                         'supporting-port': 'CP5-CFP-P1'}
 614         input_dict_2 = {
 615             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 616             'rate': 'org-openroadm-otn-common-types:ODU4',
 617             'monitoring-mode': 'monitored'}
 618         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 619                              response['interface'][0])
 620         self.assertDictEqual(dict(input_dict_2,
 621                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 622                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 623         self.assertNotIn('opu',
 624                          dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
 625
 626     def test_036_check_interface_ODU4_NETWORK2_spdrb(self):
 627         response = test_utils.check_node_attribute_request(
 628             'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4')
 629         self.assertEqual(response['status_code'], requests.codes.ok)
 630         input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
 631                         'administrative-state': 'inService',
 632                         'supporting-circuit-pack-name': 'CP6-CFP',
 633                         'type': 'org-openroadm-interfaces:otnOdu',
 634                         'supporting-port': 'CP6-CFP-P1'}
 635         input_dict_2 = {
 636             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 637             'rate': 'org-openroadm-otn-common-types:ODU4',
 638             'monitoring-mode': 'monitored'}
 639
 640         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 641                              response['interface'][0])
 642         self.assertDictEqual(dict(input_dict_2,
 643                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
 644                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
 645         self.assertNotIn('opu',
 646                          dict.keys(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']))
 647
 648     def test_037_check_ODU4_connection_spdrb(self):
 649         response = test_utils.check_node_attribute_request(
 650             'SPDR-SB1', 'odu-connection', 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4')
 651         self.assertEqual(response['status_code'], requests.codes.ok)
 652         input_dict_1 = {
 653             'connection-name': 'XPDR2-NETWORK1-ODU4-x-XPDR2-NETWORK2-ODU4',
 654             'direction': 'bidirectional'
 655         }
 656
 657         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 658                              response['odu-connection'][0])
 659         self.assertDictEqual({'dst-if': 'XPDR2-NETWORK2-ODU4'},
 660                              response['odu-connection'][0]['destination'])
 661         self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU4'},
 662                              response['odu-connection'][0]['source'])
 663
 664     def test_038_check_otn_topo_links(self):
 665         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 666         self.assertEqual(response['status_code'], requests.codes.ok)
 667         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
 668         for link in response['network'][0]['ietf-network-topology:link']:
 669             if 'OTU4' in link['link-id']:
 670                 self.assertEqual(
 671                     link['org-openroadm-otn-network-topology:available-bandwidth'], 0)
 672                 self.assertEqual(
 673                     link['org-openroadm-otn-network-topology:used-bandwidth'], 100000)
 674             elif 'ODTU4' in link['link-id']:
 675                 self.assertEqual(
 676                     link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
 677                 self.assertEqual(
 678                     link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
 679                 self.assertEqual(
 680                     link['transportpce-networkutils:otn-link-type'], 'ODTU4')
 681                 self.assertEqual(
 682                     link['org-openroadm-common-network:link-type'], 'OTN-LINK')
 683                 self.assertIn(link['org-openroadm-common-network:opposite-link'],
 684                               ['ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 685                                'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1'])
 686             else:
 687                 self.fail("this link should not exist")
 688
 689     def test_039_check_otn_topo_tp(self):
 690         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 691         self.assertEqual(response['status_code'], requests.codes.ok)
 692         for node in response['network'][0]['node']:
 693             if node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1':
 694                 tpList = node['ietf-network-topology:termination-point']
 695                 for tp in tpList:
 696                     if tp['tp-id'] == 'XPDR1-NETWORK1':
 697                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 698                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
 699                         self.assertEqual(
 700                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
 701                         self.assertEqual(xpdrTpPortConAt['odtu-tpn-pool'][0]['odtu-type'],
 702                                          'org-openroadm-otn-common-types:ODTU4.ts-Allocated')
 703
 704
 705 # test service-create for 10GE service from spdr to spdr
 706
 707
 708     def test_040_create_10GE_service(self):
 709         self.cr_serv_input_data["service-name"] = "service1-10GE"
 710         self.cr_serv_input_data["connection-type"] = "service"
 711         self.cr_serv_input_data["service-a-end"]["service-rate"] = "10"
 712         self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet"
 713         del self.cr_serv_input_data["service-a-end"]["odu-service-rate"]
 714         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
 715         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
 716         self.cr_serv_input_data["service-z-end"]["service-rate"] = "10"
 717         self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet"
 718         del self.cr_serv_input_data["service-z-end"]["odu-service-rate"]
 719         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
 720         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
 721         response = test_utils.transportpce_api_rpc_request(
 722             'org-openroadm-service', 'service-create',
 723             self.cr_serv_input_data)
 724         self.assertEqual(response['status_code'], requests.codes.ok)
 725         self.assertIn('PCE calculation in progress',
 726                       response['output']['configuration-response-common']['response-message'])
 727         time.sleep(self.WAITING)
 728
 729     def test_041_get_10GE_service1(self):
 730         response = test_utils.get_ordm_serv_list_attr_request("services", "service1-10GE")
 731         self.assertEqual(response['status_code'], requests.codes.ok)
 732         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
 733         self.assertEqual(response['services'][0]['service-name'], 'service1-10GE')
 734         self.assertEqual(response['services'][0]['connection-type'], 'service')
 735         self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
 736         time.sleep(1)
 737
 738     def test_042_check_interface_10GE_CLIENT_spdra(self):
 739         response = test_utils.check_node_attribute_request(
 740             'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
 741         self.assertEqual(response['status_code'], requests.codes.ok)
 742         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
 743                       'administrative-state': 'inService',
 744                       'supporting-circuit-pack-name': 'CP1-SFP4',
 745                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
 746                       'supporting-port': 'CP1-SFP4-P1'
 747                       }
 748         self.assertDictEqual(dict(input_dict, **response['interface'][0]),
 749                              response['interface'][0])
 750         self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
 751
 752     def test_043_check_interface_ODU2E_CLIENT_spdra(self):
 753         response = test_utils.check_node_attribute_request(
 754             'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e')
 755         self.assertEqual(response['status_code'], requests.codes.ok)
 756         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e',
 757                         'administrative-state': 'inService',
 758                         'supporting-circuit-pack-name': 'CP1-SFP4',
 759                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 760                         'type': 'org-openroadm-interfaces:otnOdu',
 761                         'supporting-port': 'CP1-SFP4-P1'}
 762         input_dict_2 = {
 763             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 764             'rate': 'org-openroadm-otn-common-types:ODU2e',
 765             'monitoring-mode': 'terminated',
 766             'expected-dapi': 'B68VWipZAU0=',
 767             'expected-sapi': 'BcwI5xz79t8=',
 768             'tx-dapi': 'BcwI5xz79t8=',
 769             'tx-sapi': 'B68VWipZAU0='}
 770
 771         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 772                              response['interface'][0])
 773         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 774                                   **input_dict_2),
 775                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 776                              )
 777         self.assertDictEqual(
 778             {'payload-type': '03', 'exp-payload-type': '03'},
 779             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 780
 781         response2 = test_utils.check_node_attribute_request(
 782             'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ODU2e')
 783         self.assertEqual(response['status_code'], requests.codes.ok)
 784         self.assertEqual(input_dict_2['tx-sapi'],
 785                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
 786         self.assertEqual(input_dict_2['tx-sapi'],
 787                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
 788         self.assertEqual(input_dict_2['tx-dapi'],
 789                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
 790         self.assertEqual(input_dict_2['tx-dapi'],
 791                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
 792
 793     def test_044_check_interface_ODU2E_NETWORK_spdra(self):
 794         response = test_utils.check_node_attribute_request(
 795             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU2e')
 796         self.assertEqual(response['status_code'], requests.codes.ok)
 797         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
 798                         'administrative-state': 'inService',
 799                         'supporting-circuit-pack-name': 'CP1-CFP0',
 800                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 801                         'type': 'org-openroadm-interfaces:otnOdu',
 802                         'supporting-port': 'CP1-CFP0-P1'}
 803         input_dict_2 = {
 804             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 805             'rate': 'org-openroadm-otn-common-types:ODU2e',
 806             'monitoring-mode': 'monitored'}
 807         input_dict_3 = {'trib-port-number': 1}
 808
 809         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 810                              response['interface'][0])
 811         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 812                                   **input_dict_2),
 813                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 814                              )
 815         self.assertDictEqual(dict(input_dict_3,
 816                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 817                                   ['parent-odu-allocation']),
 818                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
 819         self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
 820                       ['trib-slots'])
 821
 822     def test_045_check_ODU2E_connection_spdra(self):
 823         response = test_utils.check_node_attribute_request(
 824             'SPDR-SA1', 'odu-connection', 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e')
 825         self.assertEqual(response['status_code'], requests.codes.ok)
 826         input_dict_1 = {
 827             'connection-name':
 828             'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
 829             'direction': 'bidirectional'
 830         }
 831         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 832                              response['odu-connection'][0])
 833         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'},
 834                              response['odu-connection'][0]['destination'])
 835         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'},
 836                              response['odu-connection'][0]['source'])
 837
 838     def test_046_check_interface_10GE_CLIENT_spdrc(self):
 839         response = test_utils.check_node_attribute_request(
 840             'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
 841         self.assertEqual(response['status_code'], requests.codes.ok)
 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, **response['interface'][0]),
 849                              response['interface'][0])
 850         self.assertEqual(10000, response['interface'][0]['org-openroadm-ethernet-interfaces:ethernet']['speed'])
 851
 852     def test_047_check_interface_ODU2E_CLIENT_spdrc(self):
 853         response = test_utils.check_node_attribute_request(
 854             'SPDR-SC1', 'interface', 'XPDR1-CLIENT1-ODU2e')
 855         self.assertEqual(response['status_code'], requests.codes.ok)
 856         input_dict_1 = {'name': 'XPDR1-CLIENT1-ODU2e',
 857                         'administrative-state': 'inService',
 858                         'supporting-circuit-pack-name': 'CP1-SFP4',
 859                         'supporting-interface': 'XPDR1-CLIENT1-ETHERNET10G',
 860                         'type': 'org-openroadm-interfaces:otnOdu',
 861                         'supporting-port': 'CP1-SFP4-P1'}
 862         input_dict_2 = {
 863             'odu-function': 'org-openroadm-otn-common-types:ODU-TTP-CTP',
 864             'rate': 'org-openroadm-otn-common-types:ODU2e',
 865             'monitoring-mode': 'terminated',
 866             'expected-dapi': 'BcwI5xz79t8=',
 867             'expected-sapi': 'B68VWipZAU0=',
 868             'tx-dapi': 'B68VWipZAU0=',
 869             'tx-sapi': 'BcwI5xz79t8='}
 870
 871         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 872                              response['interface'][0])
 873         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 874                                   **input_dict_2),
 875                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 876                              )
 877         self.assertDictEqual(
 878             {'payload-type': '03', 'exp-payload-type': '03'},
 879             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 880
 881         response2 = test_utils.check_node_attribute_request(
 882             'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e')
 883         self.assertEqual(response['status_code'], requests.codes.ok)
 884         self.assertEqual(input_dict_2['tx-sapi'],
 885                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
 886         self.assertEqual(input_dict_2['tx-sapi'],
 887                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
 888         self.assertEqual(input_dict_2['tx-dapi'],
 889                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
 890         self.assertEqual(input_dict_2['tx-dapi'],
 891                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
 892
 893     def test_048_check_interface_ODU2E_NETWORK_spdrc(self):
 894         response = test_utils.check_node_attribute_request(
 895             'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU2e')
 896         self.assertEqual(response['status_code'], requests.codes.ok)
 897         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e',
 898                         'administrative-state': 'inService',
 899                         'supporting-circuit-pack-name': 'CP1-CFP0',
 900                         'supporting-interface': 'XPDR1-NETWORK1-ODU4',
 901                         'type': 'org-openroadm-interfaces:otnOdu',
 902                         'supporting-port': 'CP1-CFP0-P1'}
 903         input_dict_2 = {
 904             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
 905             'rate': 'org-openroadm-otn-common-types:ODU2e',
 906             'monitoring-mode': 'monitored'}
 907         input_dict_3 = {'trib-port-number': 1}
 908
 909         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
 910                              response['interface'][0])
 911         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
 912                                   **input_dict_2),
 913                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 914                              )
 915         self.assertDictEqual(dict(input_dict_3,
 916                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
 917                                   ['parent-odu-allocation']),
 918                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
 919         self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
 920                       ['trib-slots'])
 921
 922     def test_049_check_ODU2E_connection_spdrc(self):
 923         response = test_utils.check_node_attribute_request(
 924             'SPDR-SC1', 'odu-connection', 'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e')
 925         self.assertEqual(response['status_code'], requests.codes.ok)
 926         input_dict_1 = {
 927             'connection-name':
 928             'XPDR1-CLIENT1-ODU2e-x-XPDR1-NETWORK1-ODU2e',
 929             'direction': 'bidirectional'
 930         }
 931         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
 932                              response['odu-connection'][0])
 933         self.assertDictEqual({'dst-if': 'XPDR1-NETWORK1-ODU2e'},
 934                              response['odu-connection'][0]['destination'])
 935         self.assertDictEqual({'src-if': 'XPDR1-CLIENT1-ODU2e'},
 936                              response['odu-connection'][0]['source'])
 937
 938     def test_050_check_otn_topo_links(self):
 939         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 940         self.assertEqual(response['status_code'], requests.codes.ok)
 941         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
 942         for link in response['network'][0]['ietf-network-topology:link']:
 943             linkId = link['link-id']
 944             if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
 945                            'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')):
 946                 self.assertEqual(
 947                     link['org-openroadm-otn-network-topology:available-bandwidth'], 90000)
 948                 self.assertEqual(
 949                     link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
 950
 951     def test_051_check_otn_topo_tp(self):
 952         response = test_utils.get_ietf_network_request('otn-topology', 'config')
 953         self.assertEqual(response['status_code'], requests.codes.ok)
 954         for node in response['network'][0]['node']:
 955             if node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1':
 956                 tpList = node['ietf-network-topology:termination-point']
 957                 for tp in tpList:
 958                     if tp['tp-id'] == 'XPDR1-NETWORK1':
 959                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
 960                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 72)
 961                         tsPoolList = list(range(1, 9))
 962                         self.assertNotIn(
 963                             tsPoolList, xpdrTpPortConAt['ts-pool'])
 964                         self.assertEqual(
 965                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 79)
 966                         self.assertNotIn(
 967                             1, xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool'])
 968
 969     def test_052_delete_10GE_service(self):
 970         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE"
 971         response = test_utils.transportpce_api_rpc_request(
 972             'org-openroadm-service', 'service-delete',
 973             self.del_serv_input_data)
 974         self.assertEqual(response['status_code'], requests.codes.ok)
 975         self.assertIn('Renderer service delete in progress',
 976                       response['output']['configuration-response-common']['response-message'])
 977         time.sleep(self.WAITING)
 978
 979     def test_053_check_service_list(self):
 980         response = test_utils.get_ordm_serv_list_request()
 981         self.assertEqual(response['status_code'], requests.codes.ok)
 982         self.assertEqual(len(response['service-list']['services']), 3)
 983         time.sleep(1)
 984
 985     def test_054_check_no_ODU2e_connection_spdra(self):
 986         response = test_utils.check_node_request("SPDR-SA1")
 987         self.assertEqual(response['status_code'], requests.codes.ok)
 988         self.assertNotIn(['odu-connection'][0], response['org-openroadm-device'])
 989         time.sleep(1)
 990
 991     def test_055_check_no_interface_ODU2E_NETWORK_spdra(self):
 992         response = test_utils.check_node_attribute_request(
 993             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU2e')
 994         self.assertEqual(response['status_code'], requests.codes.conflict)
 995
 996     def test_056_check_no_interface_ODU2E_CLIENT_spdra(self):
 997         response = test_utils.check_node_attribute_request(
 998             'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ODU2e')
 999         self.assertEqual(response['status_code'], requests.codes.conflict)
1000
1001     def test_057_check_no_interface_10GE_CLIENT_spdra(self):
1002         response = test_utils.check_node_attribute_request(
1003             'SPDR-SA1', 'interface', 'XPDR1-CLIENT1-ETHERNET10G')
1004         self.assertEqual(response['status_code'], requests.codes.conflict)
1005
1006     def test_058_check_otn_topo_links(self):
1007         response = test_utils.get_ietf_network_request('otn-topology', 'config')
1008         self.assertEqual(response['status_code'], requests.codes.ok)
1009         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
1010         for link in response['network'][0]['ietf-network-topology:link']:
1011             linkId = link['link-id']
1012             if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
1013                            'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1')):
1014                 self.assertEqual(
1015                     link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
1016                 self.assertEqual(
1017                     link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
1018
1019     def test_059_check_otn_topo_tp(self):
1020         response = test_utils.get_ietf_network_request('otn-topology', 'config')
1021         self.assertEqual(response['status_code'], requests.codes.ok)
1022         for node in response['network'][0]['node']:
1023             if (node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1'):
1024                 tpList = node['ietf-network-topology:termination-point']
1025                 for tp in tpList:
1026                     if tp['tp-id'] == 'XPDR1-NETWORK1':
1027                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1028                         self.assertEqual(len(xpdrTpPortConAt['ts-pool']), 80)
1029                         self.assertEqual(
1030                             len(xpdrTpPortConAt['odtu-tpn-pool'][0]['tpn-pool']), 80)
1031
1032     def test_060_delete_ODU4_service(self):
1033         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-ABC"
1034         response = test_utils.transportpce_api_rpc_request(
1035             'org-openroadm-service', 'service-delete',
1036             self.del_serv_input_data)
1037         self.assertEqual(response['status_code'], requests.codes.ok)
1038         self.assertIn('Renderer service delete in progress',
1039                       response['output']['configuration-response-common']['response-message'])
1040         time.sleep(self.WAITING)
1041
1042     def test_061_check_service_list(self):
1043         response = test_utils.get_ordm_serv_list_request()
1044         self.assertEqual(response['status_code'], requests.codes.ok)
1045         self.assertEqual(len(response['service-list']['services']), 2)
1046         time.sleep(1)
1047
1048     def test_062_check_no_interface_ODU4_spdra(self):
1049         response = test_utils.check_node_attribute_request(
1050             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4')
1051         self.assertEqual(response['status_code'], requests.codes.conflict)
1052
1053     def test_063_check_no_interface_ODU4_spdrb(self):
1054         response = test_utils.check_node_attribute_request(
1055             'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4')
1056         self.assertEqual(response['status_code'], requests.codes.conflict)
1057         response = test_utils.check_node_attribute_request(
1058             'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4')
1059         self.assertEqual(response['status_code'], requests.codes.conflict)
1060
1061     def test_064_check_no_ODU4_connection_spdrb(self):
1062         response = test_utils.check_node_request("SPDR-SB1")
1063         self.assertEqual(response['status_code'], requests.codes.ok)
1064         self.assertNotIn(['odu-connection'][0], response['org-openroadm-device'])
1065         time.sleep(1)
1066
1067     def test_065_check_no_interface_ODU4_spdrc(self):
1068         response = test_utils.check_node_attribute_request(
1069             'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4')
1070         self.assertEqual(response['status_code'], requests.codes.conflict)
1071
1072     def test_066_check_otn_topo_links(self):
1073         self.test_030_check_otn_topo_otu4_links()
1074
1075     def test_067_check_otn_topo_tp(self):
1076         response = test_utils.get_ietf_network_request('otn-topology', 'config')
1077         self.assertEqual(response['status_code'], requests.codes.ok)
1078         for node in response['network'][0]['node']:
1079             if node['node-id'] == 'SPDR-SA1-XPDR1' or node['node-id'] == 'SPDR-SC1-XPDR1':
1080                 tpList = node['ietf-network-topology:termination-point']
1081                 for tp in tpList:
1082                     if tp['tp-id'] == 'XPDR1-NETWORK1':
1083                         xpdrTpPortConAt = tp['org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes']
1084                         self.assertNotIn('ts-pool', dict.keys(xpdrTpPortConAt))
1085                         self.assertNotIn(
1086                             'odtu-tpn-pool', dict.keys(xpdrTpPortConAt))
1087
1088 # test service-create for ODU4 service from spdrA to spdrB
1089     def test_068_create_ODU4_service_AB(self):
1090         self.cr_serv_input_data["service-name"] = "service-ODU4-AB"
1091         self.cr_serv_input_data["connection-type"] = "infrastructure"
1092         self.cr_serv_input_data["service-a-end"]["service-rate"] = "100"
1093         self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU"
1094         self.cr_serv_input_data["service-a-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
1095         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1"
1096         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
1097         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1"
1098         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
1099         self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SB1"
1100         self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSB"
1101         self.cr_serv_input_data["service-a-end"]["service-rate"] = "100"
1102         self.cr_serv_input_data["service-z-end"]["service-format"] = "ODU"
1103         self.cr_serv_input_data["service-z-end"]["odu-service-rate"] = "org-openroadm-otn-common-types:ODU4"
1104         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2"
1105         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1"
1106         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2"
1107         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK1"
1108
1109         response = test_utils.transportpce_api_rpc_request(
1110             'org-openroadm-service', 'service-create',
1111             self.cr_serv_input_data)
1112         self.assertEqual(response['status_code'], requests.codes.ok)
1113         self.assertIn('PCE calculation in progress',
1114                       response['output']['configuration-response-common']['response-message'])
1115         time.sleep(self.WAITING)
1116
1117     def test_069_get_ODU4_service_AB(self):
1118         response = test_utils.get_ordm_serv_list_attr_request("services", "service-ODU4-AB")
1119         self.assertEqual(response['status_code'], requests.codes.ok)
1120         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
1121         self.assertEqual(response['services'][0]['service-name'], 'service-ODU4-AB')
1122         self.assertEqual(response['services'][0]['connection-type'], 'infrastructure')
1123         self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
1124         time.sleep(1)
1125
1126     def test_070_check_interface_ODU4_spdra(self):
1127         response = test_utils.check_node_attribute_request(
1128             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4')
1129         self.assertEqual(response['status_code'], requests.codes.ok)
1130         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
1131                         'administrative-state': 'inService',
1132                         'supporting-circuit-pack-name': 'CP1-CFP0',
1133                         'type': 'org-openroadm-interfaces:otnOdu',
1134                         'supporting-port': 'CP1-CFP0-P1'}
1135         #      SAPI/DAPI are added in the Otu4 renderer
1136         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
1137                         'rate': 'org-openroadm-otn-common-types:ODU4',
1138                         'expected-dapi': 'H/OelLynehI=',
1139                         'expected-sapi': 'X+8cRNi+HbE=',
1140                         'tx-dapi': 'X+8cRNi+HbE=',
1141                         'tx-sapi': 'H/OelLynehI='}
1142
1143         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
1144                              response['interface'][0])
1145         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
1146                                   **input_dict_2),
1147                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
1148                              )
1149         self.assertDictEqual(
1150             {'payload-type': '21', 'exp-payload-type': '21'},
1151             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
1152
1153         response2 = test_utils.check_node_attribute_request(
1154             'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4')
1155         self.assertEqual(response['status_code'], requests.codes.ok)
1156         self.assertEqual(input_dict_2['tx-sapi'],
1157                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
1158         self.assertEqual(input_dict_2['tx-sapi'],
1159                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
1160         self.assertEqual(input_dict_2['tx-dapi'],
1161                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
1162         self.assertEqual(input_dict_2['tx-dapi'],
1163                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
1164
1165     def test_071_check_interface_ODU4_spdrb_N1(self):
1166         response = test_utils.check_node_attribute_request(
1167             'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU4')
1168         self.assertEqual(response['status_code'], requests.codes.ok)
1169         input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
1170                         'administrative-state': 'inService',
1171                         'supporting-circuit-pack-name': 'CP1-CFP0',
1172                         'type': 'org-openroadm-interfaces:otnOdu',
1173                         'supporting-port': 'CP1-CFP0-P1'}
1174         #      SAPI/DAPI are added in the Otu4 renderer
1175         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
1176                         'rate': 'org-openroadm-otn-common-types:ODU4',
1177                         'expected-dapi': 'X+8cRNi+HbE=',
1178                         'expected-sapi': 'H/OelLynehI=',
1179                         'tx-dapi': 'H/OelLynehI=',
1180                         'tx-sapi': 'X+8cRNi+HbE='}
1181
1182         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
1183                              response['interface'][0])
1184         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
1185                                   **input_dict_2),
1186                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
1187                              )
1188         self.assertDictEqual(
1189             {'payload-type': '21', 'exp-payload-type': '21'},
1190             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
1191         response2 = test_utils.check_node_attribute_request(
1192             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-ODU4')
1193         self.assertEqual(response['status_code'], requests.codes.ok)
1194         self.assertEqual(input_dict_2['tx-sapi'],
1195                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
1196         self.assertEqual(input_dict_2['tx-sapi'],
1197                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
1198         self.assertEqual(input_dict_2['tx-dapi'],
1199                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
1200         self.assertEqual(input_dict_2['tx-dapi'],
1201                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
1202
1203 # test service-create for ODU4 service from spdrB to spdrC
1204     def test_072_create_ODU4_service_BC(self):
1205         self.cr_serv_input_data["service-name"] = "service-ODU4-BC"
1206         self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SB1"
1207         self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSB"
1208         self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU"
1209         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2"
1210         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2"
1211         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SB1-XPDR2"
1212         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR2-NETWORK2"
1213         self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1"
1214         self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC"
1215         self.cr_serv_input_data["service-a-end"]["service-format"] = "ODU"
1216         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
1217         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
1218         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
1219         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-NETWORK1"
1220
1221         response = test_utils.transportpce_api_rpc_request(
1222             'org-openroadm-service', 'service-create',
1223             self.cr_serv_input_data)
1224         self.assertEqual(response['status_code'], requests.codes.ok)
1225         self.assertIn('PCE calculation in progress',
1226                       response['output']['configuration-response-common']['response-message'])
1227         time.sleep(self.WAITING)
1228
1229     def test_073_get_ODU4_service_AB(self):
1230         response = test_utils.get_ordm_serv_list_attr_request("services", "service-ODU4-BC")
1231         self.assertEqual(response['status_code'], requests.codes.ok)
1232         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
1233         self.assertEqual(response['services'][0]['service-name'], 'service-ODU4-BC')
1234         self.assertEqual(response['services'][0]['connection-type'], 'infrastructure')
1235         self.assertEqual(response['services'][0]['lifecycle-state'], 'planned')
1236         time.sleep(1)
1237
1238     def test_074_check_interface_ODU4_spdrb_N2(self):
1239         response = test_utils.check_node_attribute_request(
1240             'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4')
1241         self.assertEqual(response['status_code'], requests.codes.ok)
1242         input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU4',
1243                         'administrative-state': 'inService',
1244                         'supporting-circuit-pack-name': 'CP1-CFP0',
1245                         'type': 'org-openroadm-interfaces:otnOdu',
1246                         'supporting-port': 'CP1-CFP0-P1'}
1247         #      SAPI/DAPI are added in the Otu4 renderer
1248         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
1249                         'rate': 'org-openroadm-otn-common-types:ODU4',
1250                         'expected-dapi': 'X+8cRNi+HbI=',
1251                         'expected-sapi': 'AMf1n5hK6Xkk',
1252                         'tx-dapi': 'AMf1n5hK6Xkk',
1253                         'tx-sapi': 'X+8cRNi+HbI='}
1254
1255         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
1256                              response['interface'][0])
1257         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
1258                                   **input_dict_2),
1259                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
1260                              )
1261         self.assertDictEqual(
1262             {'payload-type': '21', 'exp-payload-type': '21'},
1263             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
1264         response2 = test_utils.check_node_attribute_request(
1265             'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4')
1266         self.assertEqual(response['status_code'], requests.codes.ok)
1267         self.assertEqual(input_dict_2['tx-sapi'],
1268                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
1269         self.assertEqual(input_dict_2['tx-sapi'],
1270                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
1271         self.assertEqual(input_dict_2['tx-dapi'],
1272                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
1273         self.assertEqual(input_dict_2['tx-dapi'],
1274                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
1275
1276     def test_075_check_interface_ODU4_spdrc(self):
1277         response = test_utils.check_node_attribute_request(
1278             'SPDR-SC1', 'interface', 'XPDR1-NETWORK1-ODU4')
1279         self.assertEqual(response['status_code'], requests.codes.ok)
1280         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4',
1281                         'administrative-state': 'inService',
1282                         'supporting-circuit-pack-name': 'CP1-CFP0',
1283                         'type': 'org-openroadm-interfaces:otnOdu',
1284                         'supporting-port': 'CP1-CFP0-P1'}
1285         # SAPI/DAPI are added in the Otu4 renderer
1286         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
1287                         'rate': 'org-openroadm-otn-common-types:ODU4',
1288                         'expected-dapi': 'AMf1n5hK6Xkk',
1289                         'expected-sapi': 'X+8cRNi+HbI=',
1290                         'tx-dapi': 'X+8cRNi+HbI=',
1291                         'tx-sapi': 'AMf1n5hK6Xkk'}
1292         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
1293                              response['interface'][0])
1294         self.assertDictEqual(dict(response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
1295                                   **input_dict_2),
1296                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
1297                              )
1298         self.assertDictEqual(
1299             {'payload-type': '21', 'exp-payload-type': '21'},
1300             response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
1301         response2 = test_utils.check_node_attribute_request(
1302             'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU4')
1303         self.assertEqual(response['status_code'], requests.codes.ok)
1304         self.assertEqual(input_dict_2['tx-sapi'],
1305                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-dapi'])
1306         self.assertEqual(input_dict_2['tx-sapi'],
1307                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-sapi'])
1308         self.assertEqual(input_dict_2['tx-dapi'],
1309                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['tx-sapi'])
1310         self.assertEqual(input_dict_2['tx-dapi'],
1311                          response2['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['expected-dapi'])
1312
1313
1314 # test service-create for 10GE service from spdr to spdr
1315
1316
1317     def test_076_create_10GE_service_ABC(self):
1318         self.cr_serv_input_data["service-name"] = "service1-10GE"
1319         self.cr_serv_input_data["connection-type"] = "service"
1320         self.cr_serv_input_data["service-a-end"]["node-id"] = "SPDR-SA1"
1321         self.cr_serv_input_data["service-a-end"]["clli"] = "NodeSA"
1322         self.cr_serv_input_data["service-a-end"]["service-rate"] = "10"
1323         self.cr_serv_input_data["service-a-end"]["service-format"] = "Ethernet"
1324         del self.cr_serv_input_data["service-a-end"]["odu-service-rate"]
1325         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1"
1326         self.cr_serv_input_data["service-a-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
1327         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SA1-XPDR1"
1328         self.cr_serv_input_data["service-a-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
1329         self.cr_serv_input_data["service-z-end"]["node-id"] = "SPDR-SC1"
1330         self.cr_serv_input_data["service-z-end"]["clli"] = "NodeSC"
1331         self.cr_serv_input_data["service-z-end"]["service-rate"] = "10"
1332         self.cr_serv_input_data["service-z-end"]["service-format"] = "Ethernet"
1333         del self.cr_serv_input_data["service-z-end"]["odu-service-rate"]
1334         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
1335         self.cr_serv_input_data["service-z-end"]["tx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
1336         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-device-name"] = "SPDR-SC1-XPDR1"
1337         self.cr_serv_input_data["service-z-end"]["rx-direction"][0]["port"]["port-name"] = "XPDR1-CLIENT1"
1338         response = test_utils.transportpce_api_rpc_request(
1339             'org-openroadm-service', 'service-create',
1340             self.cr_serv_input_data)
1341         self.assertEqual(response['status_code'], requests.codes.ok)
1342         self.assertIn('PCE calculation in progress',
1343                       response['output']['configuration-response-common']['response-message'])
1344         time.sleep(self.WAITING)
1345
1346     def test_077_check_configuration_spdra_spdrc(self):
1347         self.test_041_get_10GE_service1()
1348         self.test_042_check_interface_10GE_CLIENT_spdra()
1349         self.test_043_check_interface_ODU2E_CLIENT_spdra()
1350         self.test_044_check_interface_ODU2E_NETWORK_spdra()
1351         self.test_045_check_ODU2E_connection_spdra()
1352         self.test_046_check_interface_10GE_CLIENT_spdrc()
1353         self.test_047_check_interface_ODU2E_CLIENT_spdrc()
1354         self.test_049_check_ODU2E_connection_spdrc()
1355
1356     def test_078_check_interface_ODU2E_NETWORK1_spdrb(self):
1357         response = test_utils.check_node_attribute_request(
1358             'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU2e')
1359         self.assertEqual(response['status_code'], requests.codes.ok)
1360         input_dict_1 = {'name': 'XPDR2-NETWORK1-ODU2e',
1361                         'administrative-state': 'inService',
1362                         'supporting-circuit-pack-name': 'CP1-CFP0',
1363                         'supporting-interface': 'XPDR2-NETWORK1-ODU4',
1364                         'type': 'org-openroadm-interfaces:otnOdu',
1365                         'supporting-port': 'CP1-CFP0-P1'}
1366         input_dict_2 = {
1367             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
1368             'rate': 'org-openroadm-otn-common-types:ODU2e',
1369             'monitoring-mode': 'monitored'}
1370         input_dict_3 = {'trib-port-number': 1}
1371
1372         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
1373                              response['interface'][0])
1374         self.assertDictEqual(dict(input_dict_2,
1375                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
1376                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
1377         self.assertDictEqual(dict(input_dict_3,
1378                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
1379                                       'parent-odu-allocation']),
1380                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
1381         self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
1382                       ['trib-slots'])
1383
1384     def test_079_check_interface_ODU2E_NETWORK2_spdrb(self):
1385         response = test_utils.check_node_attribute_request(
1386             'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU2e')
1387         self.assertEqual(response['status_code'], requests.codes.ok)
1388         input_dict_1 = {'name': 'XPDR2-NETWORK2-ODU2e',
1389                         'administrative-state': 'inService',
1390                         'supporting-circuit-pack-name': 'CP1-CFP0',
1391                         'supporting-interface': 'XPDR2-NETWORK2-ODU4',
1392                         'type': 'org-openroadm-interfaces:otnOdu',
1393                         'supporting-port': 'CP1-CFP0-P1'}
1394         input_dict_2 = {
1395             'odu-function': 'org-openroadm-otn-common-types:ODU-CTP',
1396             'rate': 'org-openroadm-otn-common-types:ODU2e',
1397             'monitoring-mode': 'monitored'}
1398         input_dict_3 = {'trib-port-number': 1}
1399
1400         self.assertDictEqual(dict(input_dict_1, **response['interface'][0]),
1401                              response['interface'][0])
1402         self.assertDictEqual(dict(input_dict_2,
1403                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
1404                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
1405         self.assertDictEqual(dict(input_dict_3,
1406                                   **response['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
1407                                       'parent-odu-allocation']),
1408                              response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation'])
1409         self.assertIn(1, response['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['parent-odu-allocation']
1410                       ['trib-slots'])
1411
1412     def test_080_check_ODU2E_connection_spdrb(self):
1413         response = test_utils.check_node_attribute_request(
1414             'SPDR-SB1', 'odu-connection', 'XPDR2-NETWORK1-ODU2e-x-XPDR2-NETWORK2-ODU2e')
1415         self.assertEqual(response['status_code'], requests.codes.ok)
1416         input_dict_1 = {
1417             'connection-name':
1418             'XPDR2-NETWORK1-ODU2e-x-XPDR2-NETWORK2-ODU2e',
1419             'direction': 'bidirectional'
1420         }
1421
1422         self.assertDictEqual(dict(input_dict_1, **response['odu-connection'][0]),
1423                              response['odu-connection'][0])
1424         self.assertDictEqual({'dst-if': 'XPDR2-NETWORK2-ODU2e'},
1425                              response['odu-connection'][0]['destination'])
1426         self.assertDictEqual({'src-if': 'XPDR2-NETWORK1-ODU2e'},
1427                              response['odu-connection'][0]['source'])
1428
1429     def test_081_check_otn_topo_links(self):
1430         response = test_utils.get_ietf_network_request('otn-topology', 'config')
1431         self.assertEqual(response['status_code'], requests.codes.ok)
1432         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 8)
1433         for link in response['network'][0]['ietf-network-topology:link']:
1434             linkId = link['link-id']
1435             if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1',
1436                            'ODTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1',
1437                            'ODTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK2toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
1438                            'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK2',)):
1439                 self.assertEqual(
1440                     link['org-openroadm-otn-network-topology:available-bandwidth'], 90000)
1441                 self.assertEqual(
1442                     link['org-openroadm-otn-network-topology:used-bandwidth'], 10000)
1443
1444     def test_082_check_otn_topo_tp(self):
1445         self.test_051_check_otn_topo_tp()
1446
1447     def test_083_delete_10GE_service(self):
1448         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service1-10GE"
1449         response = test_utils.transportpce_api_rpc_request(
1450             'org-openroadm-service', 'service-delete',
1451             self.del_serv_input_data)
1452         self.assertEqual(response['status_code'], requests.codes.ok)
1453         self.assertIn('Renderer service delete in progress',
1454                       response['output']['configuration-response-common']['response-message'])
1455         time.sleep(self.WAITING)
1456
1457     def test_084_check_service_list(self):
1458         response = test_utils.get_ordm_serv_list_request()
1459         self.assertEqual(response['status_code'], requests.codes.ok)
1460         self.assertEqual(len(response['service-list']['services']), 4)
1461         time.sleep(1)
1462
1463     def test_085_check_configuration_spdra(self):
1464         self.test_054_check_no_ODU2e_connection_spdra()
1465         self.test_055_check_no_interface_ODU2E_NETWORK_spdra()
1466         self.test_056_check_no_interface_ODU2E_CLIENT_spdra()
1467         self.test_057_check_no_interface_10GE_CLIENT_spdra()
1468
1469     def test_086_check_no_ODU2e_connection_spdrb(self):
1470         response = test_utils.check_node_request("SPDR-SB1")
1471         self.assertEqual(response['status_code'], requests.codes.ok)
1472         self.assertNotIn(['odu-connection'][0], response['org-openroadm-device'])
1473         time.sleep(1)
1474
1475     def test_087_check_no_interface_ODU2E_NETWORK1_spdrb(self):
1476         response = test_utils.check_node_attribute_request(
1477             'SPDR-SB1', 'interface', 'XPDR2-NETWORK1-ODU2e')
1478         self.assertEqual(response['status_code'], requests.codes.conflict)
1479
1480     def test_088_check_no_interface_ODU2E_NETWORK2_spdrb(self):
1481         response = test_utils.check_node_attribute_request(
1482             'SPDR-SB1', 'interface', 'XPDR2-NETWORK2-ODU2e')
1483         self.assertEqual(response['status_code'], requests.codes.conflict)
1484
1485     def test_089_check_otn_topo_links(self):
1486         response = test_utils.get_ietf_network_request('otn-topology', 'config')
1487         self.assertEqual(response['status_code'], requests.codes.ok)
1488         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 8)
1489         for link in response['network'][0]['ietf-network-topology:link']:
1490             linkId = link['link-id']
1491             if (linkId in ('ODTU4-SPDR-SA1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK1',
1492                            'ODTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK1toSPDR-SA1-XPDR1-XPDR1-NETWORK1',
1493                            'ODTU4-SPDR-SB1-XPDR2-XPDR2-NETWORK2toSPDR-SC1-XPDR1-XPDR1-NETWORK1',
1494                            'ODTU4-SPDR-SC1-XPDR1-XPDR1-NETWORK1toSPDR-SB1-XPDR2-XPDR2-NETWORK2',)):
1495                 self.assertEqual(
1496                     link['org-openroadm-otn-network-topology:available-bandwidth'], 100000)
1497                 self.assertEqual(
1498                     link['org-openroadm-otn-network-topology:used-bandwidth'], 0)
1499
1500     def test_090_check_otn_topo_tp(self):
1501         self.test_059_check_otn_topo_tp()
1502
1503     def test_091_delete_ODU4_service_AB(self):
1504         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-AB"
1505         response = test_utils.transportpce_api_rpc_request(
1506             'org-openroadm-service', 'service-delete',
1507             self.del_serv_input_data)
1508         self.assertEqual(response['status_code'], requests.codes.ok)
1509         self.assertIn('Renderer service delete in progress',
1510                       response['output']['configuration-response-common']['response-message'])
1511         time.sleep(self.WAITING)
1512
1513     def test_092_delete_ODU4_service_BC(self):
1514         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-ODU4-BC"
1515         response = test_utils.transportpce_api_rpc_request(
1516             'org-openroadm-service', 'service-delete',
1517             self.del_serv_input_data)
1518         self.assertEqual(response['status_code'], requests.codes.ok)
1519         self.assertIn('Renderer service delete in progress',
1520                       response['output']['configuration-response-common']['response-message'])
1521         time.sleep(self.WAITING)
1522
1523     def test_093_check_global_config(self):
1524         self.test_061_check_service_list()
1525         self.test_062_check_no_interface_ODU4_spdra()
1526         self.test_063_check_no_interface_ODU4_spdrb()
1527         self.test_064_check_no_ODU4_connection_spdrb()
1528         self.test_065_check_no_interface_ODU4_spdrc()
1529         self.test_066_check_otn_topo_links()
1530         self.test_067_check_otn_topo_tp()
1531
1532     def test_094_delete_OCH_OTU4_service_AB(self):
1533         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-AB"
1534         response = test_utils.transportpce_api_rpc_request(
1535             'org-openroadm-service', 'service-delete',
1536             self.del_serv_input_data)
1537         self.assertEqual(response['status_code'], requests.codes.ok)
1538         self.assertIn('Renderer service delete in progress',
1539                       response['output']['configuration-response-common']['response-message'])
1540         time.sleep(self.WAITING)
1541
1542     def test_095_delete_OCH_OTU4_service_BC(self):
1543         self.del_serv_input_data["service-delete-req-info"]["service-name"] = "service-OCH-OTU4-BC"
1544         response = test_utils.transportpce_api_rpc_request(
1545             'org-openroadm-service', 'service-delete',
1546             self.del_serv_input_data)
1547         self.assertEqual(response['status_code'], requests.codes.ok)
1548         self.assertIn('Renderer service delete in progress',
1549                       response['output']['configuration-response-common']['response-message'])
1550         time.sleep(self.WAITING)
1551
1552     def test_096_get_no_service(self):
1553         response = test_utils.get_ordm_serv_list_request()
1554         self.assertEqual(response['status_code'], requests.codes.conflict)
1555         self.assertIn(response['service-list'], (
1556             {
1557                 "error-type": "protocol",
1558                 "error-tag": "data-missing",
1559                 "error-message":
1560                     "Request could not be completed because the relevant data "
1561                     "model content does not exist"
1562             }, {
1563                 "error-type": "application",
1564                 "error-tag": "data-missing",
1565                 "error-message":
1566                     "Request could not be completed because the relevant data "
1567                     "model content does not exist"
1568             }))
1569         time.sleep(1)
1570
1571     def test_097_check_no_interface_OTU4_spdra(self):
1572         response = test_utils.check_node_attribute_request(
1573             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-OTU')
1574         self.assertEqual(response['status_code'], requests.codes.conflict)
1575
1576     def test_098_check_no_interface_OCH_spdra(self):
1577         response = test_utils.check_node_attribute_request(
1578             'SPDR-SA1', 'interface', 'XPDR1-NETWORK1-1')
1579         self.assertEqual(response['status_code'], requests.codes.conflict)
1580
1581     def test_099_getLinks_OtnTopology(self):
1582         response = test_utils.get_ietf_network_request('otn-topology', 'config')
1583         self.assertEqual(response['status_code'], requests.codes.ok)
1584         self.assertNotIn('ietf-network-topology:link', response['network'][0])
1585
1586     def test_100_disconnect_xponders_from_roadm(self):
1587         response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
1588         self.assertEqual(response['status_code'], requests.codes.ok)
1589         links = response['network'][0]['ietf-network-topology:link']
1590         for link in links:
1591             if link["org-openroadm-common-network:link-type"] in ('XPONDER-OUTPUT', 'XPONDER-INPUT'):
1592                 response = test_utils.del_ietf_network_link_request(
1593                     'openroadm-topology', link['link-id'], 'config')
1594                 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1595
1596     def test_101_check_openroadm_topology(self):
1597         response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
1598         self.assertEqual(response['status_code'], requests.codes.ok)
1599         links = response['network'][0]['ietf-network-topology:link']
1600         self.assertEqual(28, len(links), 'Topology should contain 28 links')
1601
1602     def test_102_disconnect_spdrA(self):
1603         response = test_utils.unmount_device("SPDR-SA1")
1604         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1605
1606     def test_103_disconnect_spdrC(self):
1607         response = test_utils.unmount_device("SPDR-SC1")
1608         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1609
1610     def test_104_disconnect_spdrB(self):
1611         response = test_utils.unmount_device("SPDR-SB1")
1612         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1613
1614     def test_105_disconnect_roadmA(self):
1615         response = test_utils.unmount_device("ROADM-A1")
1616         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1617
1618     def test_106_disconnect_roadmB(self):
1619         response = test_utils.unmount_device("ROADM-B1")
1620         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1621
1622     def test_107_disconnect_roadmC(self):
1623         response = test_utils.unmount_device("ROADM-C1")
1624         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
1625
1626
1627 if __name__ == "__main__":
1628     unittest.main(verbosity=2)