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