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         url = "{}/operations/transportpce-networkutils:init-xpdr-rdm-links"
 282         data = {"networkutils:input": {
 283             "networkutils:links-input": {
 284                 "networkutils:xpdr-node": "XPDR-A1",
 285                 "networkutils:xpdr-num": "1",
 286                 "networkutils:network-num": "1",
 287                 "networkutils:rdm-node": "ROADM-A1",
 288                 "networkutils:srg-num": "1",
 289                 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 290             }
 291         }
 292         }
 293         response = test_utils.post_request(url, data)
 294         self.assertEqual(response.status_code, requests.codes.ok)
 295
 296     def test_11_connect_tail_rdm_xpdr(self):
 297         # Connect the tail: ROADMA to XPDRA
 298         url = "{}/operations/transportpce-networkutils:init-rdm-xpdr-links"
 299         data = {"networkutils:input": {
 300             "networkutils:links-input": {
 301                 "networkutils:xpdr-node": "XPDR-A1",
 302                 "networkutils:xpdr-num": "1",
 303                 "networkutils:network-num": "1",
 304                 "networkutils:rdm-node": "ROADM-A1",
 305                 "networkutils:srg-num": "1",
 306                 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 307             }
 308         }
 309         }
 310         response = test_utils.post_request(url, data)
 311         self.assertEqual(response.status_code, requests.codes.ok)
 312
 313     def test_12_getLinks_OpenRoadmTopology(self):
 314         response = test_utils.get_ordm_topo_request("")
 315         self.assertEqual(response.status_code, requests.codes.ok)
 316         res = response.json()
 317         # Tests related to links
 318         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 319         self.assertEqual(nbLink, 12)
 320         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 321                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
 322         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 323                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
 324         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 325                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
 326         XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
 327         XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 328         for i in range(0, nbLink):
 329             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 330             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 331             if(nodeType == 'EXPRESS-LINK'):
 332                 find = linkId in expressLink
 333                 self.assertEqual(find, True)
 334                 expressLink.remove(linkId)
 335             elif(nodeType == 'ADD-LINK'):
 336                 find = linkId in addLink
 337                 self.assertEqual(find, True)
 338                 addLink.remove(linkId)
 339             elif(nodeType == 'DROP-LINK'):
 340                 find = linkId in dropLink
 341                 self.assertEqual(find, True)
 342                 dropLink.remove(linkId)
 343             elif(nodeType == 'XPONDER-INPUT'):
 344                 find = linkId in XPDR_IN
 345                 self.assertEqual(find, True)
 346                 XPDR_IN.remove(linkId)
 347             elif(nodeType == 'XPONDER-OUTPUT'):
 348                 find = linkId in XPDR_OUT
 349                 self.assertEqual(find, True)
 350                 XPDR_OUT.remove(linkId)
 351             else:
 352                 self.assertFalse(True)
 353         self.assertEqual(len(expressLink), 0)
 354         self.assertEqual(len(addLink), 0)
 355         self.assertEqual(len(dropLink), 0)
 356         self.assertEqual(len(XPDR_IN), 0)
 357         self.assertEqual(len(XPDR_OUT), 0)
 358
 359     def test_13_connect_ROADMC(self):
 360         response = test_utils.mount_device("ROADM-C1", 'roadmc')
 361         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 362
 363     def test_14_omsAttributes_ROADMA_ROADMC(self):
 364         # Config ROADMA-ROADMC oms-attributes
 365         data = {"span": {
 366             "auto-spanloss": "true",
 367             "engineered-spanloss": 12.2,
 368             "link-concatenation": [{
 369                 "SRLG-Id": 0,
 370                 "fiber-type": "smf",
 371                 "SRLG-length": 100000,
 372                 "pmd": 0.5}]}}
 373         response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
 374         self.assertEqual(response.status_code, requests.codes.created)
 375
 376     def test_15_omsAttributes_ROADMC_ROADMA(self):
 377         # Config ROADM-C1-ROADM-A1 oms-attributes
 378         data = {"span": {
 379             "auto-spanloss": "true",
 380             "engineered-spanloss": 12.2,
 381             "link-concatenation": [{
 382                 "SRLG-Id": 0,
 383                 "fiber-type": "smf",
 384                 "SRLG-length": 100000,
 385                 "pmd": 0.5}]}}
 386
 387         response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
 388         self.assertEqual(response.status_code, requests.codes.created)
 389
 390     def test_16_getClliNetwork(self):
 391         response = test_utils.get_clli_net_request()
 392         self.assertEqual(response.status_code, requests.codes.ok)
 393         res = response.json()
 394         nbNode = len(res['network'][0]['node'])
 395         listNode = ['NodeA', 'NodeC']
 396         for i in range(0, nbNode):
 397             nodeId = res['network'][0]['node'][i]['node-id']
 398             find = nodeId in listNode
 399             self.assertEqual(find, True)
 400             if(nodeId == 'NodeA'):
 401                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
 402             else:
 403                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
 404             listNode.remove(nodeId)
 405         self.assertEqual(len(listNode), 0)
 406
 407     def test_17_getOpenRoadmNetwork(self):
 408         response = test_utils.get_ordm_net_request()
 409         self.assertEqual(response.status_code, requests.codes.ok)
 410         res = response.json()
 411         nbNode = len(res['network'][0]['node'])
 412         self.assertEqual(nbNode, 3)
 413         listNode = ['XPDR-A1', 'ROADM-A1', 'ROADM-C1']
 414         for i in range(0, nbNode):
 415             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
 416             nodeId = res['network'][0]['node'][i]['node-id']
 417             if(nodeId == 'XPDR-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'], 'XPONDER')
 420                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 421                 listNode.remove(nodeId)
 422             elif(nodeId == 'ROADM-A1'):
 423                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
 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             elif(nodeId == 'ROADM-C1'):
 428                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeC')
 429                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
 430                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], 'model2')
 431                 listNode.remove(nodeId)
 432             else:
 433                 self.assertFalse(True)
 434         self.assertEqual(len(listNode), 0)
 435
 436     def test_18_getROADMLinkOpenRoadmTopology(self):
 437         response = test_utils.get_ordm_topo_request("")
 438         self.assertEqual(response.status_code, requests.codes.ok)
 439         res = response.json()
 440         # Tests related to links
 441         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 442         self.assertEqual(nbLink, 20)
 443         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX', 'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX',
 444                        'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX', 'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX']
 445         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 446                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
 447                    'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX', 'ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX']
 448         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
 449                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX',
 450                     'ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX', 'ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX']
 451         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 452                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
 453         XPDR_IN = ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
 454         XPDR_OUT = ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
 455         for i in range(0, nbLink):
 456             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 457             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 458             if(nodeType == 'EXPRESS-LINK'):
 459                 find = linkId in expressLink
 460                 self.assertEqual(find, True)
 461                 expressLink.remove(linkId)
 462             elif(nodeType == 'ADD-LINK'):
 463                 find = linkId in addLink
 464                 self.assertEqual(find, True)
 465                 addLink.remove(linkId)
 466             elif(nodeType == 'DROP-LINK'):
 467                 find = linkId in dropLink
 468                 self.assertEqual(find, True)
 469                 dropLink.remove(linkId)
 470             elif(nodeType == 'ROADM-TO-ROADM'):
 471                 find = linkId in R2RLink
 472                 self.assertEqual(find, True)
 473                 R2RLink.remove(linkId)
 474             elif(nodeType == 'XPONDER-INPUT'):
 475                 find = linkId in XPDR_IN
 476                 self.assertEqual(find, True)
 477                 XPDR_IN.remove(linkId)
 478             elif(nodeType == 'XPONDER-OUTPUT'):
 479                 find = linkId in XPDR_OUT
 480                 self.assertEqual(find, True)
 481                 XPDR_OUT.remove(linkId)
 482             else:
 483                 self.assertFalse(True)
 484         self.assertEqual(len(expressLink), 0)
 485         self.assertEqual(len(addLink), 0)
 486         self.assertEqual(len(dropLink), 0)
 487         self.assertEqual(len(R2RLink), 0)
 488         self.assertEqual(len(XPDR_IN), 0)
 489         self.assertEqual(len(XPDR_OUT), 0)
 490
 491     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
 492         response = test_utils.get_ordm_topo_request("")
 493         self.assertEqual(response.status_code, requests.codes.ok)
 494         res = response.json()
 495         # Tests related to links
 496         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 497         self.assertEqual(nbLink, 20)
 498         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 499                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX']
 500         for i in range(0, nbLink):
 501             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 502             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 503             if(link_id in R2RLink):
 504                 find = False
 505                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 506                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 507                 length = res['network'][0]['ietf-network-topology:link'][i][
 508                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 509                 if((spanLoss != None) & (length != None)):
 510                     find = True
 511                 self.assertTrue(find)
 512                 R2RLink.remove(link_id)
 513         self.assertEqual(len(R2RLink), 0)
 514
 515     def test_20_getNodes_OpenRoadmTopology(self):
 516         response = test_utils.get_ordm_topo_request("")
 517         res = response.json()
 518         # Tests related to nodes
 519         self.assertEqual(response.status_code, requests.codes.ok)
 520         nbNode = len(res['network'][0]['node'])
 521         self.assertEqual(nbNode, 8)
 522         listNode = ['XPDR-A1-XPDR1',
 523                     'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
 524                     'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
 525         # ************************Tests related to XPDRA nodes
 526         for i in range(0, nbNode):
 527             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 528             nodeId = res['network'][0]['node'][i]['node-id']
 529             if(nodeId == 'XPDR-A1-XPDR1'):
 530                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 531                               res['network'][0]['node'][i]['supporting-node'])
 532                 self.assertEqual(nodeType, 'XPONDER')
 533                 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 534                 self.assertTrue(nbTps >= 4)
 535                 client = 0
 536                 network = 0
 537                 for j in range(0, nbTps):
 538                     tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
 539                     if (tpType == 'XPONDER-CLIENT'):
 540                         client += 1
 541                     elif (tpType == 'XPONDER-NETWORK'):
 542                         network += 1
 543                 self.assertTrue(client == 2)
 544                 self.assertTrue(network == 2)
 545                 listNode.remove(nodeId)
 546             elif(nodeId == 'ROADM-A1-SRG1'):
 547                 # Test related to SRG1
 548                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 549                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 550                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 551                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 552                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 553                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 554                               res['network'][0]['node'][i]['supporting-node'])
 555                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
 556                 listNode.remove(nodeId)
 557             elif(nodeId == 'ROADM-A1-SRG3'):
 558                 # Test related to SRG1
 559                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 560                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 561                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 562                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 563                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 564                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 565                               res['network'][0]['node'][i]['supporting-node'])
 566                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
 567                 listNode.remove(nodeId)
 568             elif(nodeId == 'ROADM-A1-DEG1'):
 569                 # Test related to DEG1
 570                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 571                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 572                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 573                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 574                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 575                               res['network'][0]['node'][i]['supporting-node'])
 576                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 577                 listNode.remove(nodeId)
 578             elif(nodeId == 'ROADM-A1-DEG2'):
 579                 # Test related to DEG2
 580                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 581                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 582                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 583                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 584                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 585                               res['network'][0]['node'][i]['supporting-node'])
 586                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 587                 listNode.remove(nodeId)
 588             elif(nodeId == 'ROADM-C1-SRG1'):
 589                 # Test related to SRG1
 590                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 591                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 592                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 593                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 594                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 595                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 596                               res['network'][0]['node'][i]['supporting-node'])
 597                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'SRG')
 598                 listNode.remove(nodeId)
 599             elif(nodeId == 'ROADM-C1-DEG1'):
 600                 # Test related to DEG1
 601                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 602                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 603                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 604                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 605                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 606                               res['network'][0]['node'][i]['supporting-node'])
 607                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 608                 listNode.remove(nodeId)
 609             elif(nodeId == 'ROADM-C1-DEG2'):
 610                 # Test related to DEG1
 611                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 612                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 613                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 614                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 615                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'},
 616                               res['network'][0]['node'][i]['supporting-node'])
 617                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'DEGREE')
 618                 listNode.remove(nodeId)
 619             else:
 620                 self.assertFalse(True)
 621         self.assertEqual(len(listNode), 0)
 622
 623     def test_21_connect_ROADMB(self):
 624         response = test_utils.mount_device("ROADM-B1", 'roadmb')
 625         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 626
 627     def test_22_omsAttributes_ROADMA_ROADMB(self):
 628         # Config ROADM-A1-ROADM-B1 oms-attributes
 629         data = {"span": {
 630                 "auto-spanloss": "true",
 631                 "engineered-spanloss": 12.2,
 632                 "spanloss-current": 12,
 633                 "spanloss-base": 11.4,
 634                 "link-concatenation": [{
 635                     "SRLG-Id": 0,
 636                     "fiber-type": "smf",
 637                     "SRLG-length": 100000,
 638                     "pmd": 0.5}]}}
 639         response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
 640         self.assertEqual(response.status_code, requests.codes.created)
 641
 642     def test_23_omsAttributes_ROADMB_ROADMA(self):
 643         # Config ROADM-B1-ROADM-A1 oms-attributes
 644         data = {"span": {
 645                 "auto-spanloss": "true",
 646                 "engineered-spanloss": 12.2,
 647                 "spanloss-current": 12,
 648                 "spanloss-base": 11.4,
 649                 "link-concatenation": [{
 650                     "SRLG-Id": 0,
 651                     "fiber-type": "smf",
 652                     "SRLG-length": 100000,
 653                     "pmd": 0.5}]}}
 654         response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
 655         self.assertEqual(response.status_code, requests.codes.created)
 656
 657     def test_24_omsAttributes_ROADMB_ROADMC(self):
 658         # Config ROADM-B1-ROADM-C1 oms-attributes
 659         data = {"span": {
 660                 "auto-spanloss": "true",
 661                 "engineered-spanloss": 12.2,
 662                 "spanloss-current": 12,
 663                 "spanloss-base": 11.4,
 664                 "link-concatenation": [{
 665                     "SRLG-Id": 0,
 666                     "fiber-type": "smf",
 667                     "SRLG-length": 100000,
 668                     "pmd": 0.5}]}}
 669         response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
 670         self.assertEqual(response.status_code, requests.codes.created)
 671
 672     def test_25_omsAttributes_ROADMC_ROADMB(self):
 673         # Config ROADM-C1-ROADM-B1 oms-attributes
 674         data = {"span": {
 675                 "auto-spanloss": "true",
 676                 "engineered-spanloss": 12.2,
 677                 "link-concatenation": [{
 678                     "SRLG-Id": 0,
 679                     "fiber-type": "smf",
 680                     "SRLG-length": 100000,
 681                     "pmd": 0.5}]}}
 682         response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
 683         self.assertEqual(response.status_code, requests.codes.created)
 684
 685     def test_26_getClliNetwork(self):
 686         response = test_utils.get_clli_net_request()
 687         self.assertEqual(response.status_code, requests.codes.ok)
 688         res = response.json()
 689         nbNode = len(res['network'][0]['node'])
 690         listNode = ['NodeA', 'NodeB', 'NodeC']
 691         for i in range(0, nbNode):
 692             nodeId = res['network'][0]['node'][i]['node-id']
 693             find = nodeId in listNode
 694             self.assertEqual(find, True)
 695             if(nodeId == 'NodeA'):
 696                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
 697             elif(nodeId == 'NodeB'):
 698                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeB')
 699             else:
 700                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
 701             listNode.remove(nodeId)
 702         self.assertEqual(len(listNode), 0)
 703
 704     def test_27_verifyDegree(self):
 705         response = test_utils.get_ordm_topo_request("")
 706         self.assertEqual(response.status_code, requests.codes.ok)
 707         res = response.json()
 708         # Tests related to links
 709         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 710         listR2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 711                        'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX', 'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 712                        'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX', 'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
 713         for i in range(0, nbLink):
 714             if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
 715                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 716                 find = link_id in listR2RLink
 717                 self.assertEqual(find, True)
 718                 listR2RLink.remove(link_id)
 719         self.assertEqual(len(listR2RLink), 0)
 720
 721     def test_28_verifyOppositeLinkTopology(self):
 722         response = test_utils.get_ordm_topo_request("")
 723         self.assertEqual(response.status_code, requests.codes.ok)
 724         res = response.json()
 725         # Tests related to links
 726         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 727         self.assertEqual(nbLink, 26)
 728         for i in range(0, nbLink):
 729             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 730             link_type = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 731             link_src = res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
 732             link_dest = res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
 733             oppLink_id = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
 734             # Find the opposite link
 735             response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
 736             self.assertEqual(response_oppLink.status_code, requests.codes.ok)
 737             res_oppLink = response_oppLink.json()
 738             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]
 739                              ['org-openroadm-common-network:opposite-link'], link_id)
 740             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'], link_dest)
 741             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'], link_src)
 742             oppLink_type = res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
 743             if link_type == 'ADD-LINK':
 744                 self.assertEqual(oppLink_type, 'DROP-LINK')
 745             elif link_type == 'DROP-LINK':
 746                 self.assertEqual(oppLink_type, 'ADD-LINK')
 747             elif link_type == 'EXPRESS-LINK':
 748                 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
 749             elif link_type == 'ROADM-TO-ROADM':
 750                 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
 751             elif link_type == 'XPONDER-INPUT':
 752                 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
 753             elif link_type == 'XPONDER-OUTPUT':
 754                 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
 755
 756     def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
 757         response = test_utils.get_ordm_topo_request("")
 758         self.assertEqual(response.status_code, requests.codes.ok)
 759         res = response.json()
 760         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 761         R2RLink = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
 762                    'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
 763                    'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
 764                    'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
 765                    'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
 766                    'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX']
 767         for i in range(0, nbLink):
 768             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 769             link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 770             if(link_id in R2RLink):
 771                 find = False
 772                 spanLoss = res['network'][0]['ietf-network-topology:link'][i][
 773                     'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
 774                 length = res['network'][0]['ietf-network-topology:link'][i][
 775                     'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
 776                 if((spanLoss != None) & (length != None)):
 777                     find = True
 778                 self.assertTrue(find)
 779                 R2RLink.remove(link_id)
 780         self.assertEqual(len(R2RLink), 0)
 781
 782     def test_30_disconnect_ROADMB(self):
 783         # Delete in the topology-netconf
 784         response = test_utils.unmount_device("ROADM-B1")
 785         # Delete in the clli-network
 786         response = test_utils.del_node_request("NodeB")
 787         self.assertEqual(response.status_code, requests.codes.ok)
 788
 789     def test_31_disconnect_ROADMC(self):
 790         # Delete in the topology-netconf
 791         response = test_utils.unmount_device("ROADM-C1")
 792         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 793         # Delete in the clli-network
 794         response = test_utils.del_node_request("NodeC")
 795         self.assertEqual(response.status_code, requests.codes.ok)
 796
 797 #    def test_24_check_roadm2roadm_links_deletion(self):
 798 #        response = test_utils.get_ordm_topo_request("")
 799 #        self.assertEqual(response.status_code, requests.codes.ok)
 800 #        res = response.json()
 801 #        #Write the response in the log
 802 #        with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 803 #            outfile1.write(str(res))
 804 #        #Tests related to links
 805 #        nbLink=len(res['network'][0]['ietf-network-topology:link'])
 806 #        self.assertEqual(nbLink,8)
 807 #        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
 808 #        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
 809 #        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
 810 #        XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
 811 #        XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
 812 #        for i in range(0,nbLink):
 813 #            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 814 #            linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 815 #            if(nodeType=='EXPRESS-LINK'):
 816 #                find= linkId in expressLink
 817 #                self.assertEqual(find, True)
 818 #                expressLink.remove(linkId)
 819 #            elif(nodeType=='ADD-LINK'):
 820 #                find= linkId in addLink
 821 #                self.assertEqual(find, True)
 822 #                addLink.remove(linkId)
 823 #            elif(nodeType=='DROP-LINK'):
 824 #                find= linkId in dropLink
 825 #                self.assertEqual(find, True)
 826 #                dropLink.remove(linkId)
 827 #            elif(nodeType=='XPONDER-INPUT'):
 828 #                find= linkId in XPDR_IN
 829 #                self.assertEqual(find, True)
 830 #                XPDR_IN.remove(linkId)
 831 #            elif(nodeType=='XPONDER-OUTPUT'):
 832 #                find= linkId in XPDR_OUT
 833 #                self.assertEqual(find, True)
 834 #                XPDR_OUT.remove(linkId)
 835 #            else:
 836 #                self.assertFalse(True)
 837 #        self.assertEqual(len(expressLink),0)
 838 #        self.assertEqual(len(addLink),0)
 839 #        self.assertEqual(len(dropLink),0)
 840 #        self.assertEqual(len(XPDR_IN),0)
 841 #        self.assertEqual(len(XPDR_OUT),0)
 842 #
 843 #        for i in range(0,nbLink):
 844 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'ROADM-TO-ROADM')
 845 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 846 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 847 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
 848 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 849 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
 850 #            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 851
 852     def test_32_getNodes_OpenRoadmTopology(self):
 853         response = test_utils.get_ordm_topo_request("")
 854         res = response.json()
 855         # Tests related to nodes
 856         self.assertEqual(response.status_code, requests.codes.ok)
 857         nbNode = len(res['network'][0]['node'])
 858         self.assertEqual(nbNode, 5)
 859         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 860         for i in range(0, nbNode):
 861             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 862             nodeId = res['network'][0]['node'][i]['node-id']
 863             # Tests related to XPDRA nodes
 864             if(nodeId == 'XPDR-A1-XPDR1'):
 865                 nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 866                 for j in range(0, nbTp):
 867                     tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
 868                     if (tpid == 'XPDR1-CLIENT1'):
 869                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 870                                          ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
 871                     if (tpid == 'XPDR1-NETWORK1'):
 872                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 873                                          ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
 874                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
 875                                          ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
 876                                          'ROADM-A1-SRG1--SRG1-PP1-TXRX')
 877                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
 878                               res['network'][0]['node'][i]['supporting-node'])
 879                 listNode.remove(nodeId)
 880             elif(nodeId == 'ROADM-A1-SRG1'):
 881                 # Test related to SRG1
 882                 self.assertEqual(nodeType, 'SRG')
 883                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 884                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 885                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 886                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 887                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 888                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 889                               res['network'][0]['node'][i]['supporting-node'])
 890                 listNode.remove(nodeId)
 891             elif(nodeId == 'ROADM-A1-SRG3'):
 892                 # Test related to SRG1
 893                 self.assertEqual(nodeType, 'SRG')
 894                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 895                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 896                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 897                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 898                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 899                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 900                               res['network'][0]['node'][i]['supporting-node'])
 901                 listNode.remove(nodeId)
 902             elif(nodeId == 'ROADM-A1-DEG1'):
 903                 # Test related to DEG1
 904                 self.assertEqual(nodeType, 'DEGREE')
 905                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 906                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 907                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 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-DEG2'):
 913                 # Test related to DEG2
 914                 self.assertEqual(nodeType, 'DEGREE')
 915                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 916                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 917                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 918                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 919                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 920                               res['network'][0]['node'][i]['supporting-node'])
 921                 listNode.remove(nodeId)
 922             else:
 923                 self.assertFalse(True)
 924         self.assertEqual(len(listNode), 0)
 925         # Test related to SRG1 of ROADMC
 926         for i in range(0, nbNode):
 927             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-SRG1')
 928             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG1')
 929             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1-DEG2')
 930
 931     def test_33_getOpenRoadmNetwork(self):
 932         response = test_utils.get_ordm_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, 2)
 937         for i in range(0, nbNode-1):
 938             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-C1')
 939             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADM-B1')
 940
 941     def test_34_getClliNetwork(self):
 942         response = test_utils.get_clli_net_request()
 943         self.assertEqual(response.status_code, requests.codes.ok)
 944         res = response.json()
 945         nbNode = len(res['network'][0]['node'])
 946         self.assertEqual(nbNode, 1)
 947         for i in range(0, nbNode-1):
 948             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
 949
 950     def test_35_disconnect_XPDRA(self):
 951         response = test_utils.unmount_device("XPDR-A1")
 952         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 953
 954     def test_36_getClliNetwork(self):
 955         response = test_utils.get_clli_net_request()
 956         self.assertEqual(response.status_code, requests.codes.ok)
 957         res = response.json()
 958         nbNode = len(res['network'][0]['node'])
 959         self.assertEqual(nbNode, 1)
 960         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 961
 962     def test_37_getOpenRoadmNetwork(self):
 963         response = test_utils.get_ordm_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):
 969             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDR-A1')
 970
 971     def test_38_getNodes_OpenRoadmTopology(self):
 972         response = test_utils.get_ordm_topo_request("")
 973         res = response.json()
 974         # Tests related to nodes
 975         self.assertEqual(response.status_code, requests.codes.ok)
 976         nbNode = len(res['network'][0]['node'])
 977         self.assertEqual(nbNode, 4)
 978         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
 979         for i in range(0, nbNode):
 980             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
 981                           res['network'][0]['node'][i]['supporting-node'])
 982             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 983             nodeId = res['network'][0]['node'][i]['node-id']
 984             if(nodeId == 'ROADM-A1-SRG1'):
 985                 # Test related to SRG1
 986                 self.assertEqual(nodeType, 'SRG')
 987                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 988                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 989                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 990                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 991                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 992                 listNode.remove(nodeId)
 993             elif(nodeId == 'ROADM-A1-SRG3'):
 994                 # Test related to SRG1
 995                 self.assertEqual(nodeType, 'SRG')
 996                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 5)
 997                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 998                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 999                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
