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
  15 import unittest
  16 import time
  17 import json
  18 import logging
  19 import requests
  20 from common import test_utils
  21
  22
  23 class TransportPCEtesting(unittest.TestCase):
  24
  25     processes = None
  26
  27     @classmethod
  28     def setUpClass(cls):
  29         cls.processes = test_utils.start_tpce()
  30         cls.processes = test_utils.start_sims(['xpdra', 'roadma', 'roadmb', 'roadmc'])
  31
  32     @classmethod
  33     def tearDownClass(cls):
  34         for process in cls.processes:
  35             test_utils.shutdown_process(process)
  36         print("all processes killed")
  37
  38     def setUp(self):
  39         time.sleep(5)
  40
  41     def test_01_connect_ROADM_A1(self):
  42         response = test_utils.mount_device("ROADM-A1", 'roadma')
  43         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
  44
  45     def test_02_getClliNetwork(self):
  46         response = test_utils.get_clli_net_request()
  47         self.assertEqual(response.status_code, requests.codes.ok)
  48         res = response.json()
  49         logging.info(res)
  50         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
  51         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
  52
  53     def test_03_getOpenRoadmNetwork(self):
  54         response = test_utils.get_ordm_net_request()
  55         self.assertEqual(response.status_code, requests.codes.ok)
  56         res = response.json()
  57         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADM-A1')
  58         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
  59         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
  60         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
  61         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], 'model2')
  62
  63     def test_04_getLinks_OpenroadmTopology(self):
  64         response = test_utils.get_ordm_topo_request("")
  65         self.assertEqual(response.status_code, requests.codes.ok)
  66         res = response.json()
  67         # Tests related to links
  68         nbLink = len(res['network'][0]['ietf-network-topology:link'])
  69         self.assertEqual(nbLink, 10)
  70         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
  71                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
  72         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
  73                    'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
  74                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
  75                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
  76         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
  77                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
  78                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
  79                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
  80         for i in range(0, nbLink):
  81             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
  82             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
  83                 find = linkId in expressLink
  84                 self.assertEqual(find, True)
  85                 expressLink.remove(linkId)
  86             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
  87                 find = linkId in addLink
  88                 self.assertEqual(find, True)
  89                 addLink.remove(linkId)
  90             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
  91                 find = linkId in dropLink
  92                 self.assertEqual(find, True)
  93                 dropLink.remove(linkId)
  94             else:
  95                 self.assertFalse(True)
  96         self.assertEqual(len(expressLink), 0)
  97         self.assertEqual(len(addLink), 0)
  98         self.assertEqual(len(dropLink), 0)
  99
 100     def test_05_getNodes_OpenRoadmTopology(self):
 101         response = test_utils.get_ordm_topo_request("")
 102         res = response.json()
 103         # Tests related to nodes
 104         self.assertEqual(response.status_code, requests.codes.ok)
 105         nbNode = len(res['network'][0]['node'])
 106         self.assertEqual(nbNode, 4)
 107         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 108         for i in range(0, nbNode):
 109             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 110                           res['network'][0]['node'][i]['supporting-node'])
 111             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 112             nodeId = res['network'][0]['node'][i]['node-id']
 113             if(nodeId == 'ROADM-A1-SRG1'):
 114                 # Test related to SRG1
 115                 self.assertEqual(nodeType, 'SRG')
 116                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 117                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 118                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 119                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 120                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 121                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 122                               res['network'][0]['node'][i]['supporting-node'])
 123                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 124                               res['network'][0]['node'][i]['supporting-node'])
 125                 listNode.remove(nodeId)
 126             elif(nodeId == 'ROADM-A1-SRG3'):
 127                 # Test related to SRG1
 128                 self.assertEqual(nodeType, 'SRG')
 129                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 130                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 131                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 132                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 133                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 134                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 135                               res['network'][0]['node'][i]['supporting-node'])
 136                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 137                               res['network'][0]['node'][i]['supporting-node'])
 138                 listNode.remove(nodeId)
 139             elif(nodeId == 'ROADM-A1-DEG1'):
 140                 # Test related to DEG1
 141                 self.assertEqual(nodeType, 'DEGREE')
 142                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 143                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 144                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 145                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 146                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 147                               res['network'][0]['node'][i]['supporting-node'])
 148                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 149                               res['network'][0]['node'][i]['supporting-node'])
 150                 listNode.remove(nodeId)
 151             elif(nodeId == 'ROADM-A1-DEG2'):
 152                 # Test related to DEG2
 153                 self.assertEqual(nodeType, 'DEGREE')
 154                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 155                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 156                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 157                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 158                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 159                               res['network'][0]['node'][i]['supporting-node'])
 160                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 161                               res['network'][0]['node'][i]['supporting-node'])
 162                 listNode.remove(nodeId)
 163             else:
 164                 self.assertFalse(True)
 165         self.assertEqual(len(listNode), 0)
 166
 167     def test_06_connect_XPDRA(self):
 168         response = test_utils.mount_device("XPDR-A1", 'xpdra')
 169         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 170
 171     def test_07_getClliNetwork(self):
 172         response = test_utils.get_clli_net_request()
 173         self.assertEqual(response.status_code, requests.codes.ok)
 174         res = response.json()
 175         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
 176         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 177
 178     def test_08_getOpenRoadmNetwork(self):
 179         response = test_utils.get_ordm_net_request()
 180         self.assertEqual(response.status_code, requests.codes.ok)
 181         res = response.json()
 182         nbNode = len(res['network'][0]['node'])
 183         self.assertEqual(nbNode, 2)
 184         for i in range(0, nbNode):
 185             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
 186             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
 187             nodeId = res['network'][0]['node'][i]['node-id']
 188             if(nodeId == 'XPDR-A1'):
 189                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
 190                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 191             elif(nodeId == 'ROADM-A1'):
 192                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
 193                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 194             else:
 195                 self.assertFalse(True)
 196
 197     def test_09_getNodes_OpenRoadmTopology(self):
 198         response = test_utils.get_ordm_topo_request("")
 199         res = response.json()
 200         # Tests related to nodes
 201         self.assertEqual(response.status_code, requests.codes.ok)
 202         nbNode = len(res['network'][0]['node'])
 203         self.assertEqual(nbNode, 5)
 204         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 205         for i in range(0, nbNode):
 206             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 207             nodeId = res['network'][0]['node'][i]['node-id']
 208             # Tests related to XPDRA nodes
 209             if(nodeId == 'XPDR-A1-XPDR1'):
 210                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 211                               res['network'][0]['node'][i]['supporting-node'])
 212                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 213                               res['network'][0]['node'][i]['supporting-node'])
 214                 self.assertEqual(nodeType, 'XPONDER')
 215                 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 216                 client = 0
 217                 network = 0
 218                 for j in range(0, nbTps):
 219                     tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
 220                     tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
 221                     if (tpType == 'XPONDER-CLIENT'):
 222                         client += 1
 223                     elif (tpType == 'XPONDER-NETWORK'):
 224                         network += 1
 225                     if (tpId == 'XPDR1-NETWORK2'):
 226                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 227                                          ['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
 228                     if (tpId == 'XPDR1-CLIENT2'):
 229                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 230                                          ['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
 231
 232                 self.assertTrue(client == 2)
 233                 self.assertTrue(network == 2)
 234                 listNode.remove(nodeId)
 235             elif(nodeId == 'ROADM-A1-SRG1'):
 236                 # Test related to SRG1
 237                 self.assertEqual(nodeType, 'SRG')
 238                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 239                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 240                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 241                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 242                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 243                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 244                               res['network'][0]['node'][i]['supporting-node'])
 245                 listNode.remove(nodeId)
 246             elif(nodeId == 'ROADM-A1-SRG3'):
 247                 # Test related to SRG1
 248                 self.assertEqual(nodeType, 'SRG')
 249                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 250                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 251                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 252                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 253                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 254                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 255                               res['network'][0]['node'][i]['supporting-node'])
 256                 listNode.remove(nodeId)
 257             elif(nodeId == 'ROADM-A1-DEG1'):
 258                 # Test related to DEG1
 259                 self.assertEqual(nodeType, 'DEGREE')
 260                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 261                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 262                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 263                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 264                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 265                               res['network'][0]['node'][i]['supporting-node'])
 266                 listNode.remove(nodeId)
 267             elif(nodeId == 'ROADM-A1-DEG2'):
 268                 # Test related to DEG2
 269                 self.assertEqual(nodeType, 'DEGREE')
 270                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 271                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 272                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 273                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 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         response = test_utils.get_ordm_topo_request("")
 295         self.assertEqual(response.status_code, requests.codes.ok)
 296         res = response.json()
 297         # Tests related to links
 298         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 299         self.assertEqual(nbLink, 12)
 300         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 301                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
 302         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 303                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
 304         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 305                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
 306         XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
 307         XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 308         for i in range(0, nbLink):
 309             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 310             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 311             if(nodeType == 'EXPRESS-LINK'):
 312                 find = linkId in expressLink
 313                 self.assertEqual(find, True)
 314                 expressLink.remove(linkId)
 315             elif(nodeType == 'ADD-LINK'):
 316                 find = linkId in addLink
 317                 self.assertEqual(find, True)
 318                 addLink.remove(linkId)
 319             elif(nodeType == 'DROP-LINK'):
 320                 find = linkId in dropLink
 321                 self.assertEqual(find, True)
 322                 dropLink.remove(linkId)
 323             elif(nodeType == 'XPONDER-INPUT'):
 324                 find = linkId in XPDR_IN
 325                 self.assertEqual(find, True)
 326                 XPDR_IN.remove(linkId)
 327             elif(nodeType == 'XPONDER-OUTPUT'):
 328                 find = linkId in XPDR_OUT
 329                 self.assertEqual(find, True)
 330                 XPDR_OUT.remove(linkId)
 331             else:
 332                 self.assertFalse(True)
 333         self.assertEqual(len(expressLink), 0)
 334         self.assertEqual(len(addLink), 0)
 335         self.assertEqual(len(dropLink), 0)
 336         self.assertEqual(len(XPDR_IN), 0)
 337         self.assertEqual(len(XPDR_OUT), 0)
 338
 339     def test_13_connect_ROADMC(self):
 340         response = test_utils.mount_device("ROADM-C1", 'roadmc')
 341         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 342
 343     def test_14_omsAttributes_ROADMA_ROADMC(self):
 344         # Config ROADMA-ROADMC oms-attributes
 345         data = {"span": {
 346             "auto-spanloss": "true",
 347             "engineered-spanloss": 12.2,
 348             "link-concatenation": [{
 349                 "SRLG-Id": 0,
 350                 "fiber-type": "smf",
 351                 "SRLG-length": 100000,
 352                 "pmd": 0.5}]}}
 353         response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
 354         self.assertEqual(response.status_code, requests.codes.created)
 355
 356     def test_15_omsAttributes_ROADMC_ROADMA(self):
 357         # Config ROADM-C1-ROADM-A1 oms-attributes
 358         data = {"span": {
 359             "auto-spanloss": "true",
 360             "engineered-spanloss": 12.2,
 361             "link-concatenation": [{
 362                 "SRLG-Id": 0,
 363                 "fiber-type": "smf",
 364                 "SRLG-length": 100000,
 365                 "pmd": 0.5}]}}
 366
 367         response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
 368         self.assertEqual(response.status_code, requests.codes.created)
 369
 370     def test_16_getClliNetwork(self):
 371         response = test_utils.get_clli_net_request()
 372         self.assertEqual(response.status_code, requests.codes.ok)
 373         res = response.json()
 374         nbNode = len(res['network'][0]['node'])
 375         listNode = ['NodeA', 'NodeC']
 376         for i in range(0, nbNode):
 377             nodeId = res['network'][0]['node'][i]['node-id']
 378             find = nodeId in listNode
 379             self.assertEqual(find, True)
 380             if(nodeId == 'NodeA'):
 381                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
 382             else:
 383                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
 384             listNode.remove(nodeId)
 385         self.assertEqual(len(listNode), 0)
 386
 387     def test_17_getOpenRoadmNetwork(self):
 388         response = test_utils.get_ordm_net_request()
 389         self.assertEqual(response.status_code, requests.codes.ok)
 390         res = response.json()
 391         nbNode = len(res['network'][0]['node'])
 392         self.assertEqual(nbNode, 3)
 393         listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
 394         for i in range(0, nbNode):
 395             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
 396             nodeId = res['network'][0]['node'][i]['node-id']
 397             if(nodeId == 'XPDR-A1'):
 398                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
 399                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
 400                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 401                 listNode.remove(nodeId)
 402             elif(nodeId == 'ROADM-A1'):
 403                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
 404                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
 405                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 406                 listNode.remove(nodeId)
 407             elif(nodeId == 'ROADM-C1'):
 408                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
 409                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
 410                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 411                 listNode.remove(nodeId)
 412             else:
 413                 self.assertFalse(True)
 414         self.assertEqual(len(listNode), 0)
 415
 416     def test_18_getROADMLinkOpenRoadmTopology(self):
 417         response = test_utils.get_ordm_topo_request("")
 418         self.assertEqual(response.status_code, requests.codes.ok)
 419         res = response.json()
 420         # Tests related to links
 421         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 422         self.assertEqual(nbLink, 20)
 423         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 424                        'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
 425         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 426                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 427                    'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
 428         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 429                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 430                     'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
 431         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 432                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
 433         XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
 434         XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 435         for i in range(0, nbLink):
 436             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 437             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 438             if(nodeType == 'EXPRESS-LINK'):
 439                 find = linkId in expressLink
 440                 self.assertEqual(find, True)
 441                 expressLink.remove(linkId)
 442             elif(nodeType == 'ADD-LINK'):
 443                 find = linkId in addLink
 444                 self.assertEqual(find, True)
 445                 addLink.remove(linkId)
 446             elif(nodeType == 'DROP-LINK'):
 447                 find = linkId in dropLink
 448                 self.assertEqual(find, True)
 449                 dropLink.remove(linkId)
 450             elif(nodeType == 'ROADM-TO-ROADM'):
 451                 find = linkId in R2RLink
 452                 self.assertEqual(find, True)
 453                 R2RLink.remove(linkId)
 454             elif(nodeType == 'XPONDER-INPUT'):
 455                 find = linkId in XPDR_IN
 456                 self.assertEqual(find, True)
 457                 XPDR_IN.remove(linkId)
 458             elif(nodeType == 'XPONDER-OUTPUT'):
 459                 find = linkId in XPDR_OUT
 460                 self.assertEqual(find, True)
 461                 XPDR_OUT.remove(linkId)
 462             else:
 463                 self.assertFalse(True)
 464         self.assertEqual(len(expressLink), 0)
 465         self.assertEqual(len(addLink), 0)
 466         self.assertEqual(len(dropLink), 0)
 467         self.assertEqual(len(R2RLink), 0)
 468         self.assertEqual(len(XPDR_IN), 0)
 469         self.assertEqual(len(XPDR_OUT), 0)
 470
 471     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
 472         response = test_utils.get_ordm_topo_request("")
 473         self.assertEqual(response.status_code, requests.codes.ok)
 474         res = response.json()
 475         # Tests related to links
 476         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 477         self.assertEqual(nbLink, 20)
 478         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 479                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
 480         for i in range(0, nbLink):
 481             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 482             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 483             if(link_id in R2RLink):
 484                 find = False
 485                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 486                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 487                 length = res['network'][0]['ietf-network-topology:link'][i][
 488                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 489                 if((spanLoss != None) & (length != None)):
 490                     find = True
 491                 self.assertTrue(find)
 492                 R2RLink.remove(link_id)
 493         self.assertEqual(len(R2RLink), 0)
 494
 495     def test_20_getNodes_OpenRoadmTopology(self):
 496         response = test_utils.get_ordm_topo_request("")
 497         res = response.json()
 498         # Tests related to nodes
 499         self.assertEqual(response.status_code, requests.codes.ok)
 500         nbNode = len(res['network'][0]['node'])
 501         self.assertEqual(nbNode, 8)
 502         listNode = ['XPDR-A1-XPDR1',
 503                     'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
 504                     'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
 505         # ************************Tests related to XPDRA nodes
 506         for i in range(0, nbNode):
 507             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 508             nodeId = res['network'][0]['node'][i]['node-id']
 509             if(nodeId == 'XPDR-A1-XPDR1'):
 510                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 511                               res['network'][0]['node'][i]['supporting-node'])
 512                 self.assertEqual(nodeType, 'XPONDER')
 513                 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 514                 self.assertTrue(nbTps >= 4)
 515                 client = 0
 516                 network = 0
 517                 for j in range(0, nbTps):
 518                     tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
 519                     if (tpType == 'XPONDER-CLIENT'):
 520                         client += 1
 521                     elif (tpType == 'XPONDER-NETWORK'):
 522                         network += 1
 523                 self.assertTrue(client == 2)
 524                 self.assertTrue(network == 2)
 525                 listNode.remove(nodeId)
 526             elif(nodeId == 'ROADM-A1-SRG1'):
 527                 # Test related to SRG1
 528                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 529                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 530                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 531                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 532                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 533                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 534                               res['network'][0]['node'][i]['supporting-node'])
 535                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
 536                 listNode.remove(nodeId)
 537             elif(nodeId == 'ROADM-A1-SRG3'):
 538                 # Test related to SRG1
 539                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 540                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 541                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 542                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 543                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 544                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 545                               res['network'][0]['node'][i]['supporting-node'])
 546                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
 547                 listNode.remove(nodeId)
 548             elif(nodeId == 'ROADM-A1-DEG1'):
 549                 # Test related to DEG1
 550                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 551                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 552                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 553                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 554                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 555                               res['network'][0]['node'][i]['supporting-node'])
 556                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 557                 listNode.remove(nodeId)
 558             elif(nodeId == 'ROADM-A1-DEG2'):
 559                 # Test related to DEG2
 560                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 561                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 562                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 563                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 564                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 565                               res['network'][0]['node'][i]['supporting-node'])
 566                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 567                 listNode.remove(nodeId)
 568             elif(nodeId == 'ROADM-C1-SRG1'):
 569                 # Test related to SRG1
 570                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 571                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 572                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 573                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 574                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 575                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 576                               res['network'][0]['node'][i]['supporting-node'])
 577                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
 578                 listNode.remove(nodeId)
 579             elif(nodeId == 'ROADM-C1-DEG1'):
 580                 # Test related to DEG1
 581                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 582                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 583                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 584                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 585                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 586                               res['network'][0]['node'][i]['supporting-node'])
 587                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 588                 listNode.remove(nodeId)
 589             elif(nodeId == 'ROADM-C1-DEG2'):
 590                 # Test related to DEG1
 591                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 592                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 593                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 594                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 595                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 596                               res['network'][0]['node'][i]['supporting-node'])
 597                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 598                 listNode.remove(nodeId)
 599             else:
 600                 self.assertFalse(True)
 601         self.assertEqual(len(listNode), 0)
 602
 603     def test_21_connect_ROADMB(self):
 604         response = test_utils.mount_device("ROADM-B1", 'roadmb')
 605         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 606
 607     def test_22_omsAttributes_ROADMA_ROADMB(self):
 608         # Config ROADM-A1-ROADM-B1 oms-attributes
 609         data = {"span": {
 610                 "auto-spanloss": "true",
 611                 "engineered-spanloss": 12.2,
 612                 "spanloss-current": 12,
 613                 "spanloss-base": 11.4,
 614                 "link-concatenation": [{
 615                     "SRLG-Id": 0,
 616                     "fiber-type": "smf",
 617                     "SRLG-length": 100000,
 618                     "pmd": 0.5}]}}
 619         response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
 620         self.assertEqual(response.status_code, requests.codes.created)
 621
 622     def test_23_omsAttributes_ROADMB_ROADMA(self):
 623         # Config ROADM-B1-ROADM-A1 oms-attributes
 624         data = {"span": {
 625                 "auto-spanloss": "true",
 626                 "engineered-spanloss": 12.2,
 627                 "spanloss-current": 12,
 628                 "spanloss-base": 11.4,
 629                 "link-concatenation": [{
 630                     "SRLG-Id": 0,
 631                     "fiber-type": "smf",
 632                     "SRLG-length": 100000,
 633                     "pmd": 0.5}]}}
 634         response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
 635         self.assertEqual(response.status_code, requests.codes.created)
 636
 637     def test_24_omsAttributes_ROADMB_ROADMC(self):
 638         # Config ROADM-B1-ROADM-C1 oms-attributes
 639         data = {"span": {
 640                 "auto-spanloss": "true",
 641                 "engineered-spanloss": 12.2,
 642                 "spanloss-current": 12,
 643                 "spanloss-base": 11.4,
 644                 "link-concatenation": [{
 645                     "SRLG-Id": 0,
 646                     "fiber-type": "smf",
 647                     "SRLG-length": 100000,
 648                     "pmd": 0.5}]}}
 649         response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
 650         self.assertEqual(response.status_code, requests.codes.created)
 651
 652     def test_25_omsAttributes_ROADMC_ROADMB(self):
 653         # Config ROADM-C1-ROADM-B1 oms-attributes
 654         data = {"span": {
 655                 "auto-spanloss": "true",
 656                 "engineered-spanloss": 12.2,
 657                 "link-concatenation": [{
 658                     "SRLG-Id": 0,
 659                     "fiber-type": "smf",
 660                     "SRLG-length": 100000,
 661                     "pmd": 0.5}]}}
 662         response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
 663         self.assertEqual(response.status_code, requests.codes.created)
 664
 665     def test_26_getClliNetwork(self):
 666         response = test_utils.get_clli_net_request()
 667         self.assertEqual(response.status_code, requests.codes.ok)
 668         res = response.json()
 669         nbNode = len(res['network'][0]['node'])
 670         listNode = ['NodeA', 'NodeB', 'NodeC']
 671         for i in range(0, nbNode):
 672             nodeId = res['network'][0]['node'][i]['node-id']
 673             find = nodeId in listNode
 674             self.assertEqual(find, True)
 675             if(nodeId == 'NodeA'):
 676                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
 677             elif(nodeId == 'NodeB'):
 678                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
 679             else:
 680                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
 681             listNode.remove(nodeId)
 682         self.assertEqual(len(listNode), 0)
 683
 684     def test_27_verifyDegree(self):
 685         response = test_utils.get_ordm_topo_request("")
 686         self.assertEqual(response.status_code, requests.codes.ok)
 687         res = response.json()
 688         # Tests related to links
 689         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 690         listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 691                        'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 692                        'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
 693         for i in range(0, nbLink):
 694             if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
 695                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 696                 find = link_id in listR2RLink
 697                 self.assertEqual(find, True)
 698                 listR2RLink.remove(link_id)
 699         self.assertEqual(len(listR2RLink), 0)
 700
 701     def test_28_verifyOppositeLinkTopology(self):
 702         response = test_utils.get_ordm_topo_request("")
 703         self.assertEqual(response.status_code, requests.codes.ok)
 704         res = response.json()
 705         # Tests related to links
 706         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 707         self.assertEqual(nbLink, 26)
 708         for i in range(0, nbLink):
 709             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 710             link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 711             link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
 712             link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
 713             oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
 714             # Find the opposite link
 715             response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
 716             self.assertEqual(response_oppLink.status_code, requests.codes.ok)
 717             res_oppLink = response_oppLink.json()
 718             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
 719                              ['org-openroadm-common-network:opposite-link'], link_id)
 720             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
 721             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
 722             oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
 723             if link_type == 'ADD-LINK':
 724                 self.assertEqual(oppLink_type, 'DROP-LINK')
 725             elif link_type == 'DROP-LINK':
 726                 self.assertEqual(oppLink_type, 'ADD-LINK')
 727             elif link_type == 'EXPRESS-LINK':
 728                 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
 729             elif link_type == 'ROADM-TO-ROADM':
 730                 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
 731             elif link_type == 'XPONDER-INPUT':
 732                 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
 733             elif link_type == 'XPONDER-OUTPUT':
 734                 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
 735
 736     def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
 737         response = test_utils.get_ordm_topo_request("")
 738         self.assertEqual(response.status_code, requests.codes.ok)
 739         res = response.json()
 740         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 741         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 742                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 743                    'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
 744                    'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 745                    'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
 746                    'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
 747         for i in range(0, nbLink):
 748             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 749             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 750             if(link_id in R2RLink):
 751                 find = False
 752                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 753                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 754                 length = res['network'][0]['ietf-network-topology:link'][i][
 755                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 756                 if((spanLoss != None) & (length != None)):
 757                     find = True
 758                 self.assertTrue(find)
 759                 R2RLink.remove(link_id)
 760         self.assertEqual(len(R2RLink), 0)
 761
 762     def test_30_disconnect_ROADMB(self):
 763         # Delete in the topology-netconf
 764         response = test_utils.unmount_device("ROADM-B1")
 765         # Delete in the clli-network
 766         response = test_utils.del_node_request("NodeB")
 767         self.assertEqual(response.status_code, requests.codes.ok)
 768
 769     def test_31_disconnect_ROADMC(self):
 770         # Delete in the topology-netconf
 771         response = test_utils.unmount_device("ROADM-C1")
 772         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 773         # Delete in the clli-network
 774         response = test_utils.del_node_request("NodeC")
 775         self.assertEqual(response.status_code, requests.codes.ok)
 776
 777 #    def test_24_check_roadm2roadm_links_deletion(self):
 778 #        response = test_utils.get_ordm_topo_request("")
 779 #        self.assertEqual(response.status_code, requests.codes.ok)
 780 #        res = response.json()
 781 #        #Write the response in the log
 782 #        with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 783 #            outfile1.write(str(res))
 784 #        #Tests related to links
 785 #        nbLink=len(res['network'][0]['ietf-network-topology:link'])
 786 #        self.assertEqual(nbLink,8)
 787 #        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
 788 #        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
 789 #        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
 790 #        XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
 791 #        XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
 792 #        for i in range(0,nbLink):
 793 #            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 794 #            linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 795 #            if(nodeType=='EXPRESS-LINK'):
 796 #                find= linkId in expressLink
 797 #                self.assertEqual(find, True)
 798 #                expressLink.remove(linkId)
 799 #            elif(nodeType=='ADD-LINK'):
 800 #                find= linkId in addLink
 801 #                self.assertEqual(find, True)
 802 #                addLink.remove(linkId)
 803 #            elif(nodeType=='DROP-LINK'):
 804 #                find= linkId in dropLink
 805 #                self.assertEqual(find, True)
 806 #                dropLink.remove(linkId)
 807 #            elif(nodeType=='XPONDER-INPUT'):
 808 #                find= linkId in XPDR_IN
 809 #                self.assertEqual(find, True)
 810 #                XPDR_IN.remove(linkId)
 811 #            elif(nodeType=='XPONDER-OUTPUT'):
 812 #                find= linkId in XPDR_OUT
 813 #                self.assertEqual(find, True)
 814 #                XPDR_OUT.remove(linkId)
 815 #            else:
 816 #                self.assertFalse(True)
 817 #        self.assertEqual(len(expressLink),0)
 818 #        self.assertEqual(len(addLink),0)
 819 #        self.assertEqual(len(dropLink),0)
 820 #        self.assertEqual(len(XPDR_IN),0)
 821 #        self.assertEqual(len(XPDR_OUT),0)
 822 #
 823 #        for i in range(0,nbLink):
 824 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
 825 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 826 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 827 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
 828 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 829 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
 830 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 831
 832     def test_32_getNodes_OpenRoadmTopology(self):
 833         response = test_utils.get_ordm_topo_request("")
 834         res = response.json()
 835         # Tests related to nodes
 836         self.assertEqual(response.status_code, requests.codes.ok)
 837         nbNode = len(res['network'][0]['node'])
 838         self.assertEqual(nbNode, 5)
 839         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 840         for i in range(0, nbNode):
 841             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 842             nodeId = res['network'][0]['node'][i]['node-id']
 843             # Tests related to XPDRA nodes
 844             if(nodeId == 'XPDR-A1-XPDR1'):
 845                 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 846                 for j in range(0, nbTp):
 847                     tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
 848                     if (tpid == 'XPDR1-CLIENT1'):
 849                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 850                                          ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
 851                     if (tpid == 'XPDR1-NETWORK1'):
 852                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 853                                          ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
 854                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 855                                          ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
 856                                          'ROADM-A1-SRG1--SRG1-PP1-TXRX')
 857                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 858                               res['network'][0]['node'][i]['supporting-node'])
 859                 listNode.remove(nodeId)
 860             elif(nodeId == 'ROADM-A1-SRG1'):
 861                 # Test related to SRG1
 862                 self.assertEqual(nodeType, 'SRG')
 863                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 864                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 865                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 866                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 867                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 868                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 869                               res['network'][0]['node'][i]['supporting-node'])
 870                 listNode.remove(nodeId)
 871             elif(nodeId == 'ROADM-A1-SRG3'):
 872                 # Test related to SRG1
 873                 self.assertEqual(nodeType, 'SRG')
 874                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 875                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 876                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 877                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 878                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 879                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 880                               res['network'][0]['node'][i]['supporting-node'])
 881                 listNode.remove(nodeId)
 882             elif(nodeId == 'ROADM-A1-DEG1'):
 883                 # Test related to DEG1
 884                 self.assertEqual(nodeType, 'DEGREE')
 885                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 886                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 887                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 888                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 889                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 890                               res['network'][0]['node'][i]['supporting-node'])
 891                 listNode.remove(nodeId)
 892             elif(nodeId == 'ROADM-A1-DEG2'):
 893                 # Test related to DEG2
 894                 self.assertEqual(nodeType, 'DEGREE')
 895                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 896                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 897                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 898                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 899                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 900                               res['network'][0]['node'][i]['supporting-node'])
 901                 listNode.remove(nodeId)
 902             else:
 903                 self.assertFalse(True)
 904         self.assertEqual(len(listNode), 0)
 905         # Test related to SRG1 of ROADMC
 906         for i in range(0, nbNode):
 907             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
 908             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
 909             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
 910
 911     def test_33_getOpenRoadmNetwork(self):
 912         response = test_utils.get_ordm_net_request()
 913         self.assertEqual(response.status_code, requests.codes.ok)
 914         res = response.json()
 915         nbNode = len(res['network'][0]['node'])
 916         self.assertEqual(nbNode, 2)
 917         for i in range(0, nbNode-1):
 918             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
 919             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
 920
 921     def test_34_getClliNetwork(self):
 922         response = test_utils.get_clli_net_request()
 923         self.assertEqual(response.status_code, requests.codes.ok)
 924         res = response.json()
 925         nbNode = len(res['network'][0]['node'])
 926         self.assertEqual(nbNode, 1)
 927         for i in range(0, nbNode-1):
 928             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
 929
 930     def test_35_disconnect_XPDRA(self):
 931         response = test_utils.unmount_device("XPDR-A1")
 932         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 933
 934     def test_36_getClliNetwork(self):
 935         response = test_utils.get_clli_net_request()
 936         self.assertEqual(response.status_code, requests.codes.ok)
 937         res = response.json()
 938         nbNode = len(res['network'][0]['node'])
 939         self.assertEqual(nbNode, 1)
 940         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 941
 942     def test_37_getOpenRoadmNetwork(self):
 943         response = test_utils.get_ordm_net_request()
 944         self.assertEqual(response.status_code, requests.codes.ok)
 945         res = response.json()
 946         nbNode = len(res['network'][0]['node'])
 947         self.assertEqual(nbNode, 1)
 948         for i in range(0, nbNode):
 949             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
 950
 951     def test_38_getNodes_OpenRoadmTopology(self):
 952         response = test_utils.get_ordm_topo_request("")
 953         res = response.json()
 954         # Tests related to nodes
 955         self.assertEqual(response.status_code, requests.codes.ok)
 956         nbNode = len(res['network'][0]['node'])
 957         self.assertEqual(nbNode, 4)
 958         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 959         for i in range(0, nbNode):
 960             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 961                           res['network'][0]['node'][i]['supporting-node'])
 962             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 963             nodeId = res['network'][0]['node'][i]['node-id']
 964             if(nodeId == 'ROADM-A1-SRG1'):
 965                 # Test related to SRG1
 966                 self.assertEqual(nodeType, 'SRG')
 967                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 968                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 969                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 970                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 971                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 972                 listNode.remove(nodeId)
 973             elif(nodeId == 'ROADM-A1-SRG3'):
 974                 # Test related to SRG1
 975                 self.assertEqual(nodeType, 'SRG')
 976                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 977                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 978                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 979                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 980                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 981                 listNode.remove(nodeId)
 982             elif(nodeId == 'ROADM-A1-DEG1'):
 983                 # Test related to DEG1
 984                 self.assertEqual(nodeType, 'DEGREE')
 985                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 986                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 987                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 988                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 989                 listNode.remove(nodeId)
 990             elif(nodeId == 'ROADM-A1-DEG2'):
 991                 # Test related to DEG2
 992                 self.assertEqual(nodeType, 'DEGREE')
 993                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 994                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 995                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 996                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 997                 listNode.remove(nodeId)
 998             else:
 999                 self.assertFalse(True)
