fix deprecated openroadm interfaces/objects

[transportpce.git] / tests / transportpce_tests / 1.2.1 / test_topology.py

diff --git a/tests/transportpce_tests/1.2.1/test_topology.py b/tests/transportpce_tests/1.2.1/test_topology.py
index ea35a3c6c80d32251cc417fdad0288b2169acf6b..e87f078bb5f618b5ebe50b4f721b26f852b3e5b3 100644 (file)
--- a/tests/transportpce_tests/1.2.1/test_topology.py
+++ b/tests/transportpce_tests/1.2.1/test_topology.py
@@ -19,6 +19,7 @@ import subprocess
 import time
 import unittest
 import logging
+import test_utils
 
 class TransportPCETopologyTesting(unittest.TestCase):
 
@@ -31,75 +32,29 @@ class TransportPCETopologyTesting(unittest.TestCase):
 
 #START_IGNORE_XTESTING
 
-    @classmethod
-    def __init_logfile(cls):
-        if not os.path.exists("transportpce_tests/log"):
-                os.makedirs("transportpce_tests/log")
-        if os.path.isfile("./transportpce_tests/log/response.log"):
-            os.remove("transportpce_tests/log/response.log")
-
-    @classmethod
-    def __start_honeynode1(cls):
-        executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
-                      "/honeynode-distribution-1.18.01/honeycomb-tpce")
-        if os.path.isfile(executable):
-            with open('honeynode1.log', 'w') as outfile:
-                cls.honeynode_process1 = subprocess.Popen(
-                    [executable, "17830", "sample_configs/openroadm/2.1/oper-XPDRA.xml"],
-                    stdout=outfile)
-
-    @classmethod
-    def __start_honeynode2(cls):
-        executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
-                      "/honeynode-distribution-1.18.01/honeycomb-tpce")
-        if os.path.isfile(executable):
-            with open('honeynode2.log', 'w') as outfile:
-                cls.honeynode_process2 = subprocess.Popen(
-                    [executable, "17831", "sample_configs/openroadm/2.1/oper-ROADMA.xml"],
-                    stdout=outfile)
-
-    @classmethod
-    def __start_honeynode3(cls):
-        executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
-                      "/honeynode-distribution-1.18.01/honeycomb-tpce")
-        if os.path.isfile(executable):
-            with open('honeynode3.log', 'w') as outfile:
-                cls.honeynode_process3 = subprocess.Popen(
-                    [executable, "17832", "sample_configs/openroadm/2.1/oper-ROADMB.xml"],
-                    stdout=outfile)
-
-    @classmethod
-    def __start_honeynode4(cls):
-        executable = ("./honeynode/2.1/honeynode-distribution/target/honeynode-distribution-1.18.01-hc"
-                      "/honeynode-distribution-1.18.01/honeycomb-tpce")
-        if os.path.isfile(executable):
-            with open('honeynode4.log', 'w') as outfile:
-                cls.honeynode_process4 = subprocess.Popen(
-                    [executable, "17833", "sample_configs/openroadm/2.1/oper-ROADMC.xml"],
-                    stdout=outfile)
-
-    @classmethod
-    def __start_odl(cls):
-        executable = "../karaf/target/assembly/bin/karaf"
-        with open('odl.log', 'w') as outfile:
-            cls.odl_process = subprocess.Popen(
-                ["bash", executable, "server"], stdout=outfile,
-                stdin=open(os.devnull))
-
     @classmethod
     def setUpClass(cls):
-        cls.__init_logfile()
-        time.sleep(2)
-        cls.__start_honeynode1()
+        print ("starting honeynode1...")
+        cls.honeynode_process1 = test_utils.start_xpdra_honeynode()
         time.sleep(20)
-        cls.__start_honeynode2()
+
+        print ("starting honeynode2...")
+        cls.honeynode_process2 = test_utils.start_roadma_honeynode()
         time.sleep(20)
-        cls.__start_honeynode3()
+
+        print ("starting honeynode3...")
+        cls.honeynode_process3 = test_utils.start_roadmb_honeynode()
         time.sleep(20)
-        cls.__start_honeynode4()
+
+        print ("starting honeynode4...")
+        cls.honeynode_process4 = test_utils.start_roadmc_honeynode()
         time.sleep(20)
-        cls.__start_odl()
+        print ("all honeynodes started")
+
+        print ("starting opendaylight...")
+        cls.odl_process = test_utils.start_tpce()
         time.sleep(60)
+        print ("opendaylight started")
 
     @classmethod
     def tearDownClass(cls):
@@ -131,21 +86,18 @@ class TransportPCETopologyTesting(unittest.TestCase):
         cls.honeynode_process4.send_signal(signal.SIGINT)
         cls.honeynode_process4.wait()
 
-
     def setUp(self):
-        print ("execution of {}".format(self.id().split(".")[-1]))
-        time.sleep(2)
-
+        time.sleep(30)
 
 #END_IGNORE_XTESTING
 
     def test_01_connect_ROADMA(self):
         #Config ROADMA
         url = ("{}/config/network-topology:"
-                "network-topology/topology/topology-netconf/node/ROADMA"
+                "network-topology/topology/topology-netconf/node/ROADMA01"
                .format(self.restconf_baseurl))
         data = {"node": [{
-             "node-id": "ROADMA",
+             "node-id": "ROADMA01",
              "netconf-node-topology:username": "admin",
              "netconf-node-topology:password": "admin",
              "netconf-node-topology:host": "127.0.0.1",
@@ -157,7 +109,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
              "PUT", url, data=json.dumps(data), headers=headers,
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.created)
-        time.sleep(30)
+        time.sleep(20)
 
     def test_02_getClliNetwork(self):
         url = ("{}/config/ietf-network:networks/network/clli-network"
@@ -178,10 +130,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
             "GET", url, headers=headers, auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
-        self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA')
+        self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADMA01')
         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['network-ref'],'clli-network')
         self.assertEqual(res['network'][0]['node'][0]['supporting-node'][0]['node-ref'],'NodeA')
-        self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:node-type'],'ROADM')
+        self.assertEqual(res['network'][0]['node'][0]['org-openroadm-common-network:node-type'],'ROADM')
         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-network:model'],'2')
 
     def test_04_getLinks_OpenroadmTopology(self):
@@ -194,21 +146,23 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         #Tests related to links
         nbLink=len(res['network'][0]['ietf-network-topology:link'])
-        self.assertEqual(nbLink,6)
-        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
-        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
-        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
+        self.assertEqual(nbLink,10)
+        expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
+        addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+                 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
+        dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+                  'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
         for i in range(0,nbLink):
             linkId = res['network'][0]['ietf-network-topology:link'][i]['link-id']
-            if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='EXPRESS-LINK'):
+            if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
                 find= linkId in expressLink
                 self.assertEqual(find, True)
                 expressLink.remove(linkId)
-            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='ADD-LINK'):
+            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
                 find= linkId in addLink
                 self.assertEqual(find, True)
                 addLink.remove(linkId)
