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