1000                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1001                 listNode.remove(nodeId)
1002             elif(nodeId == 'ROADM-A1-DEG1'):
1003                 # Test related to DEG1
1004                 self.assertEqual(nodeType, 'DEGREE')
1005                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1006                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1007                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1008                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1009                 listNode.remove(nodeId)
1010             elif(nodeId == 'ROADM-A1-DEG2'):
1011                 # Test related to DEG2
1012                 self.assertEqual(nodeType, 'DEGREE')
1013                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
1014                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1015                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
1016                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
1017                 listNode.remove(nodeId)
1018             else:
1019                 self.assertFalse(True)
1020         self.assertEqual(len(listNode), 0)
1021
1022     def test_39_disconnect_ROADM_XPDRA_link(self):
1023         # Link-1
1024         response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
1025         self.assertEqual(response.status_code, requests.codes.ok)
1026         # Link-2
1027         response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
1028         self.assertEqual(response.status_code, requests.codes.ok)
1029
1030     def test_40_getLinks_OpenRoadmTopology(self):
1031         response = test_utils.get_ordm_topo_request("")
1032         self.assertEqual(response.status_code, requests.codes.ok)
1033         res = response.json()
1034         nbLink = len(res['network'][0]['ietf-network-topology:link'])
1035         self.assertEqual(nbLink, 16)
1036         expressLink = ['ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1037                        'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX']
1038         addLink = ['ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX',
1039                    'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX', 'ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX']
1040         dropLink = ['ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX',
1041                     'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX', 'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
1042         roadmtoroadmLink = 0
1043         for i in range(0, nbLink):
1044             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
1045                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1046                 find = link_id in expressLink
1047                 self.assertEqual(find, True)
1048                 expressLink.remove(link_id)
1049             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
1050                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1051                 find = link_id in addLink
1052                 self.assertEqual(find, True)
1053                 addLink.remove(link_id)
1054             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
1055                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
1056                 find = link_id in dropLink
1057                 self.assertEqual(find, True)
1058                 dropLink.remove(link_id)
1059             else:
1060                 roadmtoroadmLink += 1
1061         self.assertEqual(len(expressLink), 0)
1062         self.assertEqual(len(addLink), 0)
1063         self.assertEqual(len(dropLink), 0)
1064         self.assertEqual(roadmtoroadmLink, 6)
1065         for i in range(0, nbLink):
1066             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1067                                 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
1068             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
1069                                 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
1070
1071     def test_41_disconnect_ROADMA(self):
1072         response = test_utils.unmount_device("ROADM-A1")
1073         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
1074         # Delete in the clli-network
1075         response = test_utils.del_node_request("NodeA")
1076         self.assertEqual(response.status_code, requests.codes.ok)
1077
1078     def test_42_getClliNetwork(self):
1079         response = test_utils.get_clli_net_request()
1080         self.assertEqual(response.status_code, requests.codes.ok)
1081         res = response.json()
1082         self.assertNotIn('node', res['network'][0])
1083
1084     def test_43_getOpenRoadmNetwork(self):
1085         response = test_utils.get_ordm_net_request()
1086         self.assertEqual(response.status_code, requests.codes.ok)
1087         res = response.json()
1088         self.assertNotIn('node', res['network'][0])
1089
1090     def test_44_check_roadm2roadm_link_persistence(self):
1091         response = test_utils.get_ordm_topo_request("")
1092         self.assertEqual(response.status_code, requests.codes.ok)
1093         res = response.json()
1094         nbLink = len(res['network'][0]['ietf-network-topology:link'])
1095         self.assertNotIn('node', res['network'][0])
1096         self.assertEqual(nbLink, 6)
1097
1098
1099 if __name__ == "__main__":
1100     unittest.main(verbosity=2)