-            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='DROP-LINK'):
+            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
                 find= linkId in dropLink
                 self.assertEqual(find, True)
                 dropLink.remove(linkId)
@@ -227,39 +181,46 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         #Tests related to nodes
         self.assertEqual(response.status_code, requests.codes.ok)
-        with open('./transportpce_tests/log/response.log', 'a') as outfile1:
-            outfile1.write(str(len(res['network'][0]['node'])))
         nbNode=len(res['network'][0]['node'])
-        self.assertEqual(nbNode,3)
-        listNode=['ROADMA-SRG1','ROADMA-DEG1','ROADMA-DEG2']
+        self.assertEqual(nbNode,4)
+        listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
         for i in range(0,nbNode):
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                           res['network'][0]['node'][i]['supporting-node'])
-            nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
+            nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
             nodeId=res['network'][0]['node'][i]['node-id']
-            if(nodeId=='ROADMA-SRG1'):
+            if(nodeId=='ROADMA01-SRG1'):
+                #Test related to SRG1
+                self.assertEqual(nodeType,'SRG')
+                self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+                self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                listNode.remove(nodeId)
+            elif(nodeId=='ROADMA01-SRG3'):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
-                self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
+                self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
+                self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                 listNode.remove(nodeId)
-            elif(nodeId=='ROADMA-DEG1'):
+            elif(nodeId=='ROADMA01-DEG1'):
                 #Test related to DEG1
                 self.assertEqual(nodeType,'DEGREE')
-                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                 listNode.remove(nodeId)
-            elif(nodeId=='ROADMA-DEG2'):
+            elif(nodeId=='ROADMA01-DEG2'):
                 #Test related to DEG2
                 self.assertEqual(nodeType,'DEGREE')
-                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                 listNode.remove(nodeId)
             else:
@@ -268,10 +229,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
 
     def test_06_connect_XPDRA(self):
          url = ("{}/config/network-topology:"
-                 "network-topology/topology/topology-netconf/node/XPDRA"
+                 "network-topology/topology/topology-netconf/node/XPDRA01"
                 .format(self.restconf_baseurl))
          data = {"node": [{
-              "node-id": "XPDRA",
+              "node-id": "XPDRA01",
               "netconf-node-topology:username": "admin",
               "netconf-node-topology:password": "admin",
               "netconf-node-topology:host": "127.0.0.1",
@@ -310,11 +271,11 @@ class TransportPCETopologyTesting(unittest.TestCase):
              self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
              self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
              nodeId=res['network'][0]['node'][i]['node-id']
-             if(nodeId=='XPDRA'):
-                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'XPONDER')
+             if(nodeId=='XPDRA01'):
+                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
-             elif(nodeId=='ROADMA'):
-                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
+             elif(nodeId=='ROADMA01'):
+                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
              else:
                 self.assertFalse(True)
@@ -328,68 +289,80 @@ class TransportPCETopologyTesting(unittest.TestCase):
          res = response.json()
          #Tests related to nodes
          self.assertEqual(response.status_code, requests.codes.ok)
-         with open('./transportpce_tests/log/response.log', 'a') as outfile1:
-             outfile1.write(str(len(res['network'][0]['node'])))
          nbNode=len(res['network'][0]['node'])
-         self.assertEqual(nbNode,4)
-         listNode=['XPDRA-XPDR1','ROADMA-SRG1','ROADMA-DEG1','ROADMA-DEG2']
+         self.assertEqual(nbNode,5)
+         listNode=['XPDRA01-XPDR1','ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
          for i in range(0,nbNode):
-             nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
+             nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
              nodeId=res['network'][0]['node'][i]['node-id']
              #Tests related to XPDRA nodes
-             if(nodeId=='XPDRA-XPDR1'):
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
+             if(nodeId=='XPDRA01-XPDR1'):
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
                                res['network'][0]['node'][i]['supporting-node'])
                  self.assertEqual(nodeType,'XPONDER')
                  nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertTrue(nbTps >= 2)
                  client = 0
                  network = 0
                  for j in range(0,nbTps):
-                     tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-network-topology:tp-type']
+                     tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
+                     tpId=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
                      if (tpType=='XPONDER-CLIENT'):
                          client += 1
                      elif (tpType=='XPONDER-NETWORK'):
                          network += 1
-                 self.assertTrue(client > 0)
-                 self.assertTrue(network > 0)
+                     if (tpId == 'XPDR1-NETWORK2'):
+                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-CLIENT3')
+                     if (tpId == 'XPDR1-CLIENT3'):
+                         self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['transportpce-topology:associated-connection-map-port'],'XPDR1-NETWORK2')
+                 self.assertTrue(client == 4)
+                 self.assertTrue(network == 2)
+                 listNode.remove(nodeId)
+             elif(nodeId=='ROADMA01-SRG1'):
+                 #Test related to SRG1
+                 self.assertEqual(nodeType,'SRG')
+                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+                               res['network'][0]['node'][i]['supporting-node'])
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMA-SRG1'):
+             elif(nodeId=='ROADMA01-SRG3'):
                  #Test related to SRG1
                  self.assertEqual(nodeType,'SRG')
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
-                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
+                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
+                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                                res['network'][0]['node'][i]['supporting-node'])
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMA-DEG1'):
+             elif(nodeId=='ROADMA01-DEG1'):
                 #Test related to DEG1
                 self.assertEqual(nodeType,'DEGREE')
-                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                               res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
-             elif(nodeId=='ROADMA-DEG2'):
+             elif(nodeId=='ROADMA01-DEG2'):
                 #Test related to DEG2
                 self.assertEqual(nodeType,'DEGREE')
-                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                               res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
              else:
                 self.assertFalse(True)
          self.assertEqual(len(listNode),0)
 
-
     #Connect the tail XPDRA to ROADMA and vice versa
     def test_10_connect_tail_xpdr_rdm(self):
          #Connect the tail: XPDRA to ROADMA
