tests/transportpce_tests/2.2.1/test_topology.py

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