Code Review / transportpce.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Update config files and tests
[transportpce.git] / tests / transportpce_tests / 2.2.1 / test_topology.py
diff --git a/tests/transportpce_tests/2.2.1/test_topology.py b/tests/transportpce_tests/2.2.1/test_topology.py
index 115f30ea725834635d3fdf93861176df4d1e771d..9d299df752a46e33fa4f4710de62c31138e5aacc 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test_topology.py
+++ b/tests/transportpce_tests/2.2.1/test_topology.py
@@ -86,7 +86,7 @@ class TransportPCEtesting(unittest.TestCase):
 
 
     def setUp(self):
-        time.sleep(30)
+        time.sleep(5)
 
 #END_IGNORE_XTESTING
 
@@ -133,7 +133,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(res['network'][0]['node'][0]['node-id'],'ROADM-A1')
         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'],'model2')
 
     def test_04_getLinks_OpenroadmTopology(self):
@@ -159,15 +159,15 @@ class TransportPCEtesting(unittest.TestCase):
                   'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-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)
@@ -192,41 +192,57 @@ class TransportPCEtesting(unittest.TestCase):
         for i in range(0,nbNode):
             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
                           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=='ROADM-A1-SRG1'):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                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': 'clli-network', 'node-ref': 'NodeA'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+                              res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
             elif(nodeId=='ROADM-A1-SRG3'):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                self.assertIn({'tp-id': 'SRG3-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': 'SRG3-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': 'clli-network', 'node-ref': 'NodeA'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+                              res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
             elif(nodeId=='ROADM-A1-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': 'clli-network', 'node-ref': 'NodeA'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+                              res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
             elif(nodeId=='ROADM-A1-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': 'clli-network', 'node-ref': 'NodeA'},
+                              res['network'][0]['node'][i]['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
+                              res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
@@ -277,10 +293,10 @@ class TransportPCEtesting(unittest.TestCase):
              self.assertEqual(res['network'][0]['node'][i]['supporting-node'][0]['node-ref'],'NodeA')
              nodeId=res['network'][0]['node'][i]['node-id']
              if(nodeId=='XPDR-A1'):
-                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'],'model2')
              elif(nodeId=='ROADM-A1'):
-                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'],'model2')
              else:
                 self.assertFalse(True)
@@ -298,18 +314,20 @@ class TransportPCEtesting(unittest.TestCase):
          self.assertEqual(nbNode,5)
          listNode=['XPDR-A1-XPDR1','ROADM-A1-SRG1','ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-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=='XPDR-A1-XPDR1'):
                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
                                res['network'][0]['node'][i]['supporting-node'])
+                 self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'},
+                               res['network'][0]['node'][i]['supporting-node'])
                  self.assertEqual(nodeType,'XPONDER')
                  nbTps=len(res['network'][0]['node'][i]['ietf-network-topology:termination-point'])
                  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
@@ -329,9 +347,9 @@ class TransportPCEtesting(unittest.TestCase):
                  #Test related to SRG1
                  self.assertEqual(nodeType,'SRG')
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                 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': 'ROADM-A1'},
                                res['network'][0]['node'][i]['supporting-node'])
@@ -340,9 +358,9 @@ class TransportPCEtesting(unittest.TestCase):
                  #Test related to SRG1
                  self.assertEqual(nodeType,'SRG')
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                 self.assertIn({'tp-id': 'SRG3-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': 'SRG3-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': 'ROADM-A1'},
                                res['network'][0]['node'][i]['supporting-node'])
@@ -350,9 +368,9 @@ class TransportPCEtesting(unittest.TestCase):
              elif(nodeId=='ROADM-A1-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': 'ROADM-A1'},
                               res['network'][0]['node'][i]['supporting-node'])
@@ -360,9 +378,9 @@ class TransportPCEtesting(unittest.TestCase):
              elif(nodeId=='ROADM-A1-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': 'ROADM-A1'},
                               res['network'][0]['node'][i]['supporting-node'])
@@ -392,7 +410,6 @@ class TransportPCEtesting(unittest.TestCase):
               "POST", url, data=json.dumps(data), headers=headers,
               auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
-        time.sleep(10)
 
     def test_11_connect_tail_rdm_xpdr(self):
          #Connect the tail: ROADMA to XPDRA
@@ -407,14 +424,13 @@ class TransportPCEtesting(unittest.TestCase):
                 "networkutils:srg-num": "1",
                 "networkutils:termination-point-num": "SRG1-PP1-TXRX"
              }
-            }
+           }
          }
          headers = {'content-type': 'application/json'}
          response = requests.request(
                "POST", url, data=json.dumps(data), headers=headers,
                auth=('admin', 'admin'))
          self.assertEqual(response.status_code, requests.codes.ok)