@@ -397,10 +370,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
                 .format(self.restconf_baseurl))
         data = {"networkutils:input": {
              "networkutils:links-input": {
-               "networkutils:xpdr-node": "XPDRA",
+               "networkutils:xpdr-node": "XPDRA01",
                "networkutils:xpdr-num": "1",
                "networkutils:network-num": "1",
-               "networkutils:rdm-node": "ROADMA",
+               "networkutils:rdm-node": "ROADMA01",
                "networkutils:srg-num": "1",
                "networkutils:termination-point-num": "SRG1-PP1-TXRX"
             }
@@ -419,10 +392,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
                  .format(self.restconf_baseurl))
          data = {"networkutils:input": {
               "networkutils:links-input": {
-                "networkutils:xpdr-node": "XPDRA",
+                "networkutils:xpdr-node": "XPDRA01",
                 "networkutils:xpdr-num": "1",
                 "networkutils:network-num": "1",
-                "networkutils:rdm-node": "ROADMA",
+                "networkutils:rdm-node": "ROADMA01",
                 "networkutils:srg-num": "1",
                 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
              }
@@ -445,14 +418,16 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         #Tests related to links
         nbLink=len(res['network'][0]['ietf-network-topology:link'])
-        self.assertEqual(nbLink,8)
-        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
-        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
-        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
-        XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
-        XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
+        self.assertEqual(nbLink,12)
+        expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
+        addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+                 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
+        dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+                  'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
+        XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
+        XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
         for i in range(0,nbLink):
-            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
+            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
             linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
             if(nodeType=='EXPRESS-LINK'):
                 find= linkId in expressLink
@@ -485,10 +460,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
     def test_13_connect_ROADMC(self):
         #Config ROADMC
         url = ("{}/config/network-topology:"
-                "network-topology/topology/topology-netconf/node/ROADMC"
+                "network-topology/topology/topology-netconf/node/ROADMC01"
                 .format(self.restconf_baseurl))
         data = {"node": [{
-             "node-id": "ROADMC",
+             "node-id": "ROADMC01",
              "netconf-node-topology:username": "admin",
              "netconf-node-topology:password": "admin",
              "netconf-node-topology:host": "127.0.0.1",
@@ -502,7 +477,49 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(response.status_code, requests.codes.created)
         time.sleep(30)
 
-    def test_14_getClliNetwork(self):
+    def test_14_omsAttributes_ROADMA_ROADMC(self):
+        # Config ROADMA-ROADMC oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+            "clfi": "fiber1",
+            "auto-spanloss": "true",
+            "engineered-spanloss": 12.2,
+            "link-concatenation": [{
+                "SRLG-Id": 0,
+                "fiber-type": "smf",
+                "SRLG-length": 100000,
+                "pmd": 0.5}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "PUT", url, data=json.dumps(data), headers=headers,
+            auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+
+    def test_15_omsAttributes_ROADMC_ROADMA(self):
+        # Config ROADMC01-ROADMA oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+            "clfi": "fiber1",
+            "auto-spanloss": "true",
+            "engineered-spanloss": 12.2,
+            "link-concatenation": [{
+                "SRLG-Id": 0,
+                "fiber-type": "smf",
+                "SRLG-length": 100000,
+                "pmd": 0.5}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "PUT", url, data=json.dumps(data), headers=headers,
+            auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+
+    def test_16_getClliNetwork(self):
         url = ("{}/config/ietf-network:networks/network/clli-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -524,7 +541,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
 
         self.assertEqual(len(listNode),0)
 
-    def test_15_getOpenRoadmNetwork(self):
+    def test_17_getOpenRoadmNetwork(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -534,30 +551,30 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         nbNode=len(res['network'][0]['node'])
         self.assertEqual(nbNode,3)
-        listNode=['XPDRA','ROADMA','ROADMC']
+        listNode=['XPDRA01','ROADMA01','ROADMC01']
         for i in range(0,nbNode):
             self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['network-ref'],'clli-network')
             nodeId=res['network'][0]['node'][i]['node-id']
-            if(nodeId=='XPDRA'):
+            if(nodeId=='XPDRA01'):
                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
-                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'XPONDER')
+                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'XPONDER')
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'1')
                 listNode.remove(nodeId)
-            elif(nodeId=='ROADMA'):
+            elif(nodeId=='ROADMA01'):
                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
-                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
+                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
                 listNode.remove(nodeId)
-            elif(nodeId=='ROADMC'):
+            elif(nodeId=='ROADMC01'):
                 self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeC')
-                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:node-type'],'ROADM')
+                self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'ROADM')
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network:model'],'2')
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
         self.assertEqual(len(listNode),0)
 
-    def test_16_getROADMLinkOpenRoadmTopology(self):
+    def test_18_getROADMLinkOpenRoadmTopology(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -567,18 +584,20 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         #Tests related to links
         nbLink=len(res['network'][0]['ietf-network-topology:link'])
-        self.assertEqual(nbLink,16)
-        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX',
-                     'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX','ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX']
-        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',
-                 'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX','ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX']
-        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX',
-                  'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX','ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX']
-        R2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX']
-        XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
-        XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
+        self.assertEqual(nbLink,20)
+        expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX',
+                     'ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX','ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX']
+        addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+                 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+                 'ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG2-DEG2-CTP-TXRX','ROADMC01-SRG1-SRG1-CP-TXRXtoROADMC01-DEG1-DEG1-CTP-TXRX']
+        dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+                  'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX',
+                  'ROADMC01-DEG1-DEG1-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX','ROADMC01-DEG2-DEG2-CTP-TXRXtoROADMC01-SRG1-SRG1-CP-TXRX']
+        R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
+        XPDR_IN=['ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1']
+        XPDR_OUT=['XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX']
         for i in range(0,nbLink):
-            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
+            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
             linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
             if(nodeType=='EXPRESS-LINK'):
                 find= linkId in expressLink
@@ -613,7 +632,35 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(len(XPDR_IN),0)
         self.assertEqual(len(XPDR_OUT),0)
 
