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