-         time.sleep(10)
 
     def test_12_getLinks_OpenRoadmTopology(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
@@ -435,7 +451,7 @@ class TransportPCEtesting(unittest.TestCase):
         XPDR_IN=['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
         XPDR_OUT=['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-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
@@ -483,9 +499,50 @@ class TransportPCEtesting(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_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/ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+            "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 ROADM-C1-ROADM-A1 oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+            "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'}
@@ -504,10 +561,9 @@ class TransportPCEtesting(unittest.TestCase):
             else:
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
             listNode.remove(nodeId)
-
         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'}
@@ -523,24 +579,24 @@ class TransportPCEtesting(unittest.TestCase):
             nodeId=res['network'][0]['node'][i]['node-id']
             if(nodeId=='XPDR-A1'):
                 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'],'model2')
                 listNode.remove(nodeId)
             elif(nodeId=='ROADM-A1'):
                 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'],'model2')
                 listNode.remove(nodeId)
             elif(nodeId=='ROADM-C1'):
                 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'],'model2')
                 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'}
@@ -563,7 +619,7 @@ class TransportPCEtesting(unittest.TestCase):
         XPDR_IN=['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1']
         XPDR_OUT=['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-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
@@ -598,7 +654,35 @@ class TransportPCEtesting(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=['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
+                 'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-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'}
@@ -614,7 +698,7 @@ class TransportPCEtesting(unittest.TestCase):
                    'ROADM-C1-SRG1','ROADM-C1-DEG1', 'ROADM-C1-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=='XPDR-A1-XPDR1'):
                  self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
@@ -625,7 +709,7 @@ class TransportPCEtesting(unittest.TestCase):
                  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'):
@@ -636,81 +720,81 @@ class TransportPCEtesting(unittest.TestCase):
              elif(nodeId=='ROADM-A1-SRG1'):
                  #Test related to SRG1
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                 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': 'ROADM-A1'},
                                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=='ROADM-A1-SRG3'):
                  #Test related to SRG1
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                 self.assertIn({'tp-id': 'SRG3-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': 'SRG3-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': 'ROADM-A1'},
                                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=='ROADM-A1-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': 'ROADM-A1'},
                                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=='ROADM-A1-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': 'ROADM-A1'},
                                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=='ROADM-C1-SRG1'):
                  #Test related to SRG1
                  self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                 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': 'ROADM-C1'},
                                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=='ROADM-C1-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': 'ROADM-C1'},
                                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=='ROADM-C1-DEG2'):
                  #Test related to DEG1
-                 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': 'ROADM-C1'},
                                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/ROADM-B1"
                .format(self.restconf_baseurl))
@@ -727,9 +811,95 @@ class TransportPCEtesting(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_22_omsAttributes_ROADMA_ROADMB(self):
+        # Config ROADM-A1-ROADM-B1 oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "spanloss-current": 12,
+                "spanloss-base": 11.4,
+                "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 ROADM-B1-ROADM-A1 oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "spanloss-current": 12,
+                "spanloss-base": 11.4,
+                "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 ROADM-B1-ROADM-C1 oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "auto-spanloss": "true",
+                "engineered-spanloss": 12.2,
+                "spanloss-current": 12,
+                "spanloss-base": 11.4,
+                "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_19_getClliNetwork(self):
+    def test_25_omsAttributes_ROADMC_ROADMB(self):
+        # Config ROADM-C1-ROADM-B1 oms-attributes
+        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:"
+               "link/ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX/org-openroadm-network-topology:"
+               "OMS-attributes/span"
+               .format(self.restconf_baseurl))
+        data = {"span": {
+                "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'}
@@ -750,10 +920,9 @@ class TransportPCEtesting(unittest.TestCase):
             else:
                 self.assertEqual(res['network'][0]['node'][i]['org-openroadm-clli-network:clli'],'NodeC')
             listNode.remove(nodeId)
-
         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,14 +936,14 @@ class TransportPCEtesting(unittest.TestCase):
            'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX','ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
            'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX','ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-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'}
@@ -787,7 +956,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(nbLink,26)
         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']
@@ -801,7 +970,7 @@ class TransportPCEtesting(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':
@@ -814,9 +983,38 @@ class TransportPCEtesting(unittest.TestCase):
                 self.assertEqual(oppLink_type, 'XPONDER-OUTPUT')
             elif link_type=='XPONDER-OUTPUT':
                 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 = ['ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX',
+                       'ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX',
+                       'ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX',
+                       'ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX',
+                       'ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX',
+                       'ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-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/ROADM-B1"
@@ -837,7 +1035,7 @@ class TransportPCEtesting(unittest.TestCase):
              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/ROADM-C1"
@@ -878,7 +1076,7 @@ class TransportPCEtesting(unittest.TestCase):
 #        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']
+#            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
@@ -909,7 +1107,7 @@ class TransportPCEtesting(unittest.TestCase):
 #        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]['org-openroadm-common-network: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')
@@ -917,7 +1115,7 @@ class TransportPCEtesting(unittest.TestCase):
 #            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):
+    def test_32_getNodes_OpenRoadmTopology(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -930,7 +1128,7 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(nbNode,5)
         listNode=['XPDR-A1-XPDR1','ROADM-A1-SRG1', 'ROADM-A1-SRG3','ROADM-A1-DEG1','ROADM-A1-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=='XPDR-A1-XPDR1'):
@@ -939,10 +1137,13 @@ class TransportPCEtesting(unittest.TestCase):
                     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-network-topology:tp-type'], 'XPONDER-CLIENT')
+                                         ['org-openroadm-common-network:tp-type'], 'XPONDER-CLIENT')
+                    if (tpid == 'XPDR1-NETWORK1'):
+                        self.assertEqual(res['network'][0]['node'][i]['ietf-network-topology:termination-point'][j]
+                                         ['org-openroadm-common-network:tp-type'], 'XPONDER-NETWORK')
                         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')
+                                         ['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id'],
+                                         'ROADM-A1-SRG1--SRG1-PP1-TXRX')
                 self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'},
                     res['network'][0]['node'][i]['supporting-node'])
                 listNode.remove(nodeId)
@@ -950,9 +1151,9 @@ class TransportPCEtesting(unittest.TestCase):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                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': 'ROADM-A1'},
                               res['network'][0]['node'][i]['supporting-node'])
@@ -961,9 +1162,9 @@ class TransportPCEtesting(unittest.TestCase):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                self.assertIn({'tp-id': 'SRG3-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': 'SRG3-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': 'ROADM-A1'},
                               res['network'][0]['node'][i]['supporting-node'])
@@ -971,9 +1172,9 @@ class TransportPCEtesting(unittest.TestCase):
             elif(nodeId=='ROADM-A1-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': 'ROADM-A1'},
                     res['network'][0]['node'][i]['supporting-node'])
