tests/transportpce_tests/1.2.1/test_topology.py

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