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