tests/transportpce_tests/1.2.1/test03_topology.py

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