tests/transportpce_tests/2.2.1/test_topology.py

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