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