@@ -981,9 +1182,9 @@ class TransportPCEtesting(unittest.TestCase):
             elif(nodeId=='ROADM-A1-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': 'ROADM-A1'},
                               res['network'][0]['node'][i]['supporting-node'])
@@ -997,7 +1198,7 @@ class TransportPCEtesting(unittest.TestCase):
             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-DEG1')
             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1-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'}
@@ -1011,7 +1212,7 @@ class TransportPCEtesting(unittest.TestCase):
             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-C1')
             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'ROADM-B1')
 
-    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'}
@@ -1024,7 +1225,7 @@ class TransportPCEtesting(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/XPDR-A1"
               .format(self.restconf_baseurl))
@@ -1035,7 +1236,7 @@ class TransportPCEtesting(unittest.TestCase):
             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'}
@@ -1047,7 +1248,7 @@ class TransportPCEtesting(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'}
@@ -1060,7 +1261,7 @@ class TransportPCEtesting(unittest.TestCase):
         for i in range(0,nbNode):
             self.assertNotEqual(res['network'][0]['node'][i]['node-id'],'XPDR-A1')
 
-    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'}
@@ -1075,47 +1276,47 @@ class TransportPCEtesting(unittest.TestCase):
         for i in range(0,nbNode):
             self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'},
                           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=='ROADM-A1-SRG1'):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                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=='ROADM-A1-SRG3'):
                 #Test related to SRG1
                 self.assertEqual(nodeType,'SRG')
                 self.assertEqual(len(res['network'][0]['node'][i]['ietf-network-topology:termination-point']),5)
-                self.assertIn({'tp-id': 'SRG3-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': 'SRG3-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=='ROADM-A1-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=='ROADM-A1-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/XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX"
@@ -1137,7 +1338,7 @@ class TransportPCEtesting(unittest.TestCase):
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
 
-    def test_33_getLinks_OpenRoadmTopology(self):
+    def test_40_getLinks_OpenRoadmTopology(self):
         url = ("{}/config/ietf-network:networks/network/openroadm-topology"
               .format(self.restconf_baseurl))
         headers = {'content-type': 'application/json'}
@@ -1154,17 +1355,17 @@ class TransportPCEtesting(unittest.TestCase):
                   'ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX','ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
         roadmtoroadmLink = 0
         for i in range(0,nbLink):
-            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'):
                 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'):
+            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-network-topology:link-type']=='DROP-LINK'):
+            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)
@@ -1176,10 +1377,10 @@ class TransportPCEtesting(unittest.TestCase):
         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-network-topology:link-type'],'XPONDER-OUTPUT')
-            self.assertNotEqual(res['network'][0]['ietf-network-topology:link'][i]['org-openroadm-network-topology:link-type'],'XPONDER-INPUT')
+            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/ROADM-A1"
                .format(self.restconf_baseurl))
@@ -1199,7 +1400,7 @@ class TransportPCEtesting(unittest.TestCase):
              auth=('admin', 'admin'))
         self.assertEqual(response.status_code, requests.codes.ok)
 
-    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'}
@@ -1209,7 +1410,7 @@ class TransportPCEtesting(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'}
@@ -1219,7 +1420,7 @@ class TransportPCEtesting(unittest.TestCase):
         res = response.json()
         self.assertNotIn('node', res['network'][0])
 
-    def test_37_check_roadm2roadm_link_persistence(self):
+    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'}
Repository for Transport PCE project.