Refactor func tests transportpce api rpc calls 2/2

[transportpce.git] / tests / transportpce_tests / 2.2.1 / test03_topology.py

diff --git a/tests/transportpce_tests/2.2.1/test03_topology.py b/tests/transportpce_tests/2.2.1/test03_topology.py
index 4e084f336519fdb86d96bf81ae5c3c066da9c96b..88ae14f69ea583e11aef79472de9071e62eaf1e0 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test03_topology.py
+++ b/tests/transportpce_tests/2.2.1/test03_topology.py
@@ -22,7 +22,6 @@ import sys
 sys.path.append('transportpce_tests/common/')
 # pylint: disable=wrong-import-position
 # pylint: disable=import-error
-import test_utils  # nopep8
 import test_utils_rfc8040  # nopep8
 
 
@@ -150,15 +149,15 @@ 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']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_05_getNodes_OpenRoadmTopology(self):
         # pylint: disable=redundant-unittest-assert
@@ -166,18 +165,18 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 4)
         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             self.assertIn(nodeId, self.CHECK_DICT1)
             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-            for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                self.assertIn(item, val['ietf-network-topology:termination-point'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+            for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                self.assertIn(tp, node['ietf-network-topology:termination-point'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -197,18 +196,18 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         nbNode = len(response['network'][0]['node'])
         self.assertEqual(nbNode, 2)
-        for val in response['network'][0]['node']:
-            self.assertEqual(val['supporting-node'][0]['network-ref'], 'clli-network')
-            self.assertEqual(val['supporting-node'][0]['node-ref'], 'NodeA')
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
+            self.assertEqual(node['supporting-node'][0]['node-ref'], 'NodeA')
+            nodeId = node['node-id']
             if nodeId == 'XPDR-A1':
-                self.assertEqual(val['org-openroadm-common-network:node-type'], 'XPONDER')
+                self.assertEqual(node['org-openroadm-common-network:node-type'], 'XPONDER')
             elif nodeId == 'ROADM-A1':
-                self.assertEqual(val['org-openroadm-common-network:node-type'], 'ROADM')
+                self.assertEqual(node['org-openroadm-common-network:node-type'], 'ROADM')
             else:
                 self.assertFalse(True)
                 continue
-            self.assertEqual(val['org-openroadm-network:model'], 'model2')
+            self.assertEqual(node['org-openroadm-network:model'], 'model2')
 
     def test_09_getNodes_OpenRoadmTopology(self):
         # pylint: disable=redundant-unittest-assert
@@ -216,38 +215,38 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 5)
         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDR-A1-XPDR1':
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
                 self.assertEqual(nodeType, 'XPONDER')
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = (val2['org-openroadm-common-network:tp-type'])
-                    tpId = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = (tp['org-openroadm-common-network:tp-type'])
+                    tpId = tp['tp-id']
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                     elif tpType == 'XPONDER-NETWORK':
                         network += 1
                     if tpId == 'XPDR1-NETWORK2':
-                        self.assertEqual(val2['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
+                        self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-CLIENT2')
                     if tpId == 'XPDR1-CLIENT2':
-                        self.assertEqual(val2['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
+                        self.assertEqual(tp['transportpce-topology:associated-connection-map-port'], 'XPDR1-NETWORK2')
                 self.assertEqual(client, 2)
                 self.assertEqual(network, 2)
                 listNode.remove(nodeId)
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
@@ -256,14 +255,18 @@ class TransportPCEtesting(unittest.TestCase):
     # Connect the tail XPDRA to ROADMA and vice versa
     def test_10_connect_tail_xpdr_rdm(self):
         # Connect the tail: XPDRA to ROADMA
-        response = test_utils.connect_xpdr_to_rdm_request("XPDR-A1", "1", "1",
-                                                          "ROADM-A1", "1", "SRG1-PP1-TXRX")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response = test_utils_rfc8040.transportpce_api_rpc_request(
+            'transportpce-networkutils', 'init-xpdr-rdm-links',
+            {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1',
+                             'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
+        self.assertEqual(response['status_code'], requests.codes.ok)
 
     def test_11_connect_tail_rdm_xpdr(self):
-        response = test_utils.connect_rdm_to_xpdr_request("XPDR-A1", "1", "1",
-                                                          "ROADM-A1", "1", "SRG1-PP1-TXRX")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response = test_utils_rfc8040.transportpce_api_rpc_request(
+            'transportpce-networkutils', 'init-rdm-xpdr-links',
+            {'links-input': {'xpdr-node': 'XPDR-A1', 'xpdr-num': '1', 'network-num': '1',
+                             'rdm-node': 'ROADM-A1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
+        self.assertEqual(response['status_code'], requests.codes.ok)
 
     def test_12_getLinks_OpenRoadmTopology(self):
         # pylint: disable=redundant-unittest-assert
@@ -283,15 +286,15 @@ class TransportPCEtesting(unittest.TestCase):
                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_13_connect_ROADMC(self):
         response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION))
@@ -307,7 +310,8 @@ class TransportPCEtesting(unittest.TestCase):
                 "fiber-type": "smf",
                 "SRLG-length": 100000,
                 "pmd": 0.5}]}}
-        response = test_utils.add_oms_attr_request("ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
+        response = test_utils_rfc8040.add_oms_attr_request(
+            "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
     def test_15_omsAttributes_ROADMC_ROADMA(self):
@@ -321,7 +325,8 @@ class TransportPCEtesting(unittest.TestCase):
                 "SRLG-length": 100000,
                 "pmd": 0.5}]}}
 
-        response = test_utils.add_oms_attr_request("ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
+        response = test_utils_rfc8040.add_oms_attr_request(
+            "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
     def test_16_getClliNetwork(self):
@@ -329,10 +334,10 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         listNode = ['NodeA', 'NodeC']
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             self.assertIn(nodeId, listNode)
-            self.assertEqual(val['org-openroadm-clli-network:clli'], nodeId)
+            self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -347,17 +352,17 @@ class TransportPCEtesting(unittest.TestCase):
                       'ROADM-A1': {'node-ref': 'NodeA', 'node-type': 'ROADM'},
                       'ROADM-C1': {'node-ref': 'NodeC', 'node-type': 'ROADM'}
                       }
-        for val in response['network'][0]['node']:
-            self.assertEqual(val['supporting-node'][0]['network-ref'], 'clli-network')
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertEqual(node['supporting-node'][0]['network-ref'], 'clli-network')
+            nodeId = node['node-id']
             if nodeId in CHECK_LIST:
-                self.assertEqual(val['supporting-node'][0]['node-ref'], CHECK_LIST[nodeId]['node-ref'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
+                self.assertEqual(node['supporting-node'][0]['node-ref'], CHECK_LIST[nodeId]['node-ref'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], CHECK_LIST[nodeId]['node-type'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
                 continue
-            self.assertEqual(val['org-openroadm-network:model'], 'model2')
+            self.assertEqual(node['org-openroadm-network:model'], 'model2')
         self.assertEqual(len(listNode), 0)
 
     def test_18_getROADMLinkOpenRoadmTopology(self):
@@ -386,15 +391,15 @@ class TransportPCEtesting(unittest.TestCase):
                       'XPONDER-INPUT': ['ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1'],
                       'XPONDER-OUTPUT': ['XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX']
                       }
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             self.assertIn(linkType, check_list)
             find = linkId in check_list[linkType]
             self.assertEqual(find, True)
             (check_list[linkType]).remove(linkId)
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
 
     def test_19_getLinkOmsAttributesOpenRoadmTopology(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
@@ -402,13 +407,13 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 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 val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
             if link_id in R2RLink:
                 find = False
-                spanLoss = val['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
+                spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']['engineered-spanloss']
                 # pylint: disable=line-too-long
-                length = val['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
                 if (spanLoss is not None) & (length is not None):
                     find = True
                 self.assertTrue(find)
@@ -424,18 +429,18 @@ class TransportPCEtesting(unittest.TestCase):
                     'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2',
                     'ROADM-C1-SRG1', 'ROADM-C1-DEG1', 'ROADM-C1-DEG2']
         # Tests related to XPDRA nodes
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             if nodeId == 'XPDR-A1-XPDR1':
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, val['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
                 self.assertEqual(nodeType, 'XPONDER')
-                nbTps = len(val['ietf-network-topology:termination-point'])
+                nbTps = len(node['ietf-network-topology:termination-point'])
                 self.assertTrue(nbTps >= 4)
                 client = 0
                 network = 0
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpType = (val2['org-openroadm-common-network:tp-type'])
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpType = (tp['org-openroadm-common-network:tp-type'])
                     if tpType == 'XPONDER-CLIENT':
                         client += 1
                     elif tpType == 'XPONDER-NETWORK':
@@ -447,23 +452,23 @@ class TransportPCEtesting(unittest.TestCase):
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT1[nodeId]['node_type'])
                 listNode.remove(nodeId)
         # Tests related to ROADMA nodes
             elif nodeId in self.CHECK_DICT2:
                 self.assertEqual(nodeType, self.CHECK_DICT2[nodeId]['node_type'])
                 if self.CHECK_DICT2[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT2[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'}, val['supporting-node'])
-                self.assertEqual(val['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT2[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeC'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-C1'}, node['supporting-node'])
+                self.assertEqual(node['org-openroadm-common-network:node-type'], self.CHECK_DICT2[nodeId]['node_type'])
                 listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -483,7 +488,8 @@ class TransportPCEtesting(unittest.TestCase):
                     "fiber-type": "smf",
                     "SRLG-length": 100000,
                     "pmd": 0.5}]}}
-        response = test_utils.add_oms_attr_request("ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
+        response = test_utils_rfc8040.add_oms_attr_request(
+            "ROADM-A1-DEG1-DEG1-TTP-TXRXtoROADM-B1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
     def test_23_omsAttributes_ROADMB_ROADMA(self):
@@ -498,7 +504,8 @@ class TransportPCEtesting(unittest.TestCase):
                     "fiber-type": "smf",
                     "SRLG-length": 100000,
                     "pmd": 0.5}]}}
-        response = test_utils.add_oms_attr_request("ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
+        response = test_utils_rfc8040.add_oms_attr_request(
+            "ROADM-B1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
     def test_24_omsAttributes_ROADMB_ROADMC(self):
@@ -513,7 +520,8 @@ class TransportPCEtesting(unittest.TestCase):
                     "fiber-type": "smf",
                     "SRLG-length": 100000,
                     "pmd": 0.5}]}}
-        response = test_utils.add_oms_attr_request("ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
+        response = test_utils_rfc8040.add_oms_attr_request(
+            "ROADM-B1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
     def test_25_omsAttributes_ROADMC_ROADMB(self):
@@ -526,7 +534,8 @@ class TransportPCEtesting(unittest.TestCase):
                     "fiber-type": "smf",
                     "SRLG-length": 100000,
                     "pmd": 0.5}]}}
-        response = test_utils.add_oms_attr_request("ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
+        response = test_utils_rfc8040.add_oms_attr_request(
+            "ROADM-C1-DEG2-DEG2-TTP-TXRXtoROADM-B1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
     def test_26_getClliNetwork(self):
@@ -534,10 +543,10 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         listNode = ['NodeA', 'NodeB', 'NodeC']
-        for val in response['network'][0]['node']:
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeId = node['node-id']
             self.assertIn(nodeId, listNode)
-            self.assertEqual(val['org-openroadm-clli-network:clli'], nodeId)
+            self.assertEqual(node['org-openroadm-clli-network:clli'], nodeId)
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
@@ -550,9 +559,9 @@ class TransportPCEtesting(unittest.TestCase):
                        '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 val in response['network'][0]['ietf-network-topology:link']:
-            if val['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
-                link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            if link['org-openroadm-common-network:link-type'] == 'ROADM-TO-ROADM':
+                link_id = link['link-id']
                 find = link_id in listR2RLink
                 self.assertEqual(find, True)
                 listR2RLink.remove(link_id)
@@ -562,21 +571,19 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['ietf-network-topology:link']), 30)
-        for val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
-            link_type = val['org-openroadm-common-network:link-type']
-            link_src = val['source']['source-node']
-            link_dest = val['destination']['dest-node']
-            oppLink_id = val['org-openroadm-common-network:opposite-link']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
+            link_type = link['org-openroadm-common-network:link-type']
+            link_src = link['source']['source-node']
+            link_dest = link['destination']['dest-node']
+            oppLink_id = link['org-openroadm-common-network:opposite-link']
             # Find the opposite link
-            response_oppLink = test_utils.get_ordm_topo_request("ietf-network-topology:link/"+oppLink_id)
-            self.assertEqual(response_oppLink.status_code, requests.codes.ok)
-            res_oppLink = response_oppLink.json()
-            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-common-network:link-type']
+            res_oppLink = test_utils_rfc8040.get_ietf_network_link_request('openroadm-topology', oppLink_id, 'config')
+            self.assertEqual(res_oppLink['status_code'], requests.codes.ok)
+            self.assertEqual(res_oppLink['link']['org-openroadm-common-network:opposite-link'], link_id)
+            self.assertEqual(res_oppLink['link']['source']['source-node'], link_dest)
+            self.assertEqual(res_oppLink['link']['destination']['dest-node'], link_src)
+            oppLink_type = res_oppLink['link']['org-openroadm-common-network:link-type']
             CHECK_DICT = {'ADD-LINK': 'DROP-LINK', 'DROP-LINK': 'ADD-LINK',
                           'EXPRESS-LINK': 'EXPRESS-LINK', 'ROADM-TO-ROADM': 'ROADM-TO-ROADM',
                           'XPONDER-INPUT': 'XPONDER-OUTPUT', 'XPONDER-OUTUT': 'XPONDER-INPUT'}
@@ -592,13 +599,13 @@ class TransportPCEtesting(unittest.TestCase):
                    '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 val in response['network'][0]['ietf-network-topology:link']:
-            link_id = val['link-id']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            link_id = link['link-id']
             if link_id in R2RLink:
                 find = False
-                spanLoss = val['org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
+                spanLoss = link['org-openroadm-network-topology:OMS-attributes']['span']["engineered-spanloss"]
                 # pylint: disable=line-too-long
-                length = val['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
+                length = link['org-openroadm-network-topology:OMS-attributes']['span']['link-concatenation'][0]['SRLG-length']
                 if (spanLoss is not None) & (length is not None):
                     find = True
                 self.assertTrue(find)
@@ -610,16 +617,16 @@ class TransportPCEtesting(unittest.TestCase):
         response = test_utils_rfc8040.unmount_device("ROADM-B1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
         # Delete in the clli-network
-        response = test_utils.del_node_request("NodeB")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeB', 'config')
+        self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_31_disconnect_ROADMC(self):
         # Delete in the topology-netconf
         response = test_utils_rfc8040.unmount_device("ROADM-C1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
         # Delete in the clli-network
-        response = test_utils.del_node_request("NodeC")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeC', 'config')
+        self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_32_getNodes_OpenRoadmTopology(self):
         # pylint: disable=redundant-unittest-assert
@@ -627,49 +634,52 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 5)
         listNode = ['XPDR-A1-XPDR1', 'ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             # Tests related to XPDRA nodes
             if nodeId == 'XPDR-A1-XPDR1':
-                for val2 in val['ietf-network-topology:termination-point']:
-                    tpid = val2['tp-id']
+                for tp in node['ietf-network-topology:termination-point']:
+                    tpid = tp['tp-id']
                     if tpid == 'XPDR1-CLIENT1':
-                        self.assertEqual((val2['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
+                        self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-CLIENT')
                     elif tpid == 'XPDR1-NETWORK1':
-                        self.assertEqual((val2['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
+                        self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
                         # pylint: disable=line-too-long
-                        self.assertEqual((val2['org-openroadm-network-topology:xpdr-network-attributes']['tail-equipment-id']),
+                        self.assertEqual((tp['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'}, val['supporting-node'])
+                    elif tpid == 'XPDR2-NETWORK1':
+                        self.assertEqual((tp['org-openroadm-common-network:tp-type']), 'XPONDER-NETWORK')
+                        # pylint: disable=line-too-long
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'XPDR-A1'}, node['supporting-node'])
                 listNode.remove(nodeId)
             # Tests related to ROADMA nodes
             elif nodeId in self.CHECK_DICT1:
                 self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
                 if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                    self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-                for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                    self.assertIn(item, val['ietf-network-topology:termination-point'])
-                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                    self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+                for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                    self.assertIn(tp, node['ietf-network-topology:termination-point'])
+                self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+                self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
                 listNode.remove(nodeId)
             else:
                 self.assertFalse(True)
         self.assertEqual(len(listNode), 0)
         # Test related to SRG1 of ROADMC
-        for val in response['network'][0]['node']:
-            self.assertNotEqual(val['node-id'], 'ROADM-C1-SRG1')
-            self.assertNotEqual(val['node-id'], 'ROADM-C1-DEG1')
-            self.assertNotEqual(val['node-id'], 'ROADM-C1-DEG2')
+        for node in response['network'][0]['node']:
+            self.assertNotEqual(node['node-id'], 'ROADM-C1-SRG1')
+            self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG1')
+            self.assertNotEqual(node['node-id'], 'ROADM-C1-DEG2')
 
     def test_33_getOpenRoadmNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-network', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         nbNode = len(response['network'][0]['node'])
         self.assertEqual(nbNode, 2)
-        for val in response['network'][0]['node']:
-            self.assertNotEqual(val['node-id'], 'ROADM-C1')
-            self.assertNotEqual(val['node-id'], 'ROADM-B1')
+        for node in response['network'][0]['node']:
+            self.assertNotEqual(node['node-id'], 'ROADM-C1')
+            self.assertNotEqual(node['node-id'], 'ROADM-B1')
 
     def test_34_getClliNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')
@@ -698,28 +708,34 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(len(response['network'][0]['node']), 4)
         listNode = ['ROADM-A1-SRG1', 'ROADM-A1-SRG3', 'ROADM-A1-DEG1', 'ROADM-A1-DEG2']
-        for val in response['network'][0]['node']:
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
-            nodeType = val['org-openroadm-common-network:node-type']
-            nodeId = val['node-id']
+        for node in response['network'][0]['node']:
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
+            nodeType = node['org-openroadm-common-network:node-type']
+            nodeId = node['node-id']
             self.assertIn(nodeId, self.CHECK_DICT1)
             self.assertEqual(nodeType, self.CHECK_DICT1[nodeId]['node_type'])
             if self.CHECK_DICT1[nodeId]['node_type'] == 'SRG':
-                self.assertEqual(len(val['ietf-network-topology:termination-point']), 5)
-            for item in self.CHECK_DICT1[nodeId]['checks_tp']:
-                self.assertIn(item, val['ietf-network-topology:termination-point'])
-            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, val['supporting-node'])
-            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, val['supporting-node'])
+                self.assertEqual(len(node['ietf-network-topology:termination-point']), 5)
+            for tp in self.CHECK_DICT1[nodeId]['checks_tp']:
+                self.assertIn(tp, node['ietf-network-topology:termination-point'])
+            self.assertIn({'network-ref': 'clli-network', 'node-ref': 'NodeA'}, node['supporting-node'])
+            self.assertIn({'network-ref': 'openroadm-network', 'node-ref': 'ROADM-A1'}, node['supporting-node'])
             listNode.remove(nodeId)
         self.assertEqual(len(listNode), 0)
 
     def test_39_disconnect_ROADM_XPDRA_link(self):
         # Link-1
-        response = test_utils.del_link_request("XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response = test_utils_rfc8040.del_ietf_network_link_request(
+            'openroadm-topology',
+            'XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX',
+            'config')
         # Link-2
-        response = test_utils.del_link_request("ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response2 = test_utils_rfc8040.del_ietf_network_link_request(
+            'openroadm-topology',
+            'ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1',
+            'config')
+        self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
+        self.assertIn(response2.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_40_getLinks_OpenRoadmTopology(self):
         response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
@@ -737,28 +753,28 @@ class TransportPCEtesting(unittest.TestCase):
                                     'ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX']
                       }
         roadmtoroadmLink = 0
-        for val in response['network'][0]['ietf-network-topology:link']:
-            linkId = val['link-id']
-            linkType = val['org-openroadm-common-network:link-type']
+        for link in response['network'][0]['ietf-network-topology:link']:
+            linkId = link['link-id']
+            linkType = link['org-openroadm-common-network:link-type']
             if linkType in check_list:
                 find = linkId in check_list[linkType]
                 self.assertEqual(find, True)
                 (check_list[linkType]).remove(linkId)
             else:
                 roadmtoroadmLink += 1
-        for val in check_list.values():
-            self.assertEqual(len(val), 0)
+        for link in check_list.values():
+            self.assertEqual(len(link), 0)
         self.assertEqual(roadmtoroadmLink, 6)
-        for val in response['network'][0]['ietf-network-topology:link']:
-            self.assertNotEqual(val['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
-            self.assertNotEqual(val['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
+        for link in response['network'][0]['ietf-network-topology:link']:
+            self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-OUTPUT')
+            self.assertNotEqual(link['org-openroadm-common-network:link-type'], 'XPONDER-INPUT')
 
     def test_41_disconnect_ROADMA(self):
         response = test_utils_rfc8040.unmount_device("ROADM-A1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
         # Delete in the clli-network
-        response = test_utils.del_node_request("NodeA")
-        self.assertEqual(response.status_code, requests.codes.ok)
+        response = test_utils_rfc8040.del_ietf_network_node_request('clli-network', 'NodeA', 'config')
+        self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_42_getClliNetwork(self):
         response = test_utils_rfc8040.get_ietf_network_request('clli-network', 'config')