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