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