tests/transportpce_tests/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
  23 class TransportPCEtesting(unittest.TestCase):
  24
  25     testtools_process1 = None
  26     testtools_process2 = None
  27     testtools_process3 = None
  28     testtools_process4 = None
  29     odl_process = None
  30     restconf_baseurl = "http://localhost:8181/restconf"
  31
  32     @classmethod
  33     def __start_testtools(cls):
  34         executable = ("./netconf/netconf/tools/netconf-testtool/target/"
  35                       "netconf-testtool-1.3.1-executable.jar")
  36         if os.path.isfile(executable):
  37             if not os.path.exists("transportpce_tests/log"):
  38                 os.makedirs("transportpce_tests/log")
  39             if os.path.isfile("./transportpce_tests/log/response.log"):
  40                 os.remove("transportpce_tests/log/response.log")
  41             with open('transportpce_tests/log/testtools_ROADMA.log', 'w') as outfile1:
  42                 cls.testtools_process1 = subprocess.Popen(
  43                     ["java", "-jar", executable, "--schemas-dir", "schemas",
  44                      "--initial-config-xml", "sample_configs/nodes_config/sample-config-ROADMA.xml","--starting-port","17831"],
  45                     stdout=outfile1)
  46             with open('transportpce_tests/log/testtools_ROADMB.log', 'w') as outfile2:
  47                 cls.testtools_process2 = subprocess.Popen(
  48                     ["java", "-jar", executable, "--schemas-dir", "schemas",
  49                      "--initial-config-xml", "sample_configs/nodes_config/sample-config-ROADMB.xml","--starting-port","17832"],
  50                     stdout=outfile2)
  51             with open('transportpce_tests/log/testtools_ROADMC.log', 'w') as outfile3:
  52                 cls.testtools_process3 = subprocess.Popen(
  53                     ["java", "-jar", executable, "--schemas-dir", "schemas",
  54                      "--initial-config-xml", "sample_configs/nodes_config/sample-config-ROADMC.xml","--starting-port","17833"],
  55                     stdout=outfile3)
  56             with open('transportpce_tests/log/testtools_XPDRA.log', 'w') as outfile4:
  57                 cls.testtools_process4 = subprocess.Popen(
  58                     ["java", "-jar", executable, "--schemas-dir", "schemas",
  59                      "--initial-config-xml", "sample_configs/nodes_config/sample-config-XPDRA.xml","--starting-port","17830"],
  60                     stdout=outfile4)
  61
  62     @classmethod
  63     def __start_odl(cls):
  64         executable = "../karaf/target/assembly/bin/karaf"
  65         with open('transportpce_tests/log/odl.log', 'w') as outfile:
  66             cls.odl_process = subprocess.Popen(
  67                 ["bash", executable], stdout=outfile,
  68                 stdin=open(os.devnull))
  69
  70     @classmethod
  71     def setUpClass(cls):
  72         cls.__start_testtools()
  73         cls.__start_odl()
  74         time.sleep(60)
  75
  76     @classmethod
  77     def tearDownClass(cls):
  78         cls.testtools_process1.send_signal(signal.SIGINT)
  79         cls.testtools_process1.wait()
  80         cls.testtools_process2.send_signal(signal.SIGINT)
  81         cls.testtools_process2.wait()
  82         cls.testtools_process3.send_signal(signal.SIGINT)
  83         cls.testtools_process3.wait()
  84         cls.testtools_process4.send_signal(signal.SIGINT)
  85         cls.testtools_process4.wait()
  86         for child in psutil.Process(cls.odl_process.pid).children():
  87             child.send_signal(signal.SIGINT)
  88             child.wait()
  89         cls.odl_process.send_signal(signal.SIGINT)
  90         cls.odl_process.wait()
  91         print('End of the tear down class')
  92
  93     def setUp(self):
  94         time.sleep(10)
  95
  96     def test_01_connect_ROADMA(self):
  97         #Config ROADMA
  98         url = ("{}/config/network-topology:"
  99                 "network-topology/topology/topology-netconf/node/ROADMA"
 100                .format(self.restconf_baseurl))
 101         data = {"node": [{
 102              "node-id": "ROADMA",
 103              "netconf-node-topology:username": "admin",
 104              "netconf-node-topology:password": "admin",
 105              "netconf-node-topology:host": "127.0.0.1",
 106              "netconf-node-topology:port": "17831",
 107              "netconf-node-topology:tcp-only": "false",
 108              "netconf-node-topology:pass-through": {}}]}
 109         headers = {'content-type': 'application/json'}
 110         response = requests.request(
 111              "PUT", url, data=json.dumps(data), headers=headers,
 112              auth=('admin', 'admin'))
 113         self.assertEqual(response.status_code, requests.codes.created)
 114         time.sleep(30)
 115
 116     def test_02_getClliNetwork(self):
 117         url = ("{}/config/ietf-network:network/clli-network"
 118               .format(self.restconf_baseurl))
 119         headers = {'content-type': 'application/json'}
 120         response = requests.request(
 121             "GET", url, headers=headers, auth=('admin', 'admin'))
 122         self.assertEqual(response.status_code, requests.codes.ok)
 123         res = response.json()
 124         self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
 125         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
 126
 127     def test_03_getOpenRoadmNetwork(self):
 128         url = ("{}/config/ietf-network:network/openroadm-network"
 129               .format(self.restconf_baseurl))
 130         headers = {'content-type': 'application/json'}
 131         response = requests.request(
 132             "GET", url, headers=headers, auth=('admin', 'admin'))
 133         self.assertEqual(response.status_code, requests.codes.ok)
 134         res = response.json()
 135         self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA')
 136         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
 137         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
 138         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:node-type'],'ROADM')
 139         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'2')
 140
 141     def test_04_getLinks_OpenroadmTopology(self):
 142         url = ("{}/config/ietf-network:network/openroadm-topology"
 143               .format(self.restconf_baseurl))
 144         headers = {'content-type': 'application/json'}
 145         response = requests.request(
 146             "GET", url, headers=headers, auth=('admin', 'admin'))
 147         self.assertEqual(response.status_code, requests.codes.ok)
 148         res = response.json()
 149         #Tests related to links
 150         self.assertEqual(len(res['network'][0]['ietf-network-topology:link']),6)
 151         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 152         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 153         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 154         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 155         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 156         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 157         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 158         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 159         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 160         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 161         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 162         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 163         time.sleep(1)
 164
 165     def test_05_getNodes_OpenRoadmTopology(self):
 166         url = ("{}/config/ietf-network:network/openroadm-topology"
 167               .format(self.restconf_baseurl))
 168         headers = {'content-type': 'application/json'}
 169         response = requests.request(
 170             "GET", url, headers=headers, auth=('admin', 'admin'))
 171         res = response.json()
 172         #Tests related to nodes
 173         self.assertEqual(response.status_code, requests.codes.ok)
 174         with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 175             outfile1.write(str(len(res['network'][0]['node'])))
 176         self.assertEqual(len(res['network'][0]['node']),3)
 177         #Tests related to nodes
 178         #Test related to SRG1
 179         self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA-SRG1')
 180         #failed tests
 181         self.assertEqual(len(res['network'][0]['node'][0]['ietf-network-topology:termination-point']),17)
 182         self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 183             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 184         self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 185             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 186         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 187             res['network'][0]['node'][0]['supporting-node'])
 188         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network-topology:node-type'],'SRG')
 189         #Test related to DEG2
 190         self.assertEqual(res['network'][0]['node'][1]['node-id'],'ROADMA-DEG2')
 191         self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 192             res['network'][0]['node'][1]['ietf-network-topology:termination-point'])
 193         self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 194             res['network'][0]['node'][1]['ietf-network-topology:termination-point'])
 195         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 196             res['network'][0]['node'][1]['supporting-node'])
 197         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network-topology:node-type'],'DEGREE')
 198         #Test related to DEG1
 199         self.assertEqual(res['network'][0]['node'][2]['node-id'],'ROADMA-DEG1')
 200         self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 201             res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 202         self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 203             res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 204         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 205             res['network'][0]['node'][2]['supporting-node'])
 206         self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network-topology:node-type'],'DEGREE')
 207
 208     def test_06_connect_XPDRA(self):
 209          url = ("{}/config/network-topology:"
 210                  "network-topology/topology/topology-netconf/node/XPDRA"
 211                 .format(self.restconf_baseurl))
 212          data = {"node": [{
 213               "node-id": "XPDRA",
 214               "netconf-node-topology:username": "admin",
 215               "netconf-node-topology:password": "admin",
 216               "netconf-node-topology:host": "127.0.0.1",
 217               "netconf-node-topology:port": "17830",
 218               "netconf-node-topology:tcp-only": "false",
 219               "netconf-node-topology:pass-through": {}}]}
 220          headers = {'content-type': 'application/json'}
 221          response = requests.request(
 222               "PUT", url, data=json.dumps(data), headers=headers,
 223               auth=('admin', 'admin'))
 224          self.assertEqual(response.status_code, requests.codes.created)
 225          time.sleep(30)
 226
 227     def test_07_getClliNetwork(self):
 228          url = ("{}/config/ietf-network:network/clli-network"
 229                .format(self.restconf_baseurl))
 230          headers = {'content-type': 'application/json'}
 231          response = requests.request(
 232              "GET", url, headers=headers, auth=('admin', 'admin'))
 233          self.assertEqual(response.status_code, requests.codes.ok)
 234          res = response.json()
 235          self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeA')
 236          self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
 237
 238     def test_08_getOpenRoadmNetwork(self):
 239          url = ("{}/config/ietf-network:network/openroadm-network"
 240                .format(self.restconf_baseurl))
 241          headers = {'content-type': 'application/json'}
 242          response = requests.request(
 243              "GET", url, headers=headers, auth=('admin', 'admin'))
 244          self.assertEqual(response.status_code, requests.codes.ok)
 245          res = response.json()
 246          nbNode=len(res['network'][0]['node'])
 247          self.assertEqual(nbNode,2)
 248          self.assertEqual(res['network'][0]['node'][0]['node-id'],'XPDRA')
 249          self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
 250          self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
 251          self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:node-type'],'XPONDER')
 252          self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'1')
 253
 254     def test_09_getNodes_OpenRoadmTopology(self):
 255          url = ("{}/config/ietf-network:network/openroadm-topology"
 256                .format(self.restconf_baseurl))
 257          headers = {'content-type': 'application/json'}
 258          response = requests.request(
 259              "GET", url, headers=headers, auth=('admin', 'admin'))
 260          res = response.json()
 261          #Tests related to nodes
 262          self.assertEqual(response.status_code, requests.codes.ok)
 263          with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 264              outfile1.write(str(len(res['network'][0]['node'])))
 265          nbNode=len(res['network'][0]['node'])
 266          self.assertEqual(nbNode,4)
 267          #Tests related to XPDRA nodes
 268          self.assertEqual(res['network'][0]['node'][1]['node-id'],'XPDRA-XPDR1')
 269          self.assertEqual(len(res['network'][0]['node'][1]['ietf-network-topology:termination-point']),2)
 270          self.assertEqual({'tp-id': 'XPDR1-CLIENT1', 'org-openroadm-network-topology:tp-type': 'XPONDER-CLIENT',
 271                              'org-openroadm-network-topology:xpdr-network-attributes': {
 272                              'tail-equipment-id': 'XPDR1-NETWORK1'}},
 273                         res['network'][0]['node'][1]['ietf-network-topology:termination-point'][0])
 274          self.assertEqual({'tp-id': 'XPDR1-NETWORK1', 'org-openroadm-network-topology:tp-type': 'XPONDER-NETWORK',
 275                         'org-openroadm-network-topology:xpdr-client-attributes': {'tail-equipment-id': 'XPDR1-CLIENT1'}},
 276                         res['network'][0]['node'][1]['ietf-network-topology:termination-point'][1])
 277          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
 278              res['network'][0]['node'][1]['supporting-node'])
 279          self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network-topology:node-type'],'XPONDER')
 280          #Tests related to ROADMA nodes
 281          #Test related to SRG1
 282          self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA-SRG1')
 283          #To be integrate in the effective tests
 284          self.assertEqual(len(res['network'][0]['node'][0]['ietf-network-topology:termination-point']),17)
 285          self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 286             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 287          self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 288              res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 289          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 290              res['network'][0]['node'][0]['supporting-node'])
 291          self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network-topology:node-type'],'SRG')
 292          #Test related to DEG2
 293          self.assertEqual(res['network'][0]['node'][2]['node-id'],'ROADMA-DEG2')
 294          self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 295              res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 296          self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 297              res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 298          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 299              res['network'][0]['node'][2]['supporting-node'])
 300          self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network-topology:node-type'],'DEGREE')
 301          #Test related to DEG1
 302          self.assertEqual(res['network'][0]['node'][3]['node-id'],'ROADMA-DEG1')
 303          self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 304              res['network'][0]['node'][3]['ietf-network-topology:termination-point'])
 305          self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 306              res['network'][0]['node'][3]['ietf-network-topology:termination-point'])
 307          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 308              res['network'][0]['node'][3]['supporting-node'])
 309          self.assertEqual(res['network'][0]['node'][3]['org-openroadm-network-topology:node-type'],'DEGREE')
 310
 311     #Connect the tail XPDRA to ROADMA and vice versa
 312     def test_10_connect_tail_xpdr_rdm(self):
 313          #Connect the tail: XPDRA to ROADMA
 314         url = ("{}/operations/networkutils:init-xpdr-rdm-links"
 315                 .format(self.restconf_baseurl))
 316         data = {"networkutils:input": {
 317              "networkutils:links-input": {
 318                "networkutils:xpdr-node": "XPDRA",
 319                "networkutils:xpdr-num": "1",
 320                "networkutils:network-num": "1",
 321                "networkutils:rdm-node": "ROADMA",
 322                "networkutils:srg-num": "1",
 323                "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 324             }
 325           }
 326         }
 327         headers = {'content-type': 'application/json'}
 328         response = requests.request(
 329               "POST", url, data=json.dumps(data), headers=headers,
 330               auth=('admin', 'admin'))
 331         self.assertEqual(response.status_code, requests.codes.ok)
 332         time.sleep(10)
 333
 334     def test_11_connect_tail_rdm_xpdr(self):
 335          #Connect the tail: ROADMA to XPDRA
 336          url = ("{}/operations/networkutils:init-rdm-xpdr-links"
 337                  .format(self.restconf_baseurl))
 338          data = {"networkutils:input": {
 339               "networkutils:links-input": {
 340                 "networkutils:xpdr-node": "XPDRA",
 341                 "networkutils:xpdr-num": "1",
 342                 "networkutils:network-num": "1",
 343                 "networkutils:rdm-node": "ROADMA",
 344                 "networkutils:srg-num": "1",
 345                 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
 346              }
 347             }
 348          }
 349          headers = {'content-type': 'application/json'}
 350          response = requests.request(
 351                "POST", url, data=json.dumps(data), headers=headers,
 352                auth=('admin', 'admin'))
 353          self.assertEqual(response.status_code, requests.codes.ok)
 354          time.sleep(10)
 355
 356     def test_12_getLinks_OpenRoadmTopology(self):
 357         url = ("{}/config/ietf-network:network/openroadm-topology"
 358                .format(self.restconf_baseurl))
 359         headers = {'content-type': 'application/json'}
 360         response = requests.request(
 361              "GET", url, headers=headers, auth=('admin', 'admin'))
 362         self.assertEqual(response.status_code, requests.codes.ok)
 363         res = response.json()
 364         #Tests related to links
 365         self.assertEqual(len(res['network'][0]['ietf-network-topology:link']),8)
 366         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 367         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 368         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 369         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 370         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 371         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 372         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 373         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 374         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['link-id'],'XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX')
 375         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
 376         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['link-id'],'ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1')
 377         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
 378         self.assertEqual(res['network'][0]['ietf-network-topology:link'][6]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 379         self.assertEqual(res['network'][0]['ietf-network-topology:link'][6]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 380         self.assertEqual(res['network'][0]['ietf-network-topology:link'][7]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 381         self.assertEqual(res['network'][0]['ietf-network-topology:link'][7]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 382
 383     def test_13_connect_ROADMC(self):
 384         #Config ROADMC
 385         url = ("{}/config/network-topology:"
 386                 "network-topology/topology/topology-netconf/node/ROADMC"
 387                 .format(self.restconf_baseurl))
 388         data = {"node": [{
 389              "node-id": "ROADMC",
 390              "netconf-node-topology:username": "admin",
 391              "netconf-node-topology:password": "admin",
 392              "netconf-node-topology:host": "127.0.0.1",
 393              "netconf-node-topology:port": "17833",
 394              "netconf-node-topology:tcp-only": "false",
 395              "netconf-node-topology:pass-through": {}}]}
 396         headers = {'content-type': 'application/json'}
 397         response = requests.request(
 398              "PUT", url, data=json.dumps(data), headers=headers,
 399              auth=('admin', 'admin'))
 400         self.assertEqual(response.status_code, requests.codes.created)
 401         time.sleep(30)
 402
 403     def test_14_getClliNetwork(self):
 404         url = ("{}/config/ietf-network:network/clli-network"
 405               .format(self.restconf_baseurl))
 406         headers = {'content-type': 'application/json'}
 407         response = requests.request(
 408             "GET", url, headers=headers, auth=('admin', 'admin'))
 409         self.assertEqual(response.status_code, requests.codes.ok)
 410         res = response.json()
 411         self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeC')
 412         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeC')
 413         self.assertEqual(res['network'][0]['node'][1]['node-id'],'NodeA')
 414         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeA')
 415
 416     def test_15_getOpenRoadmNetwork(self):
 417         url = ("{}/config/ietf-network:network/openroadm-network"
 418               .format(self.restconf_baseurl))
 419         headers = {'content-type': 'application/json'}
 420         response = requests.request(
 421             "GET", url, headers=headers, auth=('admin', 'admin'))
 422         self.assertEqual(response.status_code, requests.codes.ok)
 423         res = response.json()
 424         nbNode=len(res['network'][0]['node'])
 425         self.assertEqual(nbNode,3)
 426         self.assertEqual(res['network'][0]['node'][0]['node-id'],'XPDRA')
 427         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
 428         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
 429         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:node-type'],'XPONDER')
 430         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'1')
 431         self.assertEqual(res['network'][0]['node'][1]['node-id'],'ROADMA')
 432         self.assertEqual(res['network'][0]['node'][1]['supporting-node'][0]['network-ref'],'clli-network')
 433         self.assertEqual(res['network'][0]['node'][1]['supporting-node'][0]['node-ref'],'NodeA')
 434         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network:node-type'],'ROADM')
 435         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network:model'],'2')
 436         self.assertEqual(res['network'][0]['node'][2]['node-id'],'ROADMC')
 437         self.assertEqual(res['network'][0]['node'][2]['supporting-node'][0]['network-ref'],'clli-network')
 438         self.assertEqual(res['network'][0]['node'][2]['supporting-node'][0]['node-ref'],'NodeC')
 439         self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network:node-type'],'ROADM')
 440         self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network:model'],'2')
 441
 442     def test_16_getROADMLinkOpenRoadmTopology(self):
 443         url = ("{}/config/ietf-network:network/openroadm-topology"
 444               .format(self.restconf_baseurl))
 445         headers = {'content-type': 'application/json'}
 446         response = requests.request(
 447             "GET", url, headers=headers, auth=('admin', 'admin'))
 448         self.assertEqual(response.status_code, requests.codes.ok)
 449         res = response.json()
 450         #Tests related to links
 451         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 452         self.assertEqual(nbLink,16)
 453         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 454         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 455         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
 456         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 457         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 458         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 459         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['link-id'],'XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX')
 460         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
 461         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 462         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 463         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 464         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 465         self.assertEqual(res['network'][0]['ietf-network-topology:link'][6]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
 466         self.assertEqual(res['network'][0]['ietf-network-topology:link'][6]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 467         self.assertEqual(res['network'][0]['ietf-network-topology:link'][7]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 468         self.assertEqual(res['network'][0]['ietf-network-topology:link'][7]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 469         self.assertEqual(res['network'][0]['ietf-network-topology:link'][8]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 470         self.assertEqual(res['network'][0]['ietf-network-topology:link'][8]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 471         self.assertEqual(res['network'][0]['ietf-network-topology:link'][9]['link-id'],'ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX')
 472         self.assertEqual(res['network'][0]['ietf-network-topology:link'][9]['org-openroadm-network-topology:link-type'],'ROADM-TO-ROADM')
 473         self.assertEqual(res['network'][0]['ietf-network-topology:link'][10]['link-id'],'ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1')
 474         self.assertEqual(res['network'][0]['ietf-network-topology:link'][10]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
 475         self.assertEqual(res['network'][0]['ietf-network-topology:link'][11]['link-id'],'ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX')
 476         self.assertEqual(res['network'][0]['ietf-network-topology:link'][11]['org-openroadm-network-topology:link-type'],'ROADM-TO-ROADM')
 477         self.assertEqual(res['network'][0]['ietf-network-topology:link'][12]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 478         self.assertEqual(res['network'][0]['ietf-network-topology:link'][12]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 479         self.assertEqual(res['network'][0]['ietf-network-topology:link'][13]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 480         self.assertEqual(res['network'][0]['ietf-network-topology:link'][13]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 481         self.assertEqual(res['network'][0]['ietf-network-topology:link'][14]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 482         self.assertEqual(res['network'][0]['ietf-network-topology:link'][14]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 483         self.assertEqual(res['network'][0]['ietf-network-topology:link'][15]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 484         self.assertEqual(res['network'][0]['ietf-network-topology:link'][15]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 485
 486     def test_17_getNodes_OpenRoadmTopology(self):
 487          url = ("{}/config/ietf-network:network/openroadm-topology"
 488                .format(self.restconf_baseurl))
 489          headers = {'content-type': 'application/json'}
 490          response = requests.request(
 491              "GET", url, headers=headers, auth=('admin', 'admin'))
 492          res = response.json()
 493          #Tests related to nodes
 494          self.assertEqual(response.status_code, requests.codes.ok)
 495          nbNode=len(res['network'][0]['node'])
 496          self.assertEqual(nbNode,7)
 497          #************************Tests related to XPDRA nodes
 498          self.assertEqual(res['network'][0]['node'][4]['node-id'],'XPDRA-XPDR1')
 499          self.assertEqual(len(res['network'][0]['node'][4]['ietf-network-topology:termination-point']),2)
 500          self.assertEqual({'tp-id': 'XPDR1-CLIENT1', 'org-openroadm-network-topology:tp-type': 'XPONDER-CLIENT',
 501                              'org-openroadm-network-topology:xpdr-network-attributes': {
 502                              'tail-equipment-id': 'XPDR1-NETWORK1'}},
 503                         res['network'][0]['node'][4]['ietf-network-topology:termination-point'][0])
 504          self.assertEqual({'tp-id': 'XPDR1-NETWORK1', 'org-openroadm-network-topology:tp-type': 'XPONDER-NETWORK',
 505                         'org-openroadm-network-topology:xpdr-client-attributes': {'tail-equipment-id': 'XPDR1-CLIENT1'}},
 506                         res['network'][0]['node'][4]['ietf-network-topology:termination-point'][1])
 507          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
 508              res['network'][0]['node'][4]['supporting-node'])
 509          self.assertEqual(res['network'][0]['node'][4]['org-openroadm-network-topology:node-type'],'XPONDER')
 510          #************************Tests related to ROADMA nodes
 511          #Test related to SRG1
 512          self.assertEqual(res['network'][0]['node'][3]['node-id'],'ROADMA-SRG1')
 513          #To be integrate in the effective tests
 514          self.assertEqual(len(res['network'][0]['node'][0]['ietf-network-topology:termination-point']),17)
 515          self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 516             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 517          self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 518              res['network'][0]['node'][3]['ietf-network-topology:termination-point'])
 519          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 520              res['network'][0]['node'][3]['supporting-node'])
 521          self.assertEqual(res['network'][0]['node'][3]['org-openroadm-network-topology:node-type'],'SRG')
 522          #Test related to DEG2
 523          self.assertEqual(res['network'][0]['node'][5]['node-id'],'ROADMA-DEG2')
 524          self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 525              res['network'][0]['node'][5]['ietf-network-topology:termination-point'])
 526          self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 527              res['network'][0]['node'][5]['ietf-network-topology:termination-point'])
 528          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 529              res['network'][0]['node'][5]['supporting-node'])
 530          self.assertEqual(res['network'][0]['node'][5]['org-openroadm-network-topology:node-type'],'DEGREE')
 531          #Test related to DEG1
 532          self.assertEqual(res['network'][0]['node'][6]['node-id'],'ROADMA-DEG1')
 533          self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 534              res['network'][0]['node'][6]['ietf-network-topology:termination-point'])
 535          self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 536              res['network'][0]['node'][6]['ietf-network-topology:termination-point'])
 537          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 538              res['network'][0]['node'][6]['supporting-node'])
 539          self.assertEqual(res['network'][0]['node'][6]['org-openroadm-network-topology:node-type'],'DEGREE')
 540          #************************Tests related to ROADMC nodes
 541          #Test related to SRG1
 542          self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMC-SRG1')
 543          #To be integrate in the effective tests
 544          self.assertEqual(len(res['network'][0]['node'][0]['ietf-network-topology:termination-point']),17)
 545          self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 546             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 547          self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 548              res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 549          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
 550              res['network'][0]['node'][0]['supporting-node'])
 551          self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network-topology:node-type'],'SRG')
 552          #Test related to DEG1
 553          self.assertEqual(res['network'][0]['node'][1]['node-id'],'ROADMC-DEG1')
 554          self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 555              res['network'][0]['node'][1]['ietf-network-topology:termination-point'])
 556          self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 557              res['network'][0]['node'][1]['ietf-network-topology:termination-point'])
 558          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
 559              res['network'][0]['node'][1]['supporting-node'])
 560          self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network-topology:node-type'],'DEGREE')
 561          #Test related to DEG2
 562          self.assertEqual(res['network'][0]['node'][2]['node-id'],'ROADMC-DEG2')
 563          self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 564              res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 565          self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 566              res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 567          self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
 568              res['network'][0]['node'][2]['supporting-node'])
 569          self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network-topology:node-type'],'DEGREE')
 570
 571     def test_18_connect_ROADMB(self):
 572         url = ("{}/config/network-topology:"
 573                 "network-topology/topology/topology-netconf/node/ROADMB"
 574                .format(self.restconf_baseurl))
 575         data = {"node": [{
 576              "node-id": "ROADMB",
 577              "netconf-node-topology:username": "admin",
 578              "netconf-node-topology:password": "admin",
 579              "netconf-node-topology:host": "127.0.0.1",
 580              "netconf-node-topology:port": "17832",
 581              "netconf-node-topology:tcp-only": "false",
 582              "netconf-node-topology:pass-through": {}}]}
 583         headers = {'content-type': 'application/json'}
 584         response = requests.request(
 585              "PUT", url, data=json.dumps(data), headers=headers,
 586              auth=('admin', 'admin'))
 587         self.assertEqual(response.status_code, requests.codes.created)
 588         time.sleep(30)
 589
 590     def test_19_getClliNetwork(self):
 591         url = ("{}/config/ietf-network:network/clli-network"
 592               .format(self.restconf_baseurl))
 593         headers = {'content-type': 'application/json'}
 594         response = requests.request(
 595             "GET", url, headers=headers, auth=('admin', 'admin'))
 596         self.assertEqual(response.status_code, requests.codes.ok)
 597         res = response.json()
 598         self.assertEqual(res['network'][0]['node'][0]['node-id'],'NodeC')
 599         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeC')
 600         self.assertEqual(res['network'][0]['node'][1]['node-id'],'NodeA')
 601         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeA')
 602         self.assertEqual(res['network'][0]['node'][2]['node-id'],'NodeB')
 603         self.assertEqual(res['network'][0]['node'][2]['org-openroadm-clli-network:clli'],'NodeB')
 604
 605     def test_20_verifyDegree(self):
 606         url = ("{}/config/ietf-network:network/openroadm-topology"
 607               .format(self.restconf_baseurl))
 608         headers = {'content-type': 'application/json'}
 609         response = requests.request(
 610             "GET", url, headers=headers, auth=('admin', 'admin'))
 611         self.assertEqual(response.status_code, requests.codes.ok)
 612         res = response.json()
 613         #Tests related to links
 614         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 615         listR2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX',
 616            'ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
 617            'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX']
 618         for i in range(0,nbLink):
 619             if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'] == 'ROADM-TO-ROADM':
 620                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
 621                 find= link_id in listR2RLink
 622                 self.assertEqual(find, True)
 623                 listR2RLink.remove(link_id)
 624         self.assertEqual(len(listR2RLink),0)
 625
 626     def test_21_verifyOppositeLinkTopology(self):
 627         url = ("{}/config/ietf-network:network/openroadm-topology"
 628                .format(self.restconf_baseurl))
 629         headers = {'content-type': 'application/json'}
 630         response = requests.request(
 631              "GET", url, headers=headers, auth=('admin', 'admin'))
 632         self.assertEqual(response.status_code, requests.codes.ok)
 633         res = response.json()
 634         #Write the response in the log
 635         with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 636             outfile1.write(str(res))
 637         #Tests related to links
 638         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 639         self.assertEqual(nbLink,26)
 640         for i in range(0,nbLink):
 641             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
 642             link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
 643             link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
 644             link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
 645             oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-opposite-links:opposite-link']
 646             #Find the opposite link
 647             url_oppLink="{}/config/ietf-network:network/openroadm-topology/ietf-network-topology:link/"+oppLink_id
 648             url = (url_oppLink.format(self.restconf_baseurl))
 649             headers = {'content-type': 'application/json'}
 650             response_oppLink = requests.request("GET", url, headers=headers, auth=('admin', 'admin'))
 651             self.assertEqual(response_oppLink.status_code, requests.codes.ok)
 652             res_oppLink = response_oppLink.json()
 653             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-opposite-links:opposite-link'],link_id)
 654             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
 655             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
 656             oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type']
 657             if link_type=='ADD-LINK':
 658                 self.assertEqual(oppLink_type, 'DROP-LINK')
 659             elif link_type=='DROP-LINK':
 660                 self.assertEqual(oppLink_type, 'ADD-LINK')
 661             elif link_type=='EXPRESS-LINK':
 662                 self.assertEqual(oppLink_type, 'EXPRESS-LINK')
 663             elif link_type=='ROADM-TO-ROADM':
 664                 self.assertEqual(oppLink_type, 'ROADM-TO-ROADM')
 665             elif link_type=='XPONDER-INPUT':
 666                 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
 667             elif link_type=='XPONDER-OUTPUT':
 668                 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
 669         time.sleep(5)
 670
 671     def test_22_disconnect_ROADMB(self):
 672         #Delete in the topology-netconf
 673         url = ("{}/config/network-topology:"
 674                 "network-topology/topology/topology-netconf/node/ROADMB"
 675                .format(self.restconf_baseurl))
 676         data = {}
 677         headers = {'content-type': 'application/json'}
 678         response = requests.request(
 679              "DELETE", url, data=json.dumps(data), headers=headers,
 680              auth=('admin', 'admin'))
 681         self.assertEqual(response.status_code, requests.codes.ok)
 682         #Delete in the clli-network
 683         url = ("{}/config/ietf-network:network/clli-network/node/NodeB"
 684                .format(self.restconf_baseurl))
 685         data = {}
 686         headers = {'content-type': 'application/json'}
 687         response = requests.request(
 688              "DELETE", url, data=json.dumps(data), headers=headers,
 689              auth=('admin', 'admin'))
 690         self.assertEqual(response.status_code, requests.codes.ok)
 691         #Delete in the openroadm-network
 692         url = ("{}/config/ietf-network:network/openroadm-network/node/ROADMB"
 693                .format(self.restconf_baseurl))
 694         data = {}
 695         headers = {'content-type': 'application/json'}
 696         response = requests.request(
 697              "DELETE", url, data=json.dumps(data), headers=headers,
 698              auth=('admin', 'admin'))
 699         self.assertEqual(response.status_code, requests.codes.ok)
 700
 701     def test_23_disconnect_ROADMC(self):
 702         #Delete in the topology-netconf
 703         url = ("{}/config/network-topology:"
 704                 "network-topology/topology/topology-netconf/node/ROADMC"
 705                .format(self.restconf_baseurl))
 706         data = {}
 707         headers = {'content-type': 'application/json'}
 708         response = requests.request(
 709              "DELETE", url, data=json.dumps(data), headers=headers,
 710              auth=('admin', 'admin'))
 711         self.assertEqual(response.status_code, requests.codes.ok)
 712         #Delete in the clli-network
 713         url = ("{}/config/ietf-network:network/clli-network/node/NodeC"
 714                .format(self.restconf_baseurl))
 715         data = {}
 716         headers = {'content-type': 'application/json'}
 717         response = requests.request(
 718              "DELETE", url, data=json.dumps(data), headers=headers,
 719              auth=('admin', 'admin'))
 720         self.assertEqual(response.status_code, requests.codes.ok)
 721         #Delete in the openroadm-network
 722         url = ("{}/config/ietf-network:network/openroadm-network/node/ROADMC"
 723                .format(self.restconf_baseurl))
 724         data = {}
 725         headers = {'content-type': 'application/json'}
 726         response = requests.request(
 727              "DELETE", url, data=json.dumps(data), headers=headers,
 728              auth=('admin', 'admin'))
 729         self.assertEqual(response.status_code, requests.codes.ok)
 730
 731     def test_24_getLinks_OpenRoadmTopology(self):
 732         url = ("{}/config/ietf-network:network/openroadm-topology"
 733                .format(self.restconf_baseurl))
 734         headers = {'content-type': 'application/json'}
 735         response = requests.request(
 736              "GET", url, headers=headers, auth=('admin', 'admin'))
 737         self.assertEqual(response.status_code, requests.codes.ok)
 738         res = response.json()
 739         #Write the response in the log
 740         with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 741             outfile1.write(str(res))
 742         #Tests related to links
 743         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 744         self.assertEqual(nbLink,8)
 745         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 746         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 747         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 748         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 749         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 750         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 751         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 752         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 753         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['link-id'],'XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX')
 754         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
 755         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['link-id'],'ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1')
 756         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
 757         self.assertEqual(res['network'][0]['ietf-network-topology:link'][6]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 758         self.assertEqual(res['network'][0]['ietf-network-topology:link'][6]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 759         self.assertEqual(res['network'][0]['ietf-network-topology:link'][7]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 760         self.assertEqual(res['network'][0]['ietf-network-topology:link'][7]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 761         for i in range(0,nbLink-1):
 762             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'ROADM-TO-ROADM')
 763             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 764             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 765             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
 766             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
 767             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
 768             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
 769
 770     def test_25_getNodes_OpenRoadmTopology(self):
 771         url = ("{}/config/ietf-network:network/openroadm-topology"
 772               .format(self.restconf_baseurl))
 773         headers = {'content-type': 'application/json'}
 774         response = requests.request(
 775             "GET", url, headers=headers, auth=('admin', 'admin'))
 776         res = response.json()
 777         #Tests related to nodes
 778         self.assertEqual(response.status_code, requests.codes.ok)
 779         with open('./transportpce_tests/log/response.log', 'a') as outfile1:
 780             outfile1.write(str(len(res['network'][0]['node'])))
 781         nbNode=len(res['network'][0]['node'])
 782         self.assertEqual(nbNode,4)
 783         #Tests related to nodes
 784         self.assertEqual(res['network'][0]['node'][1]['node-id'],'XPDRA-XPDR1')
 785         self.assertEqual(len(res['network'][0]['node'][1]['ietf-network-topology:termination-point']),4)
 786         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
 787              res['network'][0]['node'][1]['supporting-node'])
 788         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network-topology:node-type'],'XPONDER')
 789         #Test related to SRG1
 790         self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA-SRG1')
 791         self.assertEqual(len(res['network'][0]['node'][0]['ietf-network-topology:termination-point']),17)
 792         self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 793             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 794         self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 795             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 796         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 797             res['network'][0]['node'][0]['supporting-node'])
 798         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network-topology:node-type'],'SRG')
 799         #Test related to DEG2
 800         self.assertEqual(res['network'][0]['node'][2]['node-id'],'ROADMA-DEG2')
 801         self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 802             res['network'        ][0]['node'][2]['ietf-network-topology:termination-point'])
 803         self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 804             res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 805         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 806             res['network'][0]['node'][2]['supporting-node'])
 807         self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network-topology:node-type'],'DEGREE')
 808         #Test related to DEG1
 809         self.assertEqual(res['network'][0]['node'][3]['node-id'],'ROADMA-DEG1')
 810         self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 811             res['network'][0]['node'][3]['ietf-network-topology:termination-point'])
 812         self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 813             res['network'][0]['node'][3]['ietf-network-topology:termination-point'])
 814         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 815             res['network'][0]['node'][3]['supporting-node'])
 816         self.assertEqual(res['network'][0]['node'][3]['org-openroadm-network-topology:node-type'],'DEGREE')
 817         #Test related to SRG1 of ROADMC
 818         for i in range(0,nbNode-1):
 819             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-SRG1')
 820             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG1')
 821             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG2')
 822
 823     def test_26_getOpenRoadmNetwork(self):
 824         url = ("{}/config/ietf-network:network/openroadm-network"
 825               .format(self.restconf_baseurl))
 826         headers = {'content-type': 'application/json'}
 827         response = requests.request(
 828             "GET", url, headers=headers, auth=('admin', 'admin'))
 829         self.assertEqual(response.status_code, requests.codes.ok)
 830         res = response.json()
 831         nbNode=len(res['network'][0]['node'])
 832         self.assertEqual(nbNode,2)
 833         for i in range(0,nbNode-1):
 834             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC')
 835
 836     def test_27_getClliNetwork(self):
 837         url = ("{}/config/ietf-network:network/clli-network"
 838               .format(self.restconf_baseurl))
 839         headers = {'content-type': 'application/json'}
 840         response = requests.request(
 841             "GET", url, headers=headers, auth=('admin', 'admin'))
 842         self.assertEqual(response.status_code, requests.codes.ok)
 843         res = response.json()
 844         nbNode=len(res['network'][0]['node'])
 845         self.assertEqual(nbNode,1)
 846         for i in range(0,nbNode-1):
 847             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
 848
 849     def test_28_disconnect_XPDRA(self):
 850         url = ("{}/config/network-topology:"
 851                "network-topology/topology/topology-netconf/node/XPDRA"
 852               .format(self.restconf_baseurl))
 853         data = {}
 854         headers = {'content-type': 'application/json'}
 855         response = requests.request(
 856             "DELETE", url, data=json.dumps(data), headers=headers,
 857             auth=('admin', 'admin'))
 858         self.assertEqual(response.status_code, requests.codes.ok)
 859         #Delete in the openroadm-network
 860         url = ("{}/config/ietf-network:network/openroadm-network/node/XPDRA"
 861                .format(self.restconf_baseurl))
 862         data = {}
 863         headers = {'content-type': 'application/json'}
 864         response = requests.request(
 865              "DELETE", url, data=json.dumps(data), headers=headers,
 866              auth=('admin', 'admin'))
 867         self.assertEqual(response.status_code, requests.codes.ok)
 868
 869     def test_29_getClliNetwork(self):
 870         url = ("{}/config/ietf-network:network/clli-network"
 871               .format(self.restconf_baseurl))
 872         headers = {'content-type': 'application/json'}
 873         response = requests.request(
 874             "GET", url, headers=headers, auth=('admin', 'admin'))
 875         self.assertEqual(response.status_code, requests.codes.ok)
 876         res = response.json()
 877         nbNode=len(res['network'][0]['node'])
 878         self.assertEqual(nbNode,1)
 879         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
 880
 881     def test_30_getOpenRoadmNetwork(self):
 882         url = ("{}/config/ietf-network:network/openroadm-network"
 883               .format(self.restconf_baseurl))
 884         headers = {'content-type': 'application/json'}
 885         response = requests.request(
 886             "GET", url, headers=headers, auth=('admin', 'admin'))
 887         self.assertEqual(response.status_code, requests.codes.ok)
 888         res = response.json()
 889         nbNode=len(res['network'][0]['node'])
 890         self.assertEqual(nbNode,1)
 891         for i in range(0,nbNode-1):
 892             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA')
 893
 894     def test_31_getNodes_OpenRoadmTopology(self):
 895         url = ("{}/config/ietf-network:network/openroadm-topology"
 896               .format(self.restconf_baseurl))
 897         headers = {'content-type': 'application/json'}
 898         response = requests.request(
 899             "GET", url, headers=headers, auth=('admin', 'admin'))
 900         res = response.json()
 901         #Tests related to nodes
 902         self.assertEqual(response.status_code, requests.codes.ok)
 903         nbNode=len(res['network'][0]['node'])
 904         self.assertEqual(nbNode,3)
 905         #Tests related to nodes
 906         #Test related to SRG1
 907         self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA-SRG1')
 908         self.assertEqual(len(res['network'][0]['node'][0]['ietf-network-topology:termination-point']),17)
 909         self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
 910             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 911         self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
 912             res['network'][0]['node'][0]['ietf-network-topology:termination-point'])
 913         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 914             res['network'][0]['node'][0]['supporting-node'])
 915         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network-topology:node-type'],'SRG')
 916         #Test related to DEG2
 917         self.assertEqual(res['network'][0]['node'][1]['node-id'],'ROADMA-DEG2')
 918         self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 919             res['network'][0]['node'][1]['ietf-network-topology:termination-point'])
 920         self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 921             res['network'][0]['node'][1]['ietf-network-topology:termination-point'])
 922         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 923             res['network'][0]['node'][1]['supporting-node'])
 924         self.assertEqual(res['network'][0]['node'][1]['org-openroadm-network-topology:node-type'],'DEGREE')
 925         #Test related to DEG1
 926         self.assertEqual(res['network'][0]['node'][2]['node-id'],'ROADMA-DEG1')
 927         self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
 928             res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 929         self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
 930             res['network'][0]['node'][2]['ietf-network-topology:termination-point'])
 931         self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
 932             res['network'][0]['node'][2]['supporting-node'])
 933         self.assertEqual(res['network'][0]['node'][2]['org-openroadm-network-topology:node-type'],'DEGREE')
 934
 935     def test_32_disconnect_ROADM_XPDRA_link(self):
 936         #Link-1
 937         url = ("{}/config/ietf-network:network/openroadm-topology/ietf-network-topology:"
 938                "link/XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX"
 939                 .format(self.restconf_baseurl))
 940         data = {}
 941         headers = {'content-type': 'application/json'}
 942         response = requests.request(
 943              "DELETE", url, data=json.dumps(data), headers=headers,
 944              auth=('admin', 'admin'))
 945         self.assertEqual(response.status_code, requests.codes.ok)
 946         #Link-2
 947         url = ("{}/config/ietf-network:network/openroadm-topology/ietf-network-topology:"
 948                "link/ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1"
 949                 .format(self.restconf_baseurl))
 950         data = {}
 951         headers = {'content-type': 'application/json'}
 952         response = requests.request(
 953              "DELETE", url, data=json.dumps(data), headers=headers,
 954              auth=('admin', 'admin'))
 955         self.assertEqual(response.status_code, requests.codes.ok)
 956
 957     def test_33_getLinks_OpenRoadmTopology(self):
 958         url = ("{}/config/ietf-network:network/openroadm-topology"
 959               .format(self.restconf_baseurl))
 960         headers = {'content-type': 'application/json'}
 961         response = requests.request(
 962             "GET", url, headers=headers, auth=('admin', 'admin'))
 963         self.assertEqual(response.status_code, requests.codes.ok)
 964         res = response.json()
 965         nbLink=len(res['network'][0]['ietf-network-topology:link'])
 966         self.assertEqual(nbLink,6)
 967         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 968         self.assertEqual(res['network'][0]['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 969         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 970         self.assertEqual(res['network'][0]['ietf-network-topology:link'][1]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 971         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['link-id'],'ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX')
 972         self.assertEqual(res['network'][0]['ietf-network-topology:link'][2]['org-openroadm-network-topology:link-type'],'DROP-LINK')
 973         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX')
 974         self.assertEqual(res['network'][0]['ietf-network-topology:link'][3]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 975         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['link-id'],'ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 976         self.assertEqual(res['network'][0]['ietf-network-topology:link'][4]['org-openroadm-network-topology:link-type'],'EXPRESS-LINK')
 977         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['link-id'],'ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX')
 978         self.assertEqual(res['network'][0]['ietf-network-topology:link'][5]['org-openroadm-network-topology:link-type'],'ADD-LINK')
 979         for i in range(0,nbLink-1):
 980             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
 981             self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
 982
 983     def test_34_disconnect_ROADMA(self):
 984         url = ("{}/config/network-topology:"
 985                 "network-topology/topology/topology-netconf/node/ROADMA"
 986                .format(self.restconf_baseurl))
 987         data = {}
 988         headers = {'content-type': 'application/json'}
 989         response = requests.request(
 990              "DELETE", url, data=json.dumps(data), headers=headers,
 991              auth=('admin', 'admin'))
 992         self.assertEqual(response.status_code, requests.codes.ok)
 993         #Delete in the clli-network
 994         url = ("{}/config/ietf-network:network/clli-network/node/NodeA"
 995                .format(self.restconf_baseurl))
 996         data = {}
 997         headers = {'content-type': 'application/json'}
 998         response = requests.request(
 999              "DELETE", url, data=json.dumps(data), headers=headers,
1000              auth=('admin', 'admin'))
1001         self.assertEqual(response.status_code, requests.codes.ok)
1002         #Delete in the openroadm-network
1003         url = ("{}/config/ietf-network:network/openroadm-network/node/ROADMA"
1004                .format(self.restconf_baseurl))
1005         data = {}
1006         headers = {'content-type': 'application/json'}
1007         response = requests.request(
1008              "DELETE", url, data=json.dumps(data), headers=headers,
1009              auth=('admin', 'admin'))
1010         self.assertEqual(response.status_code, requests.codes.ok)
1011         time.sleep(5)
1012
1013     def test_35_getClliNetwork(self):
1014         url = ("{}/config/ietf-network:network/clli-network"
1015               .format(self.restconf_baseurl))
1016         headers = {'content-type': 'application/json'}
1017         response = requests.request(
1018             "GET", url, headers=headers, auth=('admin', 'admin'))
1019         self.assertEqual(response.status_code, requests.codes.ok)
1020         res = response.json()
1021         self.assertNotIn('node', res['network'][0])
1022
1023     def test_36_getOpenRoadmNetwork(self):
1024         url = ("{}/config/ietf-network:network/openroadm-network"
1025               .format(self.restconf_baseurl))
1026         headers = {'content-type': 'application/json'}
1027         response = requests.request(
1028             "GET", url, headers=headers, auth=('admin', 'admin'))
1029         self.assertEqual(response.status_code, requests.codes.ok)
1030         res = response.json()
1031         self.assertNotIn('node', res['network'][0])
1032
1033     def test_37_getOpenRoadmTopology(self):
1034         url = ("{}/config/ietf-network:network/openroadm-topology"
1035               .format(self.restconf_baseurl))
1036         headers = {'content-type': 'application/json'}
1037         response = requests.request(
1038             "GET", url, headers=headers, auth=('admin', 'admin'))
1039         self.assertEqual(response.status_code, requests.codes.ok)
1040         res = response.json()
1041         self.assertNotIn('node', res['network'][0])
1042         self.assertNotIn('ietf-network-topology:link', res['network'][0])
1043
1044 if __name__ == "__main__":
1045     #logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
1046     #logging.debug('I am there')
1047     unittest.main(verbosity=2)