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