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