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         url = "{}/config/ietf-network:networks/network/openroadm-network"
  50         response = test_utils.get_request(url)
  51         self.assertEqual(response.status_code, requests.codes.ok)
  52         res = response.json()
  53         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'ROADMA01')
  54         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'], 'clli-network')
  55         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'], 'NodeA')
  56         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'], 'ROADM')
  57         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'], '2')
  58
  59     def test_04_getLinks_OpenroadmTopology(self):
  60         response = test_utils.get_ordm_topo_request("")
  61         self.assertEqual(response.status_code, requests.codes.ok)
  62         res = response.json()
  63         # Tests related to links
  64         nbLink = len(res['network'][0]['ietf-network-topology:link'])
  65         self.assertEqual(nbLink, 10)
  66         expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
  67                        'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
  68         addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
  69                    'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
  70         dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
  71                     'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
  72         for i in range(0, nbLink):
  73             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
  74             if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK':
  75                 find = linkId in expressLink
  76                 self.assertEqual(find, True)
  77                 expressLink.remove(linkId)
  78             elif res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK':
  79                 find = linkId in addLink
  80                 self.assertEqual(find, True)
  81                 addLink.remove(linkId)
  82             elif res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK':
  83                 find = linkId in dropLink
  84                 self.assertEqual(find, True)
  85                 dropLink.remove(linkId)
  86             else:
  87                 self.assertFalse(True)
  88         self.assertEqual(len(expressLink), 0)
  89         self.assertEqual(len(addLink), 0)
  90         self.assertEqual(len(dropLink), 0)
  91
  92     def test_05_getNodes_OpenRoadmTopology(self):
  93         response = test_utils.get_ordm_topo_request("")
  94         res = response.json()
  95         # Tests related to nodes
  96         self.assertEqual(response.status_code, requests.codes.ok)
  97         nbNode = len(res['network'][0]['node'])
  98         self.assertEqual(nbNode, 4)
  99         listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
 100         for i in range(0, nbNode):
 101             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 102                           res['network'][0]['node'][i]['supporting-node'])
 103             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 104             nodeId = res['network'][0]['node'][i]['node-id']
 105             if nodeId == 'ROADMA01-SRG1':
 106                 # Test related to SRG1
 107                 self.assertEqual(nodeType, 'SRG')
 108                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
 109                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 110                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 111                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 112                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 113                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 114                               res['network'][0]['node'][i]['supporting-node'])
 115                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 116                               res['network'][0]['node'][i]['supporting-node'])
 117                 listNode.remove(nodeId)
 118             elif nodeId == 'ROADMA01-SRG3':
 119                 # Test related to SRG1
 120                 self.assertEqual(nodeType, 'SRG')
 121                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
 122                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 123                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 124                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 125                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 126                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 127                               res['network'][0]['node'][i]['supporting-node'])
 128                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 129                               res['network'][0]['node'][i]['supporting-node'])
 130                 listNode.remove(nodeId)
 131             elif nodeId == 'ROADMA01-DEG1':
 132                 # Test related to DEG1
 133                 self.assertEqual(nodeType, 'DEGREE')
 134                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 135                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 136                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 137                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 138                 listNode.remove(nodeId)
 139                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 140                               res['network'][0]['node'][i]['supporting-node'])
 141                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 142                               res['network'][0]['node'][i]['supporting-node'])
 143             elif nodeId == 'ROADMA01-DEG2':
 144                 # Test related to DEG2
 145                 self.assertEqual(nodeType, 'DEGREE')
 146                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 147                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 148                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 149                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 150                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 151                               res['network'][0]['node'][i]['supporting-node'])
 152                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 153                               res['network'][0]['node'][i]['supporting-node'])
 154                 listNode.remove(nodeId)
 155             else:
 156                 self.assertFalse(True)
 157         self.assertEqual(len(listNode), 0)
 158
 159     def test_06_connect_XPDRA(self):
 160         response = test_utils.mount_device("XPDRA01", 'xpdra')
 161         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 162
 163     def test_07_getClliNetwork(self):
 164         response = test_utils.get_clli_net_request()
 165         self.assertEqual(response.status_code, requests.codes.ok)
 166         res = response.json()
 167         self.assertEqual(res['network'][0]['node'][0]['node-id'], 'NodeA')
 168         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 169
 170     def test_08_getOpenRoadmNetwork(self):
 171         url = "{}/config/ietf-network:networks/network/openroadm-network"
 172         response = test_utils.get_request(url)
 173         self.assertEqual(response.status_code, requests.codes.ok)
 174         res = response.json()
 175         nbNode = len(res['network'][0]['node'])
 176         self.assertEqual(nbNode, 2)
 177         for i in range(0, nbNode):
 178             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'], 'clli-network')
 179             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'], 'NodeA')
 180             nodeId = res['network'][0]['node'][i]['node-id']
 181             if(nodeId == 'XPDRA01'):
 182                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'XPONDER')
 183                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '1')
 184             elif(nodeId == 'ROADMA01'):
 185                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'], 'ROADM')
 186                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'], '2')
 187             else:
 188                 self.assertFalse(True)
 189
 190     def test_09_getNodes_OpenRoadmTopology(self):
 191         response = test_utils.get_ordm_topo_request("")
 192         res = response.json()
 193         # Tests related to nodes
 194         self.assertEqual(response.status_code, requests.codes.ok)
 195         nbNode = len(res['network'][0]['node'])
 196         self.assertEqual(nbNode, 5)
 197         listNode = ['XPDRA01-XPDR1', 'ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
 198         for i in range(0, nbNode):
 199             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 200             nodeId = res['network'][0]['node'][i]['node-id']
 201             # Tests related to XPDRA nodes
 202             if(nodeId == 'XPDRA01-XPDR1'):
 203                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
 204                               res['network'][0]['node'][i]['supporting-node'])
 205                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
 206                               res['network'][0]['node'][i]['supporting-node'])
 207                 self.assertEqual(nodeType, 'XPONDER')
 208                 nbTps = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 209                 client = 0
 210                 network = 0
 211                 for j in range(0, nbTps):
 212                     tpType = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
 213                     tpId = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
 214                     if (tpType == 'XPONDER-CLIENT'):
 215                         client += 1
 216                     elif (tpType == 'XPONDER-NETWORK'):
 217                         network += 1
 218                     if (tpId == 'XPDR1-NETWORK2'):
 219                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
 220                                          [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT3')
 221                     if (tpId == 'XPDR1-CLIENT3'):
 222                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point']
 223                                          [j]['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
 224                 self.assertTrue(client == 4)
 225                 self.assertTrue(network == 2)
 226                 listNode.remove(nodeId)
 227             elif(nodeId == 'ROADMA01-SRG1'):
 228                 # Test related to SRG1
 229                 self.assertEqual(nodeType, 'SRG')
 230                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
 231                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 232                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 233                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 234                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 235                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 236                               res['network'][0]['node'][i]['supporting-node'])
 237                 listNode.remove(nodeId)
 238             elif(nodeId == 'ROADMA01-SRG3'):
 239                 # Test related to SRG1
 240                 self.assertEqual(nodeType, 'SRG')
 241                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
 242                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 243                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 244                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 245                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 246                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 247                               res['network'][0]['node'][i]['supporting-node'])
 248                 listNode.remove(nodeId)
 249             elif(nodeId == 'ROADMA01-DEG1'):
 250                 # Test related to DEG1
 251                 self.assertEqual(nodeType, 'DEGREE')
 252                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 253                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 254                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 255                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 256                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 257                               res['network'][0]['node'][i]['supporting-node'])
 258                 listNode.remove(nodeId)
 259             elif(nodeId == 'ROADMA01-DEG2'):
 260                 # Test related to DEG2
 261                 self.assertEqual(nodeType, 'DEGREE')
 262                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 263                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 264                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 265                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 266                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 267                               res['network'][0]['node'][i]['supporting-node'])
 268                 listNode.remove(nodeId)
 269             else:
 270                 self.assertFalse(True)
 271         self.assertEqual(len(listNode), 0)
 272
 273     # Connect the tail XPDRA to ROADMA and vice versa
 274     def test_10_connect_tail_xpdr_rdm(self):
 275         # Connect the tail: XPDRA to ROADMA
 276         response = test_utils.connect_xpdr_to_rdm_request("XPDRA01", "1", "1",
 277                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
 278         self.assertEqual(response.status_code, requests.codes.ok)
 279
 280     def test_11_connect_tail_rdm_xpdr(self):
 281         # Connect the tail: ROADMA to XPDRA
 282         response = test_utils.connect_rdm_to_xpdr_request("XPDRA01", "1", "1",
 283                                                           "ROADMA01", "1", "SRG1-PP1-TXRX")
 284         self.assertEqual(response.status_code, requests.codes.ok)
 285
 286     def test_12_getLinks_OpenRoadmTopology(self):
 287         response = test_utils.get_ordm_topo_request("")
 288         self.assertEqual(response.status_code, requests.codes.ok)
 289         res = response.json()
 290         # Tests related to links
 291         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 292         self.assertEqual(nbLink, 12)
 293         expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
 294                        'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
 295         addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
 296                    'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
 297         dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
 298                     'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
 299         XPDR_IN = ['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
 300         XPDR_OUT = ['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
 301         for i in range(0, nbLink):
 302             nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
 303             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 304             if(nodeType == 'EXPRESS-LINK'):
 305                 find = linkId in expressLink
 306                 self.assertEqual(find, True)
 307                 expressLink.remove(linkId)
 308             elif(nodeType == 'ADD-LINK'):
 309                 find = linkId in addLink
 310                 self.assertEqual(find, True)
 311                 addLink.remove(linkId)
 312             elif(nodeType == 'DROP-LINK'):
 313                 find = linkId in dropLink
 314                 self.assertEqual(find, True)
 315                 dropLink.remove(linkId)
 316             elif(nodeType == 'XPONDER-INPUT'):
 317                 find = linkId in XPDR_IN
 318                 self.assertEqual(find, True)
 319                 XPDR_IN.remove(linkId)
 320             elif(nodeType == 'XPONDER-OUTPUT'):
 321                 find = linkId in XPDR_OUT
 322                 self.assertEqual(find, True)
 323                 XPDR_OUT.remove(linkId)
 324             else:
 325                 self.assertFalse(True)
 326         self.assertEqual(len(expressLink), 0)
 327         self.assertEqual(len(addLink), 0)
 328         self.assertEqual(len(dropLink), 0)
 329         self.assertEqual(len(XPDR_IN), 0)
 330         self.assertEqual(len(XPDR_OUT), 0)
 331
 332     def test_13_connect_ROADMC(self):
 333         response = test_utils.mount_device("ROADMC01", 'roadmc')
 334         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 335
 336     def test_14_omsAttributes_ROADMA_ROADMC(self):
 337         # Config ROADMA01-ROADMC01 oms-attributes
 338         data = {"span": {
 339             "auto-spanloss": "true",
 340             "engineered-spanloss": 12.2,
 341             "link-concatenation": [{
 342                 "SRLG-Id": 0,
 343                 "fiber-type": "smf",
 344                 "SRLG-length": 100000,
 345                 "pmd": 0.5}]}}
 346         response = test_utils.add_oms_attr_request("ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX", data)
 347         self.assertEqual(response.status_code, requests.codes.created)
 348
 349     def test_15_omsAttributes_ROADMC_ROADMA(self):
 350         # Config ROADMC01-ROADMA oms-attributes
 351         data = {"span": {
 352             "auto-spanloss": "true",
 353             "engineered-spanloss": 12.2,
 354             "link-concatenation": [{
 355                 "SRLG-Id": 0,
 356                 "fiber-type": "smf",
 357                 "SRLG-length": 100000,
 358                 "pmd": 0.5}]}}
 359         response = test_utils.add_oms_attr_request("ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX", data)
 360         self.assertEqual(response.status_code, requests.codes.created)
 361
 362     def test_16_getClliNetwork(self):
 363         response = test_utils.get_clli_net_request()
 364         self.assertEqual(response.status_code, requests.codes.ok)
 365         res = response.json()
 366         nbNode = len(res['network'][0]['node'])
 367         listNode = ['NodeA', 'NodeC']
 368         for i in range(0, nbNode):
 369             nodeId = res['network'][0]['node'][i]['node-id']
 370             find = nodeId in listNode
 371             self.assertEqual(find, True)
 372             if(nodeId == 'NodeA'):
 373                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeA')
 374             else:
 375                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'], 'NodeC')
 376             listNode.remove(nodeId)
 377
 378         self.assertEqual(len(listNode), 0)
 379
 380     def test_17_getOpenRoadmNetwork(self):
 381         url = "{}/config/ietf-network:networks/network/openroadm-network"
 382         response = test_utils.get_request(url)
 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         url = "{}/config/ietf-network:networks/network/openroadm-network"
 846         response = test_utils.get_request(url)
 847         self.assertEqual(response.status_code, requests.codes.ok)
 848         res = response.json()
 849         nbNode = len(res['network'][0]['node'])
 850         self.assertEqual(nbNode, 2)
 851         for i in range(0, nbNode-1):
 852             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMC01')
 853             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'ROADMB01')
 854
 855     def test_34_getClliNetwork(self):
 856         response = test_utils.get_clli_net_request()
 857         self.assertEqual(response.status_code, requests.codes.ok)
 858         res = response.json()
 859         nbNode = len(res['network'][0]['node'])
 860         self.assertEqual(nbNode, 1)
 861         for i in range(0, nbNode-1):
 862             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'], 'NodeC')
 863
 864     def test_35_disconnect_XPDRA(self):
 865         response = test_utils.unmount_device("XPDRA01")
 866         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 867
 868     def test_36_getClliNetwork(self):
 869         response = test_utils.get_clli_net_request()
 870         self.assertEqual(response.status_code, requests.codes.ok)
 871         res = response.json()
 872         nbNode = len(res['network'][0]['node'])
 873         self.assertEqual(nbNode, 1)
 874         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'], 'NodeA')
 875
 876     def test_37_getOpenRoadmNetwork(self):
 877         url = ("{}/config/ietf-network:networks/network/openroadm-network"
 878                )
 879         response = test_utils.get_request(url)
 880         self.assertEqual(response.status_code, requests.codes.ok)
 881         res = response.json()
 882         nbNode = len(res['network'][0]['node'])
 883         self.assertEqual(nbNode, 1)
 884         for i in range(0, nbNode):
 885             self.assertNotEqual(res['network'][0]['node'][i]['node-id'], 'XPDRA01')
 886
 887     def test_38_getNodes_OpenRoadmTopology(self):
 888         response = test_utils.get_ordm_topo_request("")
 889         res = response.json()
 890         # Tests related to nodes
 891         self.assertEqual(response.status_code, requests.codes.ok)
 892         nbNode = len(res['network'][0]['node'])
 893         self.assertEqual(nbNode, 4)
 894         listNode = ['ROADMA01-SRG1', 'ROADMA01-SRG3', 'ROADMA01-DEG1', 'ROADMA01-DEG2']
 895         for i in range(0, nbNode):
 896             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
 897                           res['network'][0]['node'][i]['supporting-node'])
 898             nodeType = res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
 899             nodeId = res['network'][0]['node'][i]['node-id']
 900             if(nodeId == 'ROADMA01-SRG1'):
 901                 # Test related to SRG1
 902                 self.assertEqual(nodeType, 'SRG')
 903                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
 904                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 905                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 906                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 907                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 908                 listNode.remove(nodeId)
 909             elif(nodeId == 'ROADMA01-SRG3'):
 910                 # Test related to SRG1
 911                 self.assertEqual(nodeType, 'SRG')
 912                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']), 17)
 913                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
 914                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 915                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
 916                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 917                 listNode.remove(nodeId)
 918             elif(nodeId == 'ROADMA01-DEG1'):
 919                 # Test related to DEG1
 920                 self.assertEqual(nodeType, 'DEGREE')
 921                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 922                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 923                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 924                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 925                 listNode.remove(nodeId)
 926             elif(nodeId == 'ROADMA01-DEG2'):
 927                 # Test related to DEG2
 928                 self.assertEqual(nodeType, 'DEGREE')
 929                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
 930                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 931                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
 932                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
 933                 listNode.remove(nodeId)
 934             else:
 935                 self.assertFalse(True)
 936         self.assertEqual(len(listNode), 0)
 937
 938     def test_39_disconnect_ROADM_XPDRA_link(self):
 939         # Link-1
 940         response = test_utils.del_link_request("XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX")
 941         self.assertEqual(response.status_code, requests.codes.ok)
 942         # Link-2
 943         response = test_utils.del_link_request("ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1")
 944         self.assertEqual(response.status_code, requests.codes.ok)
 945
 946     def test_40_getLinks_OpenRoadmTopology(self):
 947         response = test_utils.get_ordm_topo_request("")
 948         self.assertEqual(response.status_code, requests.codes.ok)
 949         res = response.json()
 950         nbLink = len(res['network'][0]['ietf-network-topology:link'])
 951         self.assertEqual(nbLink, 16)
 952         expressLink = ['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
 953                        'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
 954         addLink = ['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
 955                    'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX', 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
 956         dropLink = ['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
 957                     'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX', 'ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
 958         roadmtoroadmLink = 0
 959         for i in range(0, nbLink):
 960             if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'EXPRESS-LINK'):
 961                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 962                 find = link_id in expressLink
 963                 self.assertEqual(find, True)
 964                 expressLink.remove(link_id)
 965             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ADD-LINK'):
 966                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 967                 find = link_id in addLink
 968                 self.assertEqual(find, True)
 969                 addLink.remove(link_id)
 970             elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'DROP-LINK'):
 971                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 972                 find = link_id in dropLink
 973                 self.assertEqual(find, True)
 974                 dropLink.remove(link_id)
 975             else:
 976                 roadmtoroadmLink += 1
 977         self.assertEqual(len(expressLink), 0)
 978         self.assertEqual(len(addLink), 0)
 979         self.assertEqual(len(dropLink), 0)
 980         self.assertEqual(roadmtoroadmLink, 6)
 981         for i in range(0, nbLink):
 982             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
 983                                 ['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
 984             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]
 985                                 ['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
 986
 987     def test_41_disconnect_ROADMA(self):
 988         response = test_utils.unmount_device("ROADMA01")
 989         self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
 990         # Delete in the clli-network
 991         response = test_utils.del_node_request("NodeA")
 992         self.assertEqual(response.status_code, requests.codes.ok)
 993
 994     def test_42_getClliNetwork(self):
 995         response = test_utils.get_clli_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_43_getOpenRoadmNetwork(self):
1001         url = "{}/config/ietf-network:networks/network/openroadm-network"
1002         response = test_utils.get_request(url)
1003         self.assertEqual(response.status_code, requests.codes.ok)
1004         res = response.json()
1005         self.assertNotIn('node', res['network'][0])
1006
1007     def test_44_check_roadm2roadm_link_persistence(self):
1008         response = test_utils.get_ordm_topo_request("")
1009         self.assertEqual(response.status_code, requests.codes.ok)
1010         res = response.json()
1011         nbLink = len(res['network'][0]['ietf-network-topology:link'])
1012         self.assertNotIn('node', res['network'][0])
1013         self.assertEqual(nbLink, 6)
1014
1015
1016 if __name__ == "__main__":
1017     unittest.main(verbosity=2)