tests/transportpce_tests/2.2.1/test03_topology.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2017 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 logging
  19 import requests
  20 # pylint: disable=wrong-import-order
  21 import sys
  22 sys.path.append('transportpce_tests/common/')
  23 # pylint: disable=wrong-import-position
  24 # pylint: disable=import-error
  25 import test_utils_rfc8040  # nopep8
  26
  27
  28 class TransportPCEtesting(unittest.TestCase):
  29
  30     processes = None
  31     CHECK_DICT1 = {
  32         'ROADM-A1-SRG1': {
  33             'node_type': 'SRG',
  34             'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  35                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
  36                             'org-openroadm-common-network:operational-state': 'inService'}),
  37                           ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  38                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
  39                             'org-openroadm-common-network:operational-state': 'inService'})]
  40         },
  41         'ROADM-A1-SRG3': {
  42             'node_type': 'SRG',
  43             'checks_tp': [({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  44                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
  45                             'org-openroadm-common-network:operational-state': 'inService'}),
  46                           ({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  47                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
  48                             'org-openroadm-common-network:operational-state': 'inService'})]
  49         },
  50         'ROADM-A1-DEG1': {
  51             'node_type': 'DEGREE',
  52             'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  53                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  54                             'org-openroadm-common-network:operational-state': 'inService'}),
  55                           ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  56                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  57                             'org-openroadm-common-network:operational-state': 'inService'})]
  58         },
  59         'ROADM-A1-DEG2': {
  60             'node_type': 'DEGREE',
  61             'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  62                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  63                             'org-openroadm-common-network:operational-state': 'inService'}),
  64                           ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  65                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  66                             'org-openroadm-common-network:operational-state': 'inService'})]
  67         }
  68     }
  69     CHECK_DICT2 = {
  70         'ROADM-C1-SRG1': {
  71             'node_type': 'SRG',
  72             'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  73                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
  74                             'org-openroadm-common-network:operational-state': 'inService'}),
  75                           ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  76                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
  77                             'org-openroadm-common-network:operational-state': 'inService'})]
  78         },
  79         'ROADM-C1-DEG1': {
  80             'node_type': 'DEGREE',
  81             'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  82                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  83                             'org-openroadm-common-network:operational-state': 'inService'}),
  84                           ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  85                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  86                             'org-openroadm-common-network:operational-state': 'inService'})]
  87         },
  88         'ROADM-C1-DEG2': {
  89             'node_type': 'DEGREE',
  90             'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  91                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  92                             'org-openroadm-common-network:operational-state': 'inService'}),
  93                           ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  94                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  95                             'org-openroadm-common-network:operational-state': 'inService'})]
  96         }
  97     }
  98     NODE_VERSION = '2.2.1'
  99
 100     @classmethod
 101     def setUpClass(cls):
 102         cls.processes = test_utils_rfc8040.start_tpce()
 103         cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION), ('roadma', cls.NODE_VERSION),
 104                                                        ('roadmb', cls.NODE_VERSION), ('roadmc', cls.NODE_VERSION)])
 105
 106     @classmethod
 107     def tearDownClass(cls):
 108         # pylint: disable=not-an-iterable
 109         for process in cls.processes:
 110             test_utils_rfc8040.shutdown_process(process)
 111         print("all processes killed")
 112
 113     def setUp(self):
 114         time.sleep(5)
 115
 116     def test_01_connect_ROADM_A1(self):
 117         response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION))
 118         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
 119
 120     def test_02_getClliNetwork(self):
 121         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 122         self.assertEqual(response['status_code'], requests.codes.ok)
 123         logging.info(response)
 124         self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
 125         self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 126
 127     def test_03_getOpenRoadmNetwork(self):
 128         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
 129         self.assertEqual(response['status_code'], requests.codes.ok)
 130         self.assertEqual(response['network'][0]['node'][0]['node-id'], 'ROADM-A1')
 131         self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
 132         self.assertEqual(response['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
 133         self.assertEqual(response['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
 134         self.assertEqual(response['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
 135
 136     def test_04_getLinks_OpenroadmTopology(self):
 137         # pylint: disable=redundant-unittest-assert
 138         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 139         self.assertEqual(response['status_code'], requests.codes.ok)
 140         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 10)
 141         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 142                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
 143                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 144                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 145                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 146                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
 147                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 148                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 149                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 150                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
 151                       }
 152         for link in response['network'][0]['ietf-network-topology:link']:
 153             linkId = link['link-id']
 154             linkType = link['org-openroadm-common-network:link-type']
 155             self.assertIn(linkType, check_list)
 156             find = linkId in check_list[linkType]
 157             self.assertEqual(find, True)
 158             (check_list[linkType]).remove(linkId)
 159         for link in check_list.values():
 160             self.assertEqual(len(link), 0)
 161
 162     def test_05_getNodes_OpenRoadmTopology(self):
 163         # pylint: disable=redundant-unittest-assert
 164         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 165         self.assertEqual(response['status_code'], requests.codes.ok)
 166         self.assertEqual(len(response['network'][0]['node']), 4)
 167         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 168         for node in response['network'][0]['node']:
 169             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 170             nodeType = node['org-openroadm-common-network:node-type']
 171             nodeId = node['node-id']
 172             self.assertIn(nodeId, self.CHECK_DICT1)
 173             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 174             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 175                 self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
 176             for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
 177                 self.assertIn(tp, node['ietf-network-topology:termination-point'])
 178             self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
 179             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 180             listNode.remove(nodeId)
 181         self.assertEqual(len(listNode), 0)
 182
 183     def test_06_connect_XPDRA(self):
 184         response = test_utils_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION))
 185         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
 186
 187     def test_07_getClliNetwork(self):
 188         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 189         self.assertEqual(response['status_code'], requests.codes.ok)
 190         self.assertEqual(response['network'][0]['node'][0]['node-id'], 'NodeA')
 191         self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 192
 193     def test_08_getOpenRoadmNetwork(self):
 194         # pylint: disable=redundant-unittest-assert
 195         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
 196         self.assertEqual(response['status_code'], requests.codes.ok)
 197         nbNode = len(response['network'][0]['node'])
 198         self.assertEqual(nbNode, 2)
 199         for node in response['network'][0]['node']:
 200             self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
 201             self.assertEqual(node['supporting-node'][0]['node-ref'], 'NodeA')
 202             nodeId = node['node-id']
 203             if nodeId == 'XPDR-A1':
 204                 self.assertEqual(node['org-openroadm-common-network:node-type'], 'XPONDER')
 205             elif nodeId == 'ROADM-A1':
 206                 self.assertEqual(node['org-openroadm-common-network:node-type'], 'ROADM')
 207             else:
 208                 self.assertFalse(True)
 209                 continue
 210             self.assertEqual(node['org-openroadm-network:model'], 'model2')
 211
 212     def test_09_getNodes_OpenRoadmTopology(self):
 213         # pylint: disable=redundant-unittest-assert
 214         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 215         self.assertEqual(response['status_code'], requests.codes.ok)
 216         self.assertEqual(len(response['network'][0]['node']), 5)
 217         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 218         for node in response['network'][0]['node']:
 219             nodeType = node['org-openroadm-common-network:node-type']
 220             nodeId = node['node-id']
 221             # Tests related to XPDRA nodes
 222             if nodeId == 'XPDR-A1-XPDR1':
 223                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
 224                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
 225                 self.assertEqual(nodeType, 'XPONDER')
 226                 client = 0
 227                 network = 0
 228                 for tp in node['ietf-network-topology:termination-point']:
 229                     tpType = (tp['org-openroadm-common-network:tp-type'])
 230                     tpId = tp['tp-id']
 231                     if tpType == 'XPONDER-CLIENT':
 232                         client += 1
 233                     elif tpType == 'XPONDER-NETWORK':
 234                         network += 1
 235                     if tpId == 'XPDR1-NETWORK2':
 236                         self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
 237                     if tpId == 'XPDR1-CLIENT2':
 238                         self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
 239                 self.assertEqual(client, 2)
 240                 self.assertEqual(network, 2)
 241                 listNode.remove(nodeId)
 242             elif nodeId in self.CHECK_DICT1:
 243                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 244                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 245                     self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
 246                 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
 247                     self.assertIn(tp, node['ietf-network-topology:termination-point'])
 248                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
 249                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 250                 listNode.remove(nodeId)
 251             else:
 252                 self.assertFalse(True)
 253         self.assertEqual(len(listNode), 0)
 254
 255     # Connect the tail XPDRA to ROADMA and vice versa
 256     def test_10_connect_tail_xpdr_rdm(self):
 257         # Connect the tail: XPDRA to ROADMA
 258         response = test_utils_rfc8040.transportpce_api_rpc_request(
 259             'transportpce-networkutils', 'init-xpdr-rdm-links',
 260             {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1',
 261                              'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 262         self.assertEqual(response['status_code'], requests.codes.ok)
 263
 264     def test_11_connect_tail_rdm_xpdr(self):
 265         response = test_utils_rfc8040.transportpce_api_rpc_request(
 266             'transportpce-networkutils', 'init-rdm-xpdr-links',
 267             {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1',
 268                              'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
 269         self.assertEqual(response['status_code'], requests.codes.ok)
 270
 271     def test_12_getLinks_OpenRoadmTopology(self):
 272         # pylint: disable=redundant-unittest-assert
 273         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 274         self.assertEqual(response['status_code'], requests.codes.ok)
 275         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 12)
 276         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 277                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
 278                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 279                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 280                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 281                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
 282                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 283                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 284                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 285                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX'],
 286                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
 287                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 288                       }
 289         for link in response['network'][0]['ietf-network-topology:link']:
 290             linkId = link['link-id']
 291             linkType = link['org-openroadm-common-network:link-type']
 292             self.assertIn(linkType, check_list)
 293             find = linkId in check_list[linkType]
 294             self.assertEqual(find, True)
 295             (check_list[linkType]).remove(linkId)
 296         for link in check_list.values():
 297             self.assertEqual(len(link), 0)
 298
 299     def test_13_connect_ROADMC(self):
 300         response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
 301         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
 302
 303     def test_14_omsAttributes_ROADMA_ROADMC(self):
 304         # Config ROADMA-ROADMC oms-attributes
 305         data = {"span": {
 306             "auto-spanloss": "true",
 307             "engineered-spanloss": 12.2,
 308             "link-concatenation": [{
 309                 "SRLG-Id": 0,
 310                 "fiber-type": "smf",
 311                 "SRLG-length": 100000,
 312                 "pmd": 0.5}]}}
 313         response = test_utils_rfc8040.add_oms_attr_request(
 314             "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
 315         self.assertEqual(response.status_code, requests.codes.created)
 316
 317     def test_15_omsAttributes_ROADMC_ROADMA(self):
 318         # Config ROADM-C1-ROADM-A1 oms-attributes
 319         data = {"span": {
 320             "auto-spanloss": "true",
 321             "engineered-spanloss": 12.2,
 322             "link-concatenation": [{
 323                 "SRLG-Id": 0,
 324                 "fiber-type": "smf",
 325                 "SRLG-length": 100000,
 326                 "pmd": 0.5}]}}
 327
 328         response = test_utils_rfc8040.add_oms_attr_request(
 329             "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
 330         self.assertEqual(response.status_code, requests.codes.created)
 331
 332     def test_16_getClliNetwork(self):
 333         # pylint: disable=redundant-unittest-assert
 334         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 335         self.assertEqual(response['status_code'], requests.codes.ok)
 336         listNode = ['NodeA', 'NodeC']
 337         for node in response['network'][0]['node']:
 338             nodeId = node['node-id']
 339             self.assertIn(nodeId, listNode)
 340             self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
 341             listNode.remove(nodeId)
 342         self.assertEqual(len(listNode), 0)
 343
 344     def test_17_getOpenRoadmNetwork(self):
 345         # pylint: disable=redundant-unittest-assert
 346         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
 347         self.assertEqual(response['status_code'], requests.codes.ok)
 348         nbNode = len(response['network'][0]['node'])
 349         self.assertEqual(nbNode, 3)
 350         listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
 351         CHECK_LIST = {'XPDR-A1': {'node-ref': 'NodeA', 'node-type': 'XPONDER'},
 352                       'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
 353                       'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
 354                       }
 355         for node in response['network'][0]['node']:
 356             self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
 357             nodeId = node['node-id']
 358             if nodeId in CHECK_LIST:
 359                 self.assertEqual(node['supporting-node'][0]['node-ref'], CHECK_LIST[nodeId]['node-ref'])
 360                 self.assertEqual(node['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
 361                 listNode.remove(nodeId)
 362             else:
 363                 self.assertFalse(True)
 364                 continue
 365             self.assertEqual(node['org-openroadm-network:model'], 'model2')
 366         self.assertEqual(len(listNode), 0)
 367
 368     def test_18_getROADMLinkOpenRoadmTopology(self):
 369         # pylint: disable=redundant-unittest-assert
 370         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 371         self.assertEqual(response['status_code'], requests.codes.ok)
 372         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
 373         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 374                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 375                                        'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX',
 376                                        'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX'],
 377                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 378                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 379                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 380                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 381                                    'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX',
 382                                    'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX'],
 383                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 384                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 385                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 386                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 387                                     'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX',
 388                                     'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX'],
 389                       'ROADM-TO-ROADM': ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 390                                          'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'],
 391                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
 392                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 393                       }
 394         for link in response['network'][0]['ietf-network-topology:link']:
 395             linkId = link['link-id']
 396             linkType = link['org-openroadm-common-network:link-type']
 397             self.assertIn(linkType, check_list)
 398             find = linkId in check_list[linkType]
 399             self.assertEqual(find, True)
 400             (check_list[linkType]).remove(linkId)
 401         for link in check_list.values():
 402             self.assertEqual(len(link), 0)
 403
 404     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
 405         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 406         self.assertEqual(response['status_code'], requests.codes.ok)
 407         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 20)
 408         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 409                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
 410         for link in response['network'][0]['ietf-network-topology:link']:
 411             link_id = link['link-id']
 412             if link_id in R2RLink:
 413                 find = False
 414                 spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
 415                 # pylint: disable=line-too-long
 416                 length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 417                 if (spanLoss is not None) & (length is not None):
 418                     find = True
 419                 self.assertTrue(find)
 420                 R2RLink.remove(link_id)
 421         self.assertEqual(len(R2RLink), 0)
 422
 423     def test_20_getNodes_OpenRoadmTopology(self):
 424         # pylint: disable=redundant-unittest-assert
 425         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 426         self.assertEqual(response['status_code'], requests.codes.ok)
 427         self.assertEqual(len(response['network'][0]['node']), 8)
 428         listNode = ['XPDR-A1-XPDR1',
 429                     'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
 430                     'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
 431         # Tests related to XPDRA nodes
 432         for node in response['network'][0]['node']:
 433             nodeType = node['org-openroadm-common-network:node-type']
 434             nodeId = node['node-id']
 435             if nodeId == 'XPDR-A1-XPDR1':
 436                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
 437                 self.assertEqual(nodeType, 'XPONDER')
 438                 nbTps = len(node['ietf-network-topology:termination-point'])
 439                 self.assertTrue(nbTps >= 4)
 440                 client = 0
 441                 network = 0
 442                 for tp in node['ietf-network-topology:termination-point']:
 443                     tpType = (tp['org-openroadm-common-network:tp-type'])
 444                     if tpType == 'XPONDER-CLIENT':
 445                         client += 1
 446                     elif tpType == 'XPONDER-NETWORK':
 447                         network += 1
 448                 self.assertTrue(client == 2)
 449                 self.assertTrue(network == 2)
 450                 listNode.remove(nodeId)
 451         # Tests related to ROADMA nodes
 452             elif nodeId in self.CHECK_DICT1:
 453                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 454                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 455                     self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
 456                 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
 457                     self.assertIn(tp, node['ietf-network-topology:termination-point'])
 458                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
 459                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 460                 self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
 461                 listNode.remove(nodeId)
 462         # Tests related to ROADMA nodes
 463             elif nodeId in self.CHECK_DICT2:
 464                 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
 465                 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
 466                     self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
 467                 for tp in self.CHECK_DICT2[nodeId]['checks_tp']:
 468                     self.assertIn(tp, node['ietf-network-topology:termination-point'])
 469                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, node['supporting-node'])
 470                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'}, node['supporting-node'])
 471                 self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
 472                 listNode.remove(nodeId)
 473         self.assertEqual(len(listNode), 0)
 474
 475     def test_21_connect_ROADMB(self):
 476         response = test_utils_rfc8040.mount_device("ROADM-B1", ('roadmb', self.NODE_VERSION))
 477         self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
 478
 479     def test_22_omsAttributes_ROADMA_ROADMB(self):
 480         # Config ROADM-A1-ROADM-B1 oms-attributes
 481         data = {"span": {
 482                 "auto-spanloss": "true",
 483                 "engineered-spanloss": 12.2,
 484                 "spanloss-current": 12,
 485                 "spanloss-base": 11.4,
 486                 "link-concatenation": [{
 487                     "SRLG-Id": 0,
 488                     "fiber-type": "smf",
 489                     "SRLG-length": 100000,
 490                     "pmd": 0.5}]}}
 491         response = test_utils_rfc8040.add_oms_attr_request(
 492             "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
 493         self.assertEqual(response.status_code, requests.codes.created)
 494
 495     def test_23_omsAttributes_ROADMB_ROADMA(self):
 496         # Config ROADM-B1-ROADM-A1 oms-attributes
 497         data = {"span": {
 498                 "auto-spanloss": "true",
 499                 "engineered-spanloss": 12.2,
 500                 "spanloss-current": 12,
 501                 "spanloss-base": 11.4,
 502                 "link-concatenation": [{
 503                     "SRLG-Id": 0,
 504                     "fiber-type": "smf",
 505                     "SRLG-length": 100000,
 506                     "pmd": 0.5}]}}
 507         response = test_utils_rfc8040.add_oms_attr_request(
 508             "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
 509         self.assertEqual(response.status_code, requests.codes.created)
 510
 511     def test_24_omsAttributes_ROADMB_ROADMC(self):
 512         # Config ROADM-B1-ROADM-C1 oms-attributes
 513         data = {"span": {
 514                 "auto-spanloss": "true",
 515                 "engineered-spanloss": 12.2,
 516                 "spanloss-current": 12,
 517                 "spanloss-base": 11.4,
 518                 "link-concatenation": [{
 519                     "SRLG-Id": 0,
 520                     "fiber-type": "smf",
 521                     "SRLG-length": 100000,
 522                     "pmd": 0.5}]}}
 523         response = test_utils_rfc8040.add_oms_attr_request(
 524             "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
 525         self.assertEqual(response.status_code, requests.codes.created)
 526
 527     def test_25_omsAttributes_ROADMC_ROADMB(self):
 528         # Config ROADM-C1-ROADM-B1 oms-attributes
 529         data = {"span": {
 530                 "auto-spanloss": "true",
 531                 "engineered-spanloss": 12.2,
 532                 "link-concatenation": [{
 533                     "SRLG-Id": 0,
 534                     "fiber-type": "smf",
 535                     "SRLG-length": 100000,
 536                     "pmd": 0.5}]}}
 537         response = test_utils_rfc8040.add_oms_attr_request(
 538             "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
 539         self.assertEqual(response.status_code, requests.codes.created)
 540
 541     def test_26_getClliNetwork(self):
 542         # pylint: disable=redundant-unittest-assert
 543         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 544         self.assertEqual(response['status_code'], requests.codes.ok)
 545         listNode = ['NodeA', 'NodeB', 'NodeC']
 546         for node in response['network'][0]['node']:
 547             nodeId = node['node-id']
 548             self.assertIn(nodeId, listNode)
 549             self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
 550             listNode.remove(nodeId)
 551         self.assertEqual(len(listNode), 0)
 552
 553     def test_27_verifyDegree(self):
 554         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 555         self.assertEqual(response['status_code'], requests.codes.ok)
 556         listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 557                        'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 558                        'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
 559                        'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 560                        'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
 561                        'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
 562         for link in response['network'][0]['ietf-network-topology:link']:
 563             if link['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
 564                 link_id = link['link-id']
 565                 find = link_id in listR2RLink
 566                 self.assertEqual(find, True)
 567                 listR2RLink.remove(link_id)
 568         self.assertEqual(len(listR2RLink), 0)
 569
 570     def test_28_verifyOppositeLinkTopology(self):
 571         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 572         self.assertEqual(response['status_code'], requests.codes.ok)
 573         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 30)
 574         for link in response['network'][0]['ietf-network-topology:link']:
 575             link_id = link['link-id']
 576             link_type = link['org-openroadm-common-network:link-type']
 577             link_src = link['source']['source-node']
 578             link_dest = link['destination']['dest-node']
 579             oppLink_id = link['org-openroadm-common-network:opposite-link']
 580             # Find the opposite link
 581             res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
 582             self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
 583             self.assertEqual(res_oppLink['link']['org-openroadm-common-network:opposite-link'], link_id)
 584             self.assertEqual(res_oppLink['link']['source']['source-node'], link_dest)
 585             self.assertEqual(res_oppLink['link']['destination']['dest-node'], link_src)
 586             oppLink_type = res_oppLink['link']['org-openroadm-common-network:link-type']
 587             CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
 588                           'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
 589                           'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
 590             if link_type in CHECK_DICT:
 591                 self.assertEqual(oppLink_type, CHECK_DICT[link_type])
 592
 593     def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
 594         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 595         self.assertEqual(response['status_code'], requests.codes.ok)
 596         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 597                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 598                    'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
 599                    'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 600                    'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
 601                    'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
 602         for link in response['network'][0]['ietf-network-topology:link']:
 603             link_id = link['link-id']
 604             if link_id in R2RLink:
 605                 find = False
 606                 spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 607                 # pylint: disable=line-too-long
 608                 length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 609                 if (spanLoss is not None) & (length is not None):
 610                     find = True
 611                 self.assertTrue(find)
 612                 R2RLink.remove(link_id)
 613         self.assertEqual(len(R2RLink), 0)
 614
 615     def test_30_disconnect_ROADMB(self):
 616         # Delete in the topology-netconf
 617         response = test_utils_rfc8040.unmount_device("ROADM-B1")
 618         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 619         # Delete in the clli-network
 620         response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
 621         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 622
 623     def test_31_disconnect_ROADMC(self):
 624         # Delete in the topology-netconf
 625         response = test_utils_rfc8040.unmount_device("ROADM-C1")
 626         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 627         # Delete in the clli-network
 628         response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
 629         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 630
 631     def test_32_getNodes_OpenRoadmTopology(self):
 632         # pylint: disable=redundant-unittest-assert
 633         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 634         self.assertEqual(response['status_code'], requests.codes.ok)
 635         self.assertEqual(len(response['network'][0]['node']), 5)
 636         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 637         for node in response['network'][0]['node']:
 638             nodeType = node['org-openroadm-common-network:node-type']
 639             nodeId = node['node-id']
 640             # Tests related to XPDRA nodes
 641             if nodeId == 'XPDR-A1-XPDR1':
 642                 for tp in node['ietf-network-topology:termination-point']:
 643                     tpid = tp['tp-id']
 644                     if tpid == 'XPDR1-CLIENT1':
 645                         self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
 646                     elif tpid == 'XPDR1-NETWORK1':
 647                         self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
 648                         # pylint: disable=line-too-long
 649                         self.assertEqual((tp['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']),
 650                                          'ROADM-A1-SRG1--SRG1-PP1-TXRX')
 651                     elif tpid == 'XPDR2-NETWORK1':
 652                         self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
 653                         # pylint: disable=line-too-long
 654                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
 655                 listNode.remove(nodeId)
 656             # Tests related to ROADMA nodes
 657             elif nodeId in self.CHECK_DICT1:
 658                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 659                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 660                     self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
 661                 for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
 662                     self.assertIn(tp, node['ietf-network-topology:termination-point'])
 663                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
 664                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 665                 listNode.remove(nodeId)
 666             else:
 667                 self.assertFalse(True)
 668         self.assertEqual(len(listNode), 0)
 669         # Test related to SRG1 of ROADMC
 670         for node in response['network'][0]['node']:
 671             self.assertNotEqual(node['node-id'], 'ROADM-C1-SRG1')
 672             self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG1')
 673             self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG2')
 674
 675     def test_33_getOpenRoadmNetwork(self):
 676         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
 677         self.assertEqual(response['status_code'], requests.codes.ok)
 678         nbNode = len(response['network'][0]['node'])
 679         self.assertEqual(nbNode, 2)
 680         for node in response['network'][0]['node']:
 681             self.assertNotEqual(node['node-id'], 'ROADM-C1')
 682             self.assertNotEqual(node['node-id'], 'ROADM-B1')
 683
 684     def test_34_getClliNetwork(self):
 685         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 686         self.assertEqual(response['status_code'], requests.codes.ok)
 687         self.assertEqual(len(response['network'][0]['node']), 1)
 688         self.assertNotEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeC')
 689
 690     def test_35_disconnect_XPDRA(self):
 691         response = test_utils_rfc8040.unmount_device("XPDR-A1")
 692         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 693
 694     def test_36_getClliNetwork(self):
 695         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 696         self.assertEqual(response['status_code'], requests.codes.ok)
 697         self.assertEqual(len(response['network'][0]['node']), 1)
 698         self.assertEqual(response['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 699
 700     def test_37_getOpenRoadmNetwork(self):
 701         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
 702         self.assertEqual(response['status_code'], requests.codes.ok)
 703         self.assertEqual(len(response['network'][0]['node']), 1)
 704         self.assertNotEqual(response['network'][0]['node'][0]['node-id'], 'XPDR-A1')
 705
 706     def test_38_getNodes_OpenRoadmTopology(self):
 707         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 708         self.assertEqual(response['status_code'], requests.codes.ok)
 709         self.assertEqual(len(response['network'][0]['node']), 4)
 710         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 711         for node in response['network'][0]['node']:
 712             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 713             nodeType = node['org-openroadm-common-network:node-type']
 714             nodeId = node['node-id']
 715             self.assertIn(nodeId, self.CHECK_DICT1)
 716             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 717             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 718                 self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
 719             for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
 720                 self.assertIn(tp, node['ietf-network-topology:termination-point'])
 721             self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
 722             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
 723             listNode.remove(nodeId)
 724         self.assertEqual(len(listNode), 0)
 725
 726     def test_39_disconnect_ROADM_XPDRA_link(self):
 727         # Link-1
 728         response = test_utils_rfc8040.del_ietf_network_link_request(
 729             'openroadm-topology',
 730             'XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX',
 731             'config')
 732         # Link-2
 733         response2 = test_utils_rfc8040.del_ietf_network_link_request(
 734             'openroadm-topology',
 735             'ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1',
 736             'config')
 737         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 738         self.assertIn(response2.status_code, (requests.codes.ok, requests.codes.no_content))
 739
 740     def test_40_getLinks_OpenRoadmTopology(self):
 741         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 742         self.assertEqual(response['status_code'], requests.codes.ok)
 743         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 16)
 744         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 745                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
 746                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 747                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 748                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 749                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
 750                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 751                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 752                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 753                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
 754                       }
 755         roadmtoroadmLink = 0
 756         for link in response['network'][0]['ietf-network-topology:link']:
 757             linkId = link['link-id']
 758             linkType = link['org-openroadm-common-network:link-type']
 759             if linkType in check_list:
 760                 find = linkId in check_list[linkType]
 761                 self.assertEqual(find, True)
 762                 (check_list[linkType]).remove(linkId)
 763             else:
 764                 roadmtoroadmLink += 1
 765         for link in check_list.values():
 766             self.assertEqual(len(link), 0)
 767         self.assertEqual(roadmtoroadmLink, 6)
 768         for link in response['network'][0]['ietf-network-topology:link']:
 769             self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
 770             self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
 771
 772     def test_41_disconnect_ROADMA(self):
 773         response = test_utils_rfc8040.unmount_device("ROADM-A1")
 774         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 775         # Delete in the clli-network
 776         response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
 777         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 778
 779     def test_42_getClliNetwork(self):
 780         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
 781         self.assertEqual(response['status_code'], requests.codes.ok)
 782         self.assertNotIn('node', response['network'][0])
 783
 784     def test_43_getOpenRoadmNetwork(self):
 785         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
 786         self.assertEqual(response['status_code'], requests.codes.ok)
 787         self.assertNotIn('node', response['network'][0])
 788
 789     def test_44_check_roadm2roadm_link_persistence(self):
 790         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
 791         self.assertEqual(response['status_code'], requests.codes.ok)
 792         self.assertNotIn('node', response['network'][0])
 793         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 6)
 794
 795
 796 if __name__ == "__main__":
 797     unittest.main(verbosity=2)