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