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