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