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