tests/transportpce_tests/2.2.1/test_topology.py

   1 #!/usr/bin/env python
   2
   3 ##############################################################################
   4 # Copyright (c) 2017 Orange, Inc. and others.  All rights reserved.
   5 #
   6 # All rights reserved. This program and the accompanying materials
   7 # are made available under the terms of the Apache License, Version 2.0
   8 # which accompanies this distribution, and is available at
   9 # http://www.apache.org/licenses/LICENSE-2.0
  10 ##############################################################################
  11
  12 # pylint: disable=no-member
  13 # pylint: disable=too-many-public-methods
  14 # pylint: disable=too-many-lines
  15
  16 import unittest
  17 import time
  18 import logging
  19 import requests
  20 from common import test_utils
  21
  22
  23 class TransportPCEtesting(unittest.TestCase):
  24
  25     processes = None
  26     CHECK_DICT1 = {
  27         'ROADM-A1-SRG1': {
  28             'node_type': 'SRG',
  29             'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  30                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
  31                             'org-openroadm-common-network:operational-state': 'inService'}),
  32                           ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  33                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
  34                             'org-openroadm-common-network:operational-state': 'inService'})]
  35         },
  36         'ROADM-A1-SRG3': {
  37             'node_type': 'SRG',
  38             'checks_tp': [({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  39                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
  40                             'org-openroadm-common-network:operational-state': 'inService'}),
  41                           ({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  42                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
  43                             'org-openroadm-common-network:operational-state': 'inService'})]
  44         },
  45         'ROADM-A1-DEG1': {
  46             'node_type': 'DEGREE',
  47             'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  48                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  49                             'org-openroadm-common-network:operational-state': 'inService'}),
  50                           ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  51                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  52                             'org-openroadm-common-network:operational-state': 'inService'})]
  53         },
  54         'ROADM-A1-DEG2': {
  55             'node_type': 'DEGREE',
  56             'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  57                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  58                             'org-openroadm-common-network:operational-state': 'inService'}),
  59                           ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  60                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  61                             'org-openroadm-common-network:operational-state': 'inService'})]
  62         }
  63     }
  64     CHECK_DICT2 = {
  65         'ROADM-C1-SRG1': {
  66             'node_type': 'SRG',
  67             'checks_tp': [({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  68                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP',
  69                             'org-openroadm-common-network:operational-state': 'inService'}),
  70                           ({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  71                             'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP',
  72                             'org-openroadm-common-network:operational-state': 'inService'})]
  73         },
  74         'ROADM-C1-DEG1': {
  75             'node_type': 'DEGREE',
  76             'checks_tp': [({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  77                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  78                             'org-openroadm-common-network:operational-state': 'inService'}),
  79                           ({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  80                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  81                             'org-openroadm-common-network:operational-state': 'inService'})]
  82         },
  83         'ROADM-C1-DEG2': {
  84             'node_type': 'DEGREE',
  85             'checks_tp': [({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  86                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP',
  87                             'org-openroadm-common-network:operational-state': 'inService'}),
  88                           ({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:administrative-state': 'inService',
  89                             'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP',
  90                             'org-openroadm-common-network:operational-state': 'inService'})]
  91         }
  92     }
  93
  94     @classmethod
  95     def setUpClass(cls):
  96         cls.processes = test_utils.start_tpce()
  97         cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
  98
  99     @classmethod
 100     def tearDownClass(cls):
 101         # pylint: disable=not-an-iterable
 102         for process in cls.processes:
 103             test_utils.shutdown_process(process)
 104         print("all processes killed")
 105
 106     def setUp(self):
 107         time.sleep(5)
 108
 109     def test_01_connect_ROADM_A1(self):
 110         response = test_utils.mount_device("ROADM-A1", 'roadma')
 111         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 112
 113     def test_02_getClliNetwork(self):
 114         response = test_utils.get_clli_net_request()
 115         self.assertEqual(response.status_code, requests.codes.ok)
 116         res = response.json()
 117         logging.info(res)
 118         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
 119         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 120
 121     def test_03_getOpenRoadmNetwork(self):
 122         response = test_utils.get_ordm_net_request()
 123         self.assertEqual(response.status_code, requests.codes.ok)
 124         res = response.json()
 125         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
 126         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
 127         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
 128         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
 129         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
 130
 131     def test_04_getLinks_OpenroadmTopology(self):
 132         # pylint: disable=redundant-unittest-assert
 133         response = test_utils.get_ordm_topo_request("")
 134         self.assertEqual(response.status_code, requests.codes.ok)
 135         res = response.json()
 136         # Tests related to links
 137         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 138         self.assertEqual(nbLink, 10)
 139         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 140                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
 141                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 142                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 143                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 144                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
 145                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 146                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 147                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 148                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
 149                       }
 150         for i in range(0, nbLink):
 151             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 152             linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 153             if linkType in check_list:
 154                 find = linkId in check_list[linkType]
 155                 self.assertEqual(find, True)
 156                 (check_list[linkType]).remove(linkId)
 157             else:
 158                 self.assertFalse(True)
 159         for link_type in check_list:
 160             self.assertEqual(len(check_list[link_type]), 0)
 161
 162     def test_05_getNodes_OpenRoadmTopology(self):
 163         # pylint: disable=redundant-unittest-assert
 164         response = test_utils.get_ordm_topo_request("")
 165         res = response.json()
 166         # Tests related to nodes
 167         self.assertEqual(response.status_code, requests.codes.ok)
 168         nbNode = len(res['network'][0]['node'])
 169         self.assertEqual(nbNode, 4)
 170         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 171         for i in range(0, nbNode):
 172             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 173                           res['network'][0]['node'][i]['supporting-node'])
 174             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 175             nodeId = res['network'][0]['node'][i]['node-id']
 176             if nodeId in self.CHECK_DICT1:
 177                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 178                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 179                     self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 180                 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
 181                     self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 182                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 183                               res['network'][0]['node'][i]['supporting-node'])
 184                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 185                               res['network'][0]['node'][i]['supporting-node'])
 186                 listNode.remove(nodeId)
 187             else:
 188                 self.assertFalse(True)
 189         self.assertEqual(len(listNode), 0)
 190
 191     def test_06_connect_XPDRA(self):
 192         response = test_utils.mount_device("XPDR-A1", 'xpdra')
 193         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 194
 195     def test_07_getClliNetwork(self):
 196         response = test_utils.get_clli_net_request()
 197         self.assertEqual(response.status_code, requests.codes.ok)
 198         res = response.json()
 199         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
 200         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 201
 202     def test_08_getOpenRoadmNetwork(self):
 203         # pylint: disable=redundant-unittest-assert
 204         response = test_utils.get_ordm_net_request()
 205         self.assertEqual(response.status_code, requests.codes.ok)
 206         res = response.json()
 207         nbNode = len(res['network'][0]['node'])
 208         self.assertEqual(nbNode, 2)
 209         for i in range(0, nbNode):
 210             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
 211             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
 212             nodeId = res['network'][0]['node'][i]['node-id']
 213             if nodeId == 'XPDR-A1':
 214                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
 215             elif nodeId == 'ROADM-A1':
 216                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
 217             else:
 218                 self.assertFalse(True)
 219                 continue
 220             self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 221
 222     def test_09_getNodes_OpenRoadmTopology(self):
 223         # pylint: disable=redundant-unittest-assert
 224         response = test_utils.get_ordm_topo_request("")
 225         res = response.json()
 226         # Tests related to nodes
 227         self.assertEqual(response.status_code, requests.codes.ok)
 228         nbNode = len(res['network'][0]['node'])
 229         self.assertEqual(nbNode, 5)
 230         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 231         for i in range(0, nbNode):
 232             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 233             nodeId = res['network'][0]['node'][i]['node-id']
 234             # Tests related to XPDRA nodes
 235             if nodeId == 'XPDR-A1-XPDR1':
 236                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 237                               res['network'][0]['node'][i]['supporting-node'])
 238                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 239                               res['network'][0]['node'][i]['supporting-node'])
 240                 self.assertEqual(nodeType, 'XPONDER')
 241                 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 242                 client = 0
 243                 network = 0
 244                 for j in range(0, nbTps):
 245                     tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 246                                  ['org-openroadm-common-network:tp-type'])
 247                     tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
 248                     if tpType == 'XPONDER-CLIENT':
 249                         client += 1
 250                     elif tpType == 'XPONDER-NETWORK':
 251                         network += 1
 252                     if tpId == 'XPDR1-NETWORK2':
 253                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 254                                          ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
 255                     if tpId == 'XPDR1-CLIENT2':
 256                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 257                                          ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
 258
 259                 self.assertTrue(client == 2)
 260                 self.assertTrue(network == 2)
 261                 listNode.remove(nodeId)
 262             elif nodeId in self.CHECK_DICT1:
 263                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 264                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 265                     self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 266                 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
 267                     self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 268                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 269                               res['network'][0]['node'][i]['supporting-node'])
 270                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 271                               res['network'][0]['node'][i]['supporting-node'])
 272                 listNode.remove(nodeId)
 273             else:
 274                 self.assertFalse(True)
 275         self.assertEqual(len(listNode), 0)
 276
 277     # Connect the tail XPDRA to ROADMA and vice versa
 278     def test_10_connect_tail_xpdr_rdm(self):
 279         # Connect the tail: XPDRA to ROADMA
 280         response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "1",
 281                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
 282         self.assertEqual(response.status_code, requests.codes.ok)
 283
 284     def test_11_connect_tail_rdm_xpdr(self):
 285         response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "1",
 286                                                           "ROADM-A1", "1", "SRG1-PP1-TXRX")
 287         self.assertEqual(response.status_code, requests.codes.ok)
 288
 289     def test_12_getLinks_OpenRoadmTopology(self):
 290         # pylint: disable=redundant-unittest-assert
 291         response = test_utils.get_ordm_topo_request("")
 292         self.assertEqual(response.status_code, requests.codes.ok)
 293         res = response.json()
 294         # Tests related to links
 295         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 296         self.assertEqual(nbLink, 12)
 297         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 298                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
 299                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 300                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 301                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 302                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
 303                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 304                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 305                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 306                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX'],
 307                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
 308                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 309                       }
 310         for i in range(0, nbLink):
 311             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 312             linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 313             if linkType in check_list:
 314                 find = linkId in check_list[linkType]
 315                 self.assertEqual(find, True)
 316                 (check_list[linkType]).remove(linkId)
 317             else:
 318                 self.assertFalse(True)
 319         for link_type in check_list:
 320             self.assertEqual(len(check_list[link_type]), 0)
 321
 322     def test_13_connect_ROADMC(self):
 323         response = test_utils.mount_device("ROADM-C1", 'roadmc')
 324         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 325
 326     def test_14_omsAttributes_ROADMA_ROADMC(self):
 327         # Config ROADMA-ROADMC oms-attributes
 328         data = {"span": {
 329             "auto-spanloss": "true",
 330             "engineered-spanloss": 12.2,
 331             "link-concatenation": [{
 332                 "SRLG-Id": 0,
 333                 "fiber-type": "smf",
 334                 "SRLG-length": 100000,
 335                 "pmd": 0.5}]}}
 336         response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
 337         self.assertEqual(response.status_code, requests.codes.created)
 338
 339     def test_15_omsAttributes_ROADMC_ROADMA(self):
 340         # Config ROADM-C1-ROADM-A1 oms-attributes
 341         data = {"span": {
 342             "auto-spanloss": "true",
 343             "engineered-spanloss": 12.2,
 344             "link-concatenation": [{
 345                 "SRLG-Id": 0,
 346                 "fiber-type": "smf",
 347                 "SRLG-length": 100000,
 348                 "pmd": 0.5}]}}
 349
 350         response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
 351         self.assertEqual(response.status_code, requests.codes.created)
 352
 353     def test_16_getClliNetwork(self):
 354         # pylint: disable=redundant-unittest-assert
 355         response = test_utils.get_clli_net_request()
 356         self.assertEqual(response.status_code, requests.codes.ok)
 357         res = response.json()
 358         nbNode = len(res['network'][0]['node'])
 359         listNode = ['NodeA', 'NodeC']
 360         for i in range(0, nbNode):
 361             nodeId = res['network'][0]['node'][i]['node-id']
 362             if nodeId in listNode:
 363                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], nodeId)
 364                 listNode.remove(nodeId)
 365             else:
 366                 self.assertFalse(True)
 367         self.assertEqual(len(listNode), 0)
 368
 369     def test_17_getOpenRoadmNetwork(self):
 370         # pylint: disable=redundant-unittest-assert
 371         response = test_utils.get_ordm_net_request()
 372         self.assertEqual(response.status_code, requests.codes.ok)
 373         res = response.json()
 374         nbNode = len(res['network'][0]['node'])
 375         self.assertEqual(nbNode, 3)
 376         listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
 377         CHECK_LIST = {'XPDR-A1': {'node-ref': 'NodeA', 'node-type': 'XPONDER'},
 378                       'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
 379                       'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
 380                       }
 381         for i in range(0, nbNode):
 382             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
 383             nodeId = res['network'][0]['node'][i]['node-id']
 384             if nodeId in CHECK_LIST:
 385                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],
 386                                  CHECK_LIST[nodeId]['node-ref'])
 387                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
 388                                  CHECK_LIST[nodeId]['node-type'])
 389                 listNode.remove(nodeId)
 390             else:
 391                 self.assertFalse(True)
 392                 continue
 393             self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 394         self.assertEqual(len(listNode), 0)
 395
 396     def test_18_getROADMLinkOpenRoadmTopology(self):
 397         # pylint: disable=redundant-unittest-assert
 398         response = test_utils.get_ordm_topo_request("")
 399         self.assertEqual(response.status_code, requests.codes.ok)
 400         res = response.json()
 401         # Tests related to links
 402         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 403         self.assertEqual(nbLink, 20)
 404         check_list = {'EXPRESS-LINK': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 405                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 406                                        'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX',
 407                                        'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX'],
 408                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 409                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 410                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 411                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 412                                    'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX',
 413                                    'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX'],
 414                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 415                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 416                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 417                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 418                                     'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX',
 419                                     'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX'],
 420                       'ROADM-TO-ROADM': ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 421                                          'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX'],
 422                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
 423                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 424                       }
 425         for i in range(0, nbLink):
 426             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 427             linkType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 428             if linkType in check_list:
 429                 find = linkId in check_list[linkType]
 430                 self.assertEqual(find, True)
 431                 (check_list[linkType]).remove(linkId)
 432             else:
 433                 self.assertFalse(True)
 434         for link_type in check_list:
 435             self.assertEqual(len(check_list[link_type]), 0)
 436
 437     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
 438         response = test_utils.get_ordm_topo_request("")
 439         self.assertEqual(response.status_code, requests.codes.ok)
 440         res = response.json()
 441         # Tests related to links
 442         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 443         self.assertEqual(nbLink, 20)
 444         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 445                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
 446         for i in range(0, nbLink):
 447             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 448             if link_id in R2RLink:
 449                 find = False
 450                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 451                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 452                 length = res['network'][0]['ietf-network-topology:link'][i][
 453                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 454                 if (spanLoss is not None) & (length is not None):
 455                     find = True
 456                 self.assertTrue(find)
 457                 R2RLink.remove(link_id)
 458         self.assertEqual(len(R2RLink), 0)
 459
 460     def test_20_getNodes_OpenRoadmTopology(self):
 461         # pylint: disable=redundant-unittest-assert
 462         response = test_utils.get_ordm_topo_request("")
 463         res = response.json()
 464         # Tests related to nodes
 465         self.assertEqual(response.status_code, requests.codes.ok)
 466         nbNode = len(res['network'][0]['node'])
 467         self.assertEqual(nbNode, 8)
 468         listNode = ['XPDR-A1-XPDR1',
 469                     'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
 470                     'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
 471         # Tests related to XPDRA nodes
 472         for i in range(0, nbNode):
 473             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 474             nodeId = res['network'][0]['node'][i]['node-id']
 475             if nodeId == 'XPDR-A1-XPDR1':
 476                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 477                               res['network'][0]['node'][i]['supporting-node'])
 478                 self.assertEqual(nodeType, 'XPONDER')
 479                 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 480                 self.assertTrue(nbTps >= 4)
 481                 client = 0
 482                 network = 0
 483                 for j in range(0, nbTps):
 484                     tpType = (res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 485                                  ['org-openroadm-common-network:tp-type'])
 486                     if tpType == 'XPONDER-CLIENT':
 487                         client += 1
 488                     elif tpType == 'XPONDER-NETWORK':
 489                         network += 1
 490                 self.assertTrue(client == 2)
 491                 self.assertTrue(network == 2)
 492                 listNode.remove(nodeId)
 493         # Tests related to ROADMA nodes
 494             elif nodeId in self.CHECK_DICT1:
 495                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
 496                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
 497                     self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 498                 for item in self.CHECK_DICT1[nodeId]['checks_tp']:
 499                     self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 500                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 501                               res['network'][0]['node'][i]['supporting-node'])
 502                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 503                               res['network'][0]['node'][i]['supporting-node'])
 504                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
 505                                  self.CHECK_DICT1[nodeId]['node_type'])
 506                 listNode.remove(nodeId)
 507         # Tests related to ROADMA nodes
 508             elif nodeId in self.CHECK_DICT2:
 509                 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
 510                 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
 511                     self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 512                 for item in self.CHECK_DICT2[nodeId]['checks_tp']:
 513                     self.assertIn(item, res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 514                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'},
 515                               res['network'][0]['node'][i]['supporting-node'])
 516                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 517                               res['network'][0]['node'][i]['supporting-node'])
 518                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],
 519                                  self.CHECK_DICT2[nodeId]['node_type'])
 520                 listNode.remove(nodeId)
 521         self.assertEqual(len(listNode), 0)
 522
 523     def test_21_connect_ROADMB(self):
 524         response = test_utils.mount_device("ROADM-B1", 'roadmb')
 525         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 526
 527     def test_22_omsAttributes_ROADMA_ROADMB(self):
 528         # Config ROADM-A1-ROADM-B1 oms-attributes
 529         data = {"span": {
 530                 "auto-spanloss": "true",
 531                 "engineered-spanloss": 12.2,
 532                 "spanloss-current": 12,
 533                 "spanloss-base": 11.4,
 534                 "link-concatenation": [{
 535                     "SRLG-Id": 0,
 536                     "fiber-type": "smf",
 537                     "SRLG-length": 100000,
 538                     "pmd": 0.5}]}}
 539         response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
 540         self.assertEqual(response.status_code, requests.codes.created)
 541
 542     def test_23_omsAttributes_ROADMB_ROADMA(self):
 543         # Config ROADM-B1-ROADM-A1 oms-attributes
 544         data = {"span": {
 545                 "auto-spanloss": "true",
 546                 "engineered-spanloss": 12.2,
 547                 "spanloss-current": 12,
 548                 "spanloss-base": 11.4,
 549                 "link-concatenation": [{
 550                     "SRLG-Id": 0,
 551                     "fiber-type": "smf",
 552                     "SRLG-length": 100000,
 553                     "pmd": 0.5}]}}
 554         response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
 555         self.assertEqual(response.status_code, requests.codes.created)
 556
 557     def test_24_omsAttributes_ROADMB_ROADMC(self):
 558         # Config ROADM-B1-ROADM-C1 oms-attributes
 559         data = {"span": {
 560                 "auto-spanloss": "true",
 561                 "engineered-spanloss": 12.2,
 562                 "spanloss-current": 12,
 563                 "spanloss-base": 11.4,
 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("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
 570         self.assertEqual(response.status_code, requests.codes.created)
 571
 572     def test_25_omsAttributes_ROADMC_ROADMB(self):
 573         # Config ROADM-C1-ROADM-B1 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("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-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 = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 608                        'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 609                        'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
 610                        'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 611                        'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
 612                        'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-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, 26)
 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 = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 657                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 658                    'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
 659                    'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 660                    'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
 661                    'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-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("ROADM-B1")
 679         # Delete in the clli-network
 680         response = test_utils.del_node_request("NodeB")
 681         self.assertEqual(response.status_code, requests.codes.ok)
 682
 683     def test_31_disconnect_ROADMC(self):
 684         # Delete in the topology-netconf
 685         response = test_utils.unmount_device("ROADM-C1")
 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 = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-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 == 'XPDR-A1-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                                          'ROADM-A1-SRG1--SRG1-PP1-TXRX')
 718                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 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']), 5)
 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': 'ROADM-A1'},
 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'], 'ROADM-C1-SRG1')
 739             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
 740             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-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'], 'ROADM-C1')
 750             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
 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("XPDR-A1")
 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'], 'XPDR-A1')
 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 = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 791         for i in range(0, nbNode):
 792             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 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']), 5)
 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': 'ROADM-A1'},
 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("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
 814         self.assertEqual(response.status_code, requests.codes.ok)
 815         # Link-2
 816         response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-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': ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 826                                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX'],
 827                       'ADD-LINK': ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 828                                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 829                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 830                                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX'],
 831                       'DROP-LINK': ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 832                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 833                                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 834                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-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("ROADM-A1")
 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)