tests/transportpce_tests/1.2.1/test_topology.py

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