1000         self.assertEqual(len(listNode), 0)
1001
1002     def test_39_disconnect_ROADM_XPDRA_link(self):
1003         # Link-1
1004         response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
1005         self.assertEqual(response.status_code, requests.codes.ok)
1006         # Link-2
1007         response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
1008         self.assertEqual(response.status_code, requests.codes.ok)
1009
1010     def test_40_getLinks_OpenRoadmTopology(self):
1011         response = test_utils.get_ordm_topo_request("")
1012         self.assertEqual(response.status_code, requests.codes.ok)
1013         res = response.json()
1014         nbLink = len(res['network'][0]['ietf-network-topology:link'])
1015         self.assertEqual(nbLink, 16)
1016         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1017                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1018         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1019                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1020         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1021                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1022         roadmtoroadmLink = 0
1023         for i in range(0, nbLink):
1024             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1025                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1026                 find = link_id in expressLink
1027                 self.assertEqual(find, True)
1028                 expressLink.remove(link_id)
1029             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1030                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1031                 find = link_id in addLink
1032                 self.assertEqual(find, True)
1033                 addLink.remove(link_id)
1034             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1035                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1036                 find = link_id in dropLink
1037                 self.assertEqual(find, True)
1038                 dropLink.remove(link_id)
1039             else:
1040                 roadmtoroadmLink += 1
1041         self.assertEqual(len(expressLink), 0)
1042         self.assertEqual(len(addLink), 0)
1043         self.assertEqual(len(dropLink), 0)
1044         self.assertEqual(roadmtoroadmLink, 6)
1045         for i in range(0, nbLink):
1046             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1047                                 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1048             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1049                                 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1050
1051     def test_41_disconnect_ROADMA(self):
1052         response = test_utils.unmount_device("ROADM-A1")
1053         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1054         # Delete in the clli-network
1055         response = test_utils.del_node_request("NodeA")
1056         self.assertEqual(response.status_code, requests.codes.ok)
1057
1058     def test_42_getClliNetwork(self):
1059         response = test_utils.get_clli_net_request()
1060         self.assertEqual(response.status_code, requests.codes.ok)
1061         res = response.json()
1062         self.assertNotIn('node', res['network'][0])
1063
1064     def test_43_getOpenRoadmNetwork(self):
1065         response = test_utils.get_ordm_net_request()
1066         self.assertEqual(response.status_code, requests.codes.ok)
1067         res = response.json()
1068         self.assertNotIn('node', res['network'][0])
1069
1070     def test_44_check_roadm2roadm_link_persistence(self):
1071         response = test_utils.get_ordm_topo_request("")
1072         self.assertEqual(response.status_code, requests.codes.ok)
1073         res = response.json()
1074         nbLink = len(res['network'][0]['ietf-network-topology:link'])
1075         self.assertNotIn('node', res['network'][0])
1076         self.assertEqual(nbLink, 6)
1077
1078
1079 if __name__ == "__main__":
1080     unittest.main(verbosity=2)