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