-    def test_17_getNodes_OpenRoadmTopology(self):
+    def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+              .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        #Tests related to links
+        nbLink=len(res['network'][0]['ietf-network-topology:link'])
+        self.assertEqual(nbLink,20)
+        R2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
+                 'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX']
+        for i in range(0,nbLink):
+            nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+            link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
+            if(link_id in R2RLink):
+                find = False
+                spanLoss = res['network'][0]['ietf-network-topology:link'][i][
+                    'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
+                length = res['network'][0]['ietf-network-topology:link'][i][
+                    'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                if((spanLoss!=None)&(length!=None)):
+                    find = True
+                self.assertTrue(find)
+                R2RLink.remove(link_id)
+        self.assertEqual(len(R2RLink),0)
+
+    def test_20_getNodes_OpenRoadmTopology(self):
          url = ("{}/config/ietf-network:networks/network/openroadm-topology"
                .format(self.restconf_baseurl))
          headers = {'content-type': 'application/json'}
@@ -623,98 +670,109 @@ class TransportPCETopologyTesting(unittest.TestCase):
          #Tests related to nodes
          self.assertEqual(response.status_code, requests.codes.ok)
          nbNode=len(res['network'][0]['node'])
-         self.assertEqual(nbNode,7)
-         listNode=['XPDRA-XPDR1',
-                   'ROADMA-SRG1','ROADMA-DEG1','ROADMA-DEG2',
-                   'ROADMC-SRG1','ROADMC-DEG1','ROADMC-DEG2']
+         self.assertEqual(nbNode,8)
+         listNode=['XPDRA01-XPDR1',
+                   'ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2',
+                   'ROADMC01-SRG1','ROADMC01-DEG1','ROADMC01-DEG2']
          #************************Tests related to XPDRA nodes
          for i in range(0,nbNode):
-             nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
+             nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
              nodeId=res['network'][0]['node'][i]['node-id']
-             if(nodeId=='XPDRA-XPDR1'):
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
+             if(nodeId=='XPDRA01-XPDR1'):
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
                                res['network'][0]['node'][i]['supporting-node'])
                  self.assertEqual(nodeType,'XPONDER')
                  nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertTrue(nbTps >= 2)
+                 self.assertTrue(nbTps == 6)
                  client = 0
                  network = 0
                  for j in range(0,nbTps):
-                     tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-network-topology:tp-type']
+                     tpType=res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['org-openroadm-common-network:tp-type']
                      if (tpType=='XPONDER-CLIENT'):
                          client += 1
                      elif (tpType=='XPONDER-NETWORK'):
                          network += 1
-                 self.assertTrue(client > 0)
-                 self.assertTrue(network > 0)
+                 self.assertTrue(client == 4)
+                 self.assertTrue(network == 2)
+                 listNode.remove(nodeId)
+             elif(nodeId=='ROADMA01-SRG1'):
+                 #Test related to SRG1
+                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+                               res['network'][0]['node'][i]['supporting-node'])
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMA-SRG1'):
+             elif(nodeId=='ROADMA01-SRG3'):
                  #Test related to SRG1
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
-                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
+                 self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
+                 self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                                res['network'][0]['node'][i]['supporting-node'])
-                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMA-DEG1'):
+             elif(nodeId=='ROADMA01-DEG1'):
                  #Test related to DEG1
-                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                                res['network'][0]['node'][i]['supporting-node'])
-                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMA-DEG2'):
+             elif(nodeId=='ROADMA01-DEG2'):
                  #Test related to DEG2
-                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                                res['network'][0]['node'][i]['supporting-node'])
-                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMC-SRG1'):
+             elif(nodeId=='ROADMC01-SRG1'):
                  #Test related to SRG1
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
-                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
+                 self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
+                 self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
                                res['network'][0]['node'][i]['supporting-node'])
-                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'SRG')
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'SRG')
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMC-DEG1'):
+             elif(nodeId=='ROADMC01-DEG1'):
                  #Test related to DEG1
-                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                 self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                 self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
                                res['network'][0]['node'][i]['supporting-node'])
-                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
                  listNode.remove(nodeId)
-             elif(nodeId=='ROADMC-DEG2'):
+             elif(nodeId=='ROADMC01-DEG2'):
                  #Test related to DEG2
-                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                 self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                 self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                                res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC'},
+                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMC01'},
                                res['network'][0]['node'][i]['supporting-node'])
-                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-network-topology:node-type'],'DEGREE')
+                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-common-network:node-type'],'DEGREE')
                  listNode.remove(nodeId)
              else:
                 self.assertFalse(True)
          self.assertEqual(len(listNode),0)
 
-    def test_18_connect_ROADMB(self):
+    def test_21_connect_ROADMB(self):
         url = ("{}/config/network-topology:"
                 "network-topology/topology/topology-netconf/node/ROADMB"
                .format(self.restconf_baseurl))
@@ -733,7 +791,91 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(response.status_code, requests.codes.created)
         time.sleep(30)
 
