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