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