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