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