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