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