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