-    def test_19_getClliNetwork(self):
+    def test_22_omsAttributes_ROADMA_ROADMB(self):
+        # Config ROADMA-ROADMB oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "clfi": "fiber1",
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "link-concatenation": [{
+                    "SRLG-Id": 0,
+                    "fiber-type": "smf",
+                    "SRLG-length": 100000,
+                    "pmd": 0.5}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+                "PUT", url, data=json.dumps(data), headers=headers,
+                auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+
+    def test_23_omsAttributes_ROADMB_ROADMA(self):
+        # Config ROADMB-ROADMA oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "clfi": "fiber1",
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "link-concatenation": [{
+                    "SRLG-Id": 0,
+                    "fiber-type": "smf",
+                    "SRLG-length": 100000,
+                    "pmd": 0.5}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+                "PUT", url, data=json.dumps(data), headers=headers,
+                auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+
+    def test_24_omsAttributes_ROADMB_ROADMC(self):
+        # Config ROADMB-ROADMC oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "clfi": "fiber1",
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "link-concatenation": [{
+                    "SRLG-Id": 0,
+                    "fiber-type": "smf",
+                    "SRLG-length": 100000,
+                    "pmd": 0.5}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+                "PUT", url, data=json.dumps(data), headers=headers,
+                auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+
+    def test_25_omsAttributes_ROADMC_ROADMB(self):
+        # Config ROADMC01-ROADMB oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "clfi": "fiber1",
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "link-concatenation": [{
+                    "SRLG-Id": 0,
+                    "fiber-type": "smf",
+                    "SRLG-length": 100000,
+                    "pmd": 0.5}]}}
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+                "PUT", url, data=json.dumps(data), headers=headers,
+                auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.created)
+
+    def test_26_getClliNetwork(self):
         url = ("{}/config/ietf-network:networks/network/clli-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -757,7 +899,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
 
         self.assertEqual(len(listNode),0)
 
-    def test_20_verifyDegree(self):
+    def test_27_verifyDegree(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -767,18 +909,18 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         #Tests related to links
         nbLink=len(res['network'][0]['ietf-network-topology:link'])
-        listR2RLink=['ROADMA-DEG1-DEG1-TTP-TXRXtoROADMC-DEG2-DEG2-TTP-TXRX','ROADMC-DEG2-DEG2-TTP-TXRXtoROADMA-DEG1-DEG1-TTP-TXRX',
-           'ROADMA-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
-           'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC-DEG1-DEG1-TTP-TXRX']
+        listR2RLink=['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX','ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
+           'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX','ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
+           'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX','ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
         for i in range(0,nbLink):
-            if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'] == 'ROADM-TO-ROADM':
+            if res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
                 link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
                 find= link_id in listR2RLink
                 self.assertEqual(find, True)
                 listR2RLink.remove(link_id)
         self.assertEqual(len(listR2RLink),0)
 
-    def test_21_verifyOppositeLinkTopology(self):
+    def test_28_verifyOppositeLinkTopology(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
                .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -786,15 +928,12 @@ class TransportPCETopologyTesting(unittest.TestCase):
              "GET", url, headers=headers, auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
-        #Write the response in the log
-        with open('./transportpce_tests/log/response.log', 'a') as outfile1:
-            outfile1.write(str(res))
         #Tests related to links
         nbLink=len(res['network'][0]['ietf-network-topology:link'])
-        self.assertEqual(nbLink,26)
+        self.assertEqual(nbLink,34)
         for i in range(0,nbLink):
             link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
-            link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
+            link_type=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
             link_src=res['network'][0]['ietf-network-topology:link'][i]['source']['source-node']
             link_dest=res['network'][0]['ietf-network-topology:link'][i]['destination']['dest-node']
             oppLink_id=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:opposite-link']
@@ -808,7 +947,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:opposite-link'],link_id)
             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['source']['source-node'],link_dest)
             self.assertEqual(res_oppLink['ietf-network-topology:link'][0]['destination']['dest-node'],link_src)
-            oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-network-topology:link-type']
+            oppLink_type=res_oppLink['ietf-network-topology:link'][0]['org-openroadm-common-network:link-type']
             if link_type=='ADD-LINK':
                 self.assertEqual(oppLink_type, 'DROP-LINK')
             elif link_type=='DROP-LINK':
@@ -823,7 +962,37 @@ class TransportPCETopologyTesting(unittest.TestCase):
                 self.assertEqual(oppLink_type, 'XPONDER-INPUT')
         time.sleep(5)
 
-    def test_22_disconnect_ROADMB(self):
+    def test_29_getLinkOmsAttributesOpenRoadmTopology(self):
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+              .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        nbLink=len(res['network'][0]['ietf-network-topology:link'])
+        R2RLink = ['ROADMA01-DEG1-DEG1-TTP-TXRXtoROADMC01-DEG2-DEG2-TTP-TXRX',
+                       'ROADMC01-DEG2-DEG2-TTP-TXRXtoROADMA01-DEG1-DEG1-TTP-TXRX',
+                       'ROADMA01-DEG2-DEG2-TTP-TXRXtoROADMB-DEG1-DEG1-TTP-TXRX',
+                       'ROADMC01-DEG1-DEG1-TTP-TXRXtoROADMB-DEG2-DEG2-TTP-TXRX',
+                       'ROADMB-DEG1-DEG1-TTP-TXRXtoROADMA01-DEG2-DEG2-TTP-TXRX',
+                       'ROADMB-DEG2-DEG2-TTP-TXRXtoROADMC01-DEG1-DEG1-TTP-TXRX']
+        for i in range(0,nbLink):
+            nodeType = res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']
+            link_id=res['network'][0]['ietf-network-topology:link'][i]['link-id']
+            if(link_id in R2RLink):
+                find = False
+                spanLoss = res['network'][0]['ietf-network-topology:link'][i][
+                    'org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
+                length = res['network'][0]['ietf-network-topology:link'][i][
+                    'org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                if((spanLoss!=None)&(length!=None)):
+                    find = True
+                self.assertTrue(find)
+                R2RLink.remove(link_id)
+        self.assertEqual(len(R2RLink),0)
+
+    def test_30_disconnect_ROADMB(self):
         #Delete in the topology-netconf
         url = ("{}/config/network-topology:"
                 "network-topology/topology/topology-netconf/node/ROADMB"
@@ -843,20 +1012,11 @@ class TransportPCETopologyTesting(unittest.TestCase):
              "DELETE", url, data=json.dumps(data), headers=headers,
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
-        #Delete in the openroadm-network
-#         url = ("{}/config/ietf-network:networks/network/openroadm-network/node/ROADMB"
-#                .format(self.restconf_baseurl))
-#         data = {}
-#         headers = {'content-type': 'application/json'}
-#         response = requests.request(
-#              "DELETE", url, data=json.dumps(data), headers=headers,
-#              auth=('admin', 'admin'))
-#         self.assertEqual(response.status_code, requests.codes.ok)
 
-    def test_23_disconnect_ROADMC(self):
+    def test_31_disconnect_ROADMC(self):
         #Delete in the topology-netconf
         url = ("{}/config/network-topology:"
-                "network-topology/topology/topology-netconf/node/ROADMC"
+                "network-topology/topology/topology-netconf/node/ROADMC01"
                .format(self.restconf_baseurl))
         data = {}
         headers = {'content-type': 'application/json'}
@@ -873,147 +1033,88 @@ class TransportPCETopologyTesting(unittest.TestCase):
              "DELETE", url, data=json.dumps(data), headers=headers,
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
-        #Delete in the openroadm-network
-#         url = ("{}/config/ietf-network:networks/network/openroadm-network/node/ROADMC"
-#                .format(self.restconf_baseurl))
-#         data = {}
-#         headers = {'content-type': 'application/json'}
-#         response = requests.request(
-#              "DELETE", url, data=json.dumps(data), headers=headers,
-#              auth=('admin', 'admin'))
-#         self.assertEqual(response.status_code, requests.codes.ok)
 
-#    def test_24_getLinks_OpenRoadmTopology(self):
-#        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
-#               .format(self.restconf_baseurl))
-#        headers = {'content-type': 'application/json'}
-#        response = requests.request(
-#             "GET", url, headers=headers, auth=('admin', 'admin'))
-#        self.assertEqual(response.status_code, requests.codes.ok)
-#        res = response.json()
-#        #Write the response in the log
-#        with open('./transportpce_tests/log/response.log', 'a') as outfile1:
-#            outfile1.write(str(res))
-#        #Tests related to links
-#        nbLink=len(res['network'][0]['ietf-network-topology:link'])
-#        self.assertEqual(nbLink,8)
-#        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
-#        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX',]
-#        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
-#        XPDR_IN=['ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1']
-#        XPDR_OUT=['XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX']
-#        for i in range(0,nbLink):
-#            nodeType=res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']
-#            linkId=res['network'][0]['ietf-network-topology:link'][i]['link-id']
-#            if(nodeType=='EXPRESS-LINK'):
-#                find= linkId in expressLink
-#                self.assertEqual(find, True)
-#                expressLink.remove(linkId)
-#            elif(nodeType=='ADD-LINK'):
-#                find= linkId in addLink
-#                self.assertEqual(find, True)
-#                addLink.remove(linkId)
-#            elif(nodeType=='DROP-LINK'):
-#                find= linkId in dropLink
-#                self.assertEqual(find, True)
-#                dropLink.remove(linkId)
-#            elif(nodeType=='XPONDER-INPUT'):
-#                find= linkId in XPDR_IN
-#                self.assertEqual(find, True)
-#                XPDR_IN.remove(linkId)
-#            elif(nodeType=='XPONDER-OUTPUT'):
-#                find= linkId in XPDR_OUT
-#                self.assertEqual(find, True)
-#                XPDR_OUT.remove(linkId)
-#            else:
-#                self.assertFalse(True)
-#        self.assertEqual(len(expressLink),0)
-#        self.assertEqual(len(addLink),0)
-#        self.assertEqual(len(dropLink),0)
-#        self.assertEqual(len(XPDR_IN),0)
-#        self.assertEqual(len(XPDR_OUT),0)
-#
-#        for i in range(0,nbLink):
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'ROADM-TO-ROADM')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-SRG1-SRG1-CP-TXRXtoROADMC-DEG2-DEG1-CTP-TXRX')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG2-CTP-TXRXtoROADMC-SRG1-SRG1-CP-TXRX')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG1-DEG1-CTP-TXRXtoROADMC-DEG2-DEG2-CTP-TXRX')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['link-id'],'ROADMC-DEG2-DEG2-CTP-TXRXtoROADMC-DEG1-DEG1-CTP-TXRX')
-#
-#    def test_25_getNodes_OpenRoadmTopology(self):
-#        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
-#              .format(self.restconf_baseurl))
-#        headers = {'content-type': 'application/json'}
-#        response = requests.request(
-#            "GET", url, headers=headers, auth=('admin', 'admin'))
-#        res = response.json()
-#        #Tests related to nodes
-#        self.assertEqual(response.status_code, requests.codes.ok)
-#        with open('./transportpce_tests/log/response.log', 'a') as outfile1:
-#            outfile1.write(str(len(res['network'][0]['node'])))
-#        nbNode=len(res['network'][0]['node'])
-#        self.assertEqual(nbNode,4)
-#        listNode=['XPDRA-XPDR1','ROADMA-SRG1','ROADMA-DEG1','ROADMA-DEG2']
-#        for i in range(0,nbNode):
-#            nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
-#            nodeId=res['network'][0]['node'][i]['node-id']
-#            #Tests related to XPDRA nodes
-#            if(nodeId=='XPDRA-XPDR1'):
-#                self.assertEqual(nodeType,'XPONDER')
-#                self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),2)
-#                self.assertEqual({'tp-id': 'XPDR1-CLIENT1', 'org-openroadm-network-topology:tp-type': 'XPONDER-CLIENT',
-#                                  'org-openroadm-network-topology:xpdr-network-attributes': {
-#                                      'tail-equipment-id': 'XPDR1-NETWORK1'}},
-#                                 res['network'][0]['node'][i]['ietf-network-topology:termination-point'][0])
-#                self.assertEqual({'tp-id': 'XPDR1-NETWORK1', 'org-openroadm-network-topology:tp-type': 'XPONDER-NETWORK',
-#                                  'org-openroadm-network-topology:xpdr-client-attributes': {'tail-equipment-id': 'XPDR1-CLIENT1'}},
-#                                 res['network'][0]['node'][i]['ietf-network-topology:termination-point'][1])
-#                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA'},
-#                    res['network'][0]['node'][i]['supporting-node'])
-#                listNode.remove(nodeId)
-#            elif(nodeId=='ROADMA-SRG1'):
-#                #Test related to SRG1
-#                self.assertEqual(nodeType,'SRG')
-#                self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
-#                self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
-#                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-#                self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
-#                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-#                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
-#                              res['network'][0]['node'][i]['supporting-node'])
-#                listNode.remove(nodeId)
-#            elif(nodeId=='ROADMA-DEG1'):
-#                #Test related to DEG1
-#                self.assertEqual(nodeType,'DEGREE')
-#                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
-#                    res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-#                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
-#                    res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-#                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
-#                    res['network'][0]['node'][i]['supporting-node'])
-#                listNode.remove(nodeId)
-#            elif(nodeId=='ROADMA-DEG2'):
-#                #Test related to DEG2
-#                self.assertEqual(nodeType,'DEGREE')
-#                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
-#                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-#                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
-#                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-#                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
-#                              res['network'][0]['node'][i]['supporting-node'])
-#                listNode.remove(nodeId)
-#            else:
-#                self.assertFalse(True)
-#        self.assertEqual(len(listNode),0)
-#        #Test related to SRG1 of ROADMC
-#        for i in range(0,nbNode):
-#            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-SRG1')
-#            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG1')
-#            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC-DEG2')
+    def test_32_getNodes_OpenRoadmTopology(self):
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+              .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        res = response.json()
+        #Tests related to nodes
+        self.assertEqual(response.status_code, requests.codes.ok)
+        nbNode=len(res['network'][0]['node'])
+        self.assertEqual(nbNode,5)
+        listNode=['XPDRA01-XPDR1','ROADMA01-SRG1', 'ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
+        for i in range(0,nbNode):
+            nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
+            nodeId=res['network'][0]['node'][i]['node-id']
+            #Tests related to XPDRA nodes
+            if(nodeId=='XPDRA01-XPDR1'):
+                nbTp = len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                for j in range(0, nbTp):
+                    tpid = res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]['tp-id']
+                    if (tpid == 'XPDR1-CLIENT1'):
+                        self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+                                         ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
+                        self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+                                         ['org-openroadm-network-topology:xpdr-client-attributes']['tail-equipment-id'],
+                                         'XPDR1-NETWORK1')
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDRA01'},
+                    res['network'][0]['node'][i]['supporting-node'])
+                listNode.remove(nodeId)
+            elif(nodeId=='ROADMA01-SRG1'):
+                #Test related to SRG1
+                self.assertEqual(nodeType,'SRG')
+                self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+                self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                listNode.remove(nodeId)
+            elif(nodeId=='ROADMA01-SRG3'):
+                #Test related to SRG1
+                self.assertEqual(nodeType,'SRG')
+                self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+                self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                listNode.remove(nodeId)
+            elif(nodeId=='ROADMA01-DEG1'):
+                #Test related to DEG1
+                self.assertEqual(nodeType,'DEGREE')
+                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+                    res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+                    res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+                    res['network'][0]['node'][i]['supporting-node'])
+                listNode.remove(nodeId)
+            elif(nodeId=='ROADMA01-DEG2'):
+                #Test related to DEG2
+                self.assertEqual(nodeType,'DEGREE')
+                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                listNode.remove(nodeId)
+            else:
+                self.assertFalse(True)
+        self.assertEqual(len(listNode),0)
+        #Test related to SRG1 of ROADMC
+        for i in range(0,nbNode):
+            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-SRG1')
+            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG1')
+            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01-DEG2')
 
-    def test_26_getOpenRoadmNetwork(self):
+    def test_33_getOpenRoadmNetwork(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1024,9 +1125,10 @@ class TransportPCETopologyTesting(unittest.TestCase):
         nbNode=len(res['network'][0]['node'])
         self.assertEqual(nbNode,2)
         for i in range(0,nbNode-1):
-            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC')
+            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMC01')
+            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADMB')
 
-    def test_27_getClliNetwork(self):
+    def test_34_getClliNetwork(self):
         url = ("{}/config/ietf-network:networks/network/clli-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1039,9 +1141,9 @@ class TransportPCETopologyTesting(unittest.TestCase):
         for i in range(0,nbNode-1):
             self.assertNotEqual(res['network'][0]['node'][1]['org-openroadm-clli-network:clli'],'NodeC')
 
-    def test_28_disconnect_XPDRA(self):
+    def test_35_disconnect_XPDRA(self):
         url = ("{}/config/network-topology:"
-               "network-topology/topology/topology-netconf/node/XPDRA"
+               "network-topology/topology/topology-netconf/node/XPDRA01"
               .format(self.restconf_baseurl))
         data = {}
         headers = {'content-type': 'application/json'}
@@ -1049,17 +1151,8 @@ class TransportPCETopologyTesting(unittest.TestCase):
             "DELETE", url, data=json.dumps(data), headers=headers,
             auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
-        #Delete in the openroadm-network
-#         url = ("{}/config/ietf-network:networks/network/openroadm-network/node/XPDRA"
-#                .format(self.restconf_baseurl))
-#         data = {}
-#         headers = {'content-type': 'application/json'}
-#         response = requests.request(
-#              "DELETE", url, data=json.dumps(data), headers=headers,
-#              auth=('admin', 'admin'))
-#         self.assertEqual(response.status_code, requests.codes.ok)
 
-    def test_29_getClliNetwork(self):
+    def test_36_getClliNetwork(self):
         url = ("{}/config/ietf-network:networks/network/clli-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1071,7 +1164,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(nbNode,1)
         self.assertEqual(res['network'][0]['node'][0]['org-openroadm-clli-network:clli'],'NodeA')
 
-    def test_30_getOpenRoadmNetwork(self):
+    def test_37_getOpenRoadmNetwork(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1082,9 +1175,9 @@ class TransportPCETopologyTesting(unittest.TestCase):
         nbNode=len(res['network'][0]['node'])
         self.assertEqual(nbNode,1)
         for i in range(0,nbNode):
-            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA')
+            self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDRA01')
 
-    def test_31_getNodes_OpenRoadmTopology(self):
+    def test_38_getNodes_OpenRoadmTopology(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1094,46 +1187,55 @@ class TransportPCETopologyTesting(unittest.TestCase):
         #Tests related to nodes
         self.assertEqual(response.status_code, requests.codes.ok)
         nbNode=len(res['network'][0]['node'])
-        self.assertEqual(nbNode,3)
-        listNode=['ROADMA-SRG1','ROADMA-DEG1','ROADMA-DEG2']
+        self.assertEqual(nbNode,4)
+        listNode=['ROADMA01-SRG1','ROADMA01-SRG3','ROADMA01-DEG1','ROADMA01-DEG2']
         for i in range(0,nbNode):
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA'},
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADMA01'},
                           res['network'][0]['node'][i]['supporting-node'])
-            nodeType=res['network'][0]['node'][i]['org-openroadm-network-topology:node-type']
+            nodeType=res['network'][0]['node'][i]['org-openroadm-common-network:node-type']
             nodeId=res['network'][0]['node'][i]['node-id']
-            if(nodeId=='ROADMA-SRG1'):
+            if(nodeId=='ROADMA01-SRG1'):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
-                self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-CP'},
+                self.assertIn({'tp-id': 'SRG1-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-network-topology:tp-type': 'SRG-TXRX-PP'},
+                self.assertIn({'tp-id': 'SRG1-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                 listNode.remove(nodeId)
-            elif(nodeId=='ROADMA-DEG1'):
+            elif(nodeId=='ROADMA01-SRG3'):
+                #Test related to SRG1
+                self.assertEqual(nodeType,'SRG')
+                self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),17)
+                self.assertIn({'tp-id': 'SRG3-CP-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-CP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                self.assertIn({'tp-id': 'SRG3-PP1-TXRX', 'org-openroadm-common-network:tp-type': 'SRG-TXRX-PP'},
+                              res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
+                listNode.remove(nodeId)
+            elif(nodeId=='ROADMA01-DEG1'):
                 #Test related to DEG1
                 self.assertEqual(nodeType,'DEGREE')
-                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                self.assertIn({'tp-id': 'DEG1-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                self.assertIn({'tp-id': 'DEG1-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                 listNode.remove(nodeId)
-            elif(nodeId=='ROADMA-DEG2'):
+            elif(nodeId=='ROADMA01-DEG2'):
                 #Test related to DEG2
                 self.assertEqual(nodeType,'DEGREE')
-                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-TTP'},
+                self.assertIn({'tp-id': 'DEG2-TTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-TTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
-                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-network-topology:tp-type': 'DEGREE-TXRX-CTP'},
+                self.assertIn({'tp-id': 'DEG2-CTP-TXRX', 'org-openroadm-common-network:tp-type': 'DEGREE-TXRX-CTP'},
                               res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
         self.assertEqual(len(listNode),0)
 
-    def test_32_disconnect_ROADM_XPDRA_link(self):
+    def test_39_disconnect_ROADM_XPDRA_link(self):
         #Link-1
         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
-               "link/XPDRA-XPDR1-XPDR1-NETWORK1toROADMA-SRG1-SRG1-PP1-TXRX"
+               "link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
                 .format(self.restconf_baseurl))
         data = {}
         headers = {'content-type': 'application/json'}
@@ -1143,7 +1245,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
         self.assertEqual(response.status_code, requests.codes.ok)
         #Link-2
         url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
-               "link/ROADMA-SRG1-SRG1-PP1-TXRXtoXPDRA-XPDR1-XPDR1-NETWORK1"
+               "link/ROADMA01-SRG1-SRG1-PP1-TXRXtoXPDRA01-XPDR1-XPDR1-NETWORK1"
                 .format(self.restconf_baseurl))
         data = {}
         headers = {'content-type': 'application/json'}
@@ -1152,47 +1254,51 @@ class TransportPCETopologyTesting(unittest.TestCase):
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
 
-#    def test_33_getLinks_OpenRoadmTopology(self):
-#        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
-#              .format(self.restconf_baseurl))
-#        headers = {'content-type': 'application/json'}
-#        response = requests.request(
-#            "GET", url, headers=headers, auth=('admin', 'admin'))
-#        self.assertEqual(response.status_code, requests.codes.ok)
-#        res = response.json()
-#        nbLink=len(res['network'][0]['ietf-network-topology:link'])
-#        self.assertEqual(nbLink,6)
-#        expressLink=['ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX','ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX']
-#        addLink=['ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG2-DEG2-CTP-TXRX','ROADMA-SRG1-SRG1-CP-TXRXtoROADMA-DEG1-DEG1-CTP-TXRX']
-#        dropLink=['ROADMA-DEG1-DEG1-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX','ROADMA-DEG2-DEG2-CTP-TXRXtoROADMA-SRG1-SRG1-CP-TXRX']
-#        for i in range(0,nbLink):
-#            if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='EXPRESS-LINK'):
-#                link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
-#                find= link_id in expressLink
-#                self.assertEqual(find, True)
-#                expressLink.remove(link_id)
-#            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='ADD-LINK'):
-#                link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
-#                find= link_id in addLink
-#                self.assertEqual(find, True)
-#                addLink.remove(link_id)
-#            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type']=='DROP-LINK'):
-#                link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
-#                find= link_id in dropLink
-#                self.assertEqual(find, True)
-#                dropLink.remove(link_id)
-#            else:
-#                self.assertFalse(True)
-#        self.assertEqual(len(expressLink),0)
-#        self.assertEqual(len(addLink),0)
-#        self.assertEqual(len(dropLink),0)
-#        for i in range(0,nbLink):
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-OUTPUT')
-#            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
+    def test_40_getLinks_OpenRoadmTopology(self):
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+              .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        nbLink=len(res['network'][0]['ietf-network-topology:link'])
+        self.assertEqual(nbLink,16)
+        expressLink=['ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX','ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX']
+        addLink=['ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG1-SRG1-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX',
+                 'ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG2-DEG2-CTP-TXRX','ROADMA01-SRG3-SRG3-CP-TXRXtoROADMA01-DEG1-DEG1-CTP-TXRX']
+        dropLink=['ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG1-SRG1-CP-TXRX',
+                  'ROADMA01-DEG1-DEG1-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX','ROADMA01-DEG2-DEG2-CTP-TXRXtoROADMA01-SRG3-SRG3-CP-TXRX']
+        roadmtoroadmLink = 0
+        for i in range(0,nbLink):
+            if (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='EXPRESS-LINK'):
+                link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+                find= link_id in expressLink
+                self.assertEqual(find, True)
+                expressLink.remove(link_id)
+            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='ADD-LINK'):
+                link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+                find= link_id in addLink
+                self.assertEqual(find, True)
+                addLink.remove(link_id)
+            elif (res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type']=='DROP-LINK'):
+                link_id = res['network'][0]['ietf-network-topology:link'][i]['link-id']
+                find= link_id in dropLink
+                self.assertEqual(find, True)
+                dropLink.remove(link_id)
+            else:
+                roadmtoroadmLink += 1
+        self.assertEqual(len(expressLink),0)
+        self.assertEqual(len(addLink),0)
+        self.assertEqual(len(dropLink),0)
+        self.assertEqual(roadmtoroadmLink, 6)
+        for i in range(0,nbLink):
+            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-OUTPUT')
+            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-common-network:link-type'],'XPONDER-INPUT')
 
-    def test_34_disconnect_ROADMA(self):
+    def test_41_disconnect_ROADMA(self):
         url = ("{}/config/network-topology:"
-                "network-topology/topology/topology-netconf/node/ROADMA"
+                "network-topology/topology/topology-netconf/node/ROADMA01"
                .format(self.restconf_baseurl))
         data = {}
         headers = {'content-type': 'application/json'}
@@ -1209,18 +1315,8 @@ class TransportPCETopologyTesting(unittest.TestCase):
              "DELETE", url, data=json.dumps(data), headers=headers,
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
-        #Delete in the openroadm-network
-#         url = ("{}/config/ietf-network:networks/network/openroadm-network/node/ROADMA"
-#                .format(self.restconf_baseurl))
-#         data = {}
-#         headers = {'content-type': 'application/json'}
-#         response = requests.request(
-#              "DELETE", url, data=json.dumps(data), headers=headers,
-#              auth=('admin', 'admin'))
-#         self.assertEqual(response.status_code, requests.codes.ok)
-#         time.sleep(5)
 
-    def test_35_getClliNetwork(self):
+    def test_42_getClliNetwork(self):
         url = ("{}/config/ietf-network:networks/network/clli-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1230,7 +1326,7 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         self.assertNotIn('node', res['network'][0])
 
-    def test_36_getOpenRoadmNetwork(self):
+    def test_43_getOpenRoadmNetwork(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-network"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1240,18 +1336,17 @@ class TransportPCETopologyTesting(unittest.TestCase):
         res = response.json()
         self.assertNotIn('node', res['network'][0])
 
-#    def test_37_getOpenRoadmTopology(self):
-#        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
-#              .format(self.restconf_baseurl))
-#        headers = {'content-type': 'application/json'}
-#        response = requests.request(
-#            "GET", url, headers=headers, auth=('admin', 'admin'))
-#        self.assertEqual(response.status_code, requests.codes.ok)
-#        res = response.json()
-#        self.assertNotIn('node', res['network'][0])
-#        self.assertNotIn('ietf-network-topology:link', res['network'][0])
+    def test_44_check_roadm2roadm_link_persistence(self):
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology"
+              .format(self.restconf_baseurl))
+        headers = {'content-type': 'application/json'}
+        response = requests.request(
+            "GET", url, headers=headers, auth=('admin', 'admin'))
+        self.assertEqual(response.status_code, requests.codes.ok)
+        res = response.json()
+        nbLink=len(res['network'][0]['ietf-network-topology:link'])
+        self.assertNotIn('node', res['network'][0])
+        self.assertEqual(nbLink, 6)
 
 if __name__ == "__main__":
-    #logging.basicConfig(filename='./transportpce_tests/log/response.log',filemode='w',level=logging.DEBUG)
-    #logging.debug('I am there')
     unittest.main(verbosity=2)