Speed up functional tests execution

[transportpce.git] / tests / transportpce_tests / 7.1 / test03_renderer_or_modes.py

diff --git a/tests/transportpce_tests/7.1/test03_renderer_or_modes.py b/tests/transportpce_tests/7.1/test03_renderer_or_modes.py
index 92e733541a87b09ed9fc1980f668d12f288ec0c6..2592457856fb28d96885455c69b9a162758d9326 100644 (file)
--- a/tests/transportpce_tests/7.1/test03_renderer_or_modes.py
+++ b/tests/transportpce_tests/7.1/test03_renderer_or_modes.py
@@ -11,21 +11,23 @@
 # pylint: disable=no-member
 # pylint: disable=too-many-public-methods
 
-import unittest
-import time
-import requests
 # pylint: disable=wrong-import-order
 import sys
+import time
+import unittest
+
+import requests
+
 sys.path.append("transportpce_tests/common")
 # pylint: disable=wrong-import-position
 # pylint: disable=import-error
-import test_utils_rfc8040  # nopep8
+import test_utils  # nopep8
 
 
 class TransportPCE400GPortMappingTesting(unittest.TestCase):
 
     processes = None
-    NETWORK2_CHECK_DICT = {"logical-connection-point": "XPDR3-NETWORK1",
+    NETWORK1_CHECK_DICT = {"logical-connection-point": "XPDR3-NETWORK1",
                            "supporting-port": "L1",
                            "supported-interface-capability": [
                                "org-openroadm-port-types:if-otsi-otsigroup"
@@ -36,58 +38,58 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                            "xponder-type": "tpdr",
                            "port-admin-state": "InService",
                            "port-oper-state": "InService"}
-    CLIENT_CAPABILITIES = ["org-openroadm-port-types:if-OCH-OTU4-ODU4",
-                           "org-openroadm-port-types:if-100GE"]
+    CLIENT_CAPABILITIES = ["org-openroadm-port-types:if-100GE",
+                           "org-openroadm-port-types:if-OCH-OTU4-ODU4"]
     NODE_VERSION = "7.1"
 
     @classmethod
     def setUpClass(cls):
-        cls.processes = test_utils_rfc8040.start_tpce()
-        cls.processes = test_utils_rfc8040.start_sims([("xpdra2", cls.NODE_VERSION),
-                                                       ("xpdrc2", cls.NODE_VERSION)])
+        cls.processes = test_utils.start_tpce()
+        cls.processes = test_utils.start_sims([("xpdra2", cls.NODE_VERSION),
+                                               ("xpdrc2", cls.NODE_VERSION)])
 
     @classmethod
     def tearDownClass(cls):
         # pylint: disable=not-an-iterable
         for process in cls.processes:
-            test_utils_rfc8040.shutdown_process(process)
+            test_utils.shutdown_process(process)
         print("all processes killed")
 
     def setUp(self):
         # pylint: disable=consider-using-f-string
         print("execution of {}".format(self.id().split(".")[-1]))
-        time.sleep(10)
+        time.sleep(2)
 
     def test_01_xpdr_device_connection(self):
-        response = test_utils_rfc8040.mount_device("XPDR-A2",
-                                                   ("xpdra2", self.NODE_VERSION))
+        response = test_utils.mount_device("XPDR-A2",
+                                           ("xpdra2", self.NODE_VERSION))
         self.assertEqual(response.status_code, requests.codes.created,
-                         test_utils_rfc8040.CODE_SHOULD_BE_201)
+                         test_utils.CODE_SHOULD_BE_201)
 
     def test_01a_xpdr_device_connection(self):
-        response = test_utils_rfc8040.mount_device("XPDR-C2",
-                                                   ("xpdrc2", self.NODE_VERSION))
+        response = test_utils.mount_device("XPDR-C2",
+                                           ("xpdrc2", self.NODE_VERSION))
         self.assertEqual(response.status_code, requests.codes.created,
-                         test_utils_rfc8040.CODE_SHOULD_BE_201)
+                         test_utils.CODE_SHOULD_BE_201)
 
     # Check the correct capabilities for the client ports (if-100GE, if-100GE-ODU4,
     # if-OCH-OTU4-ODU4)
     def test_02_check_client_capabilities(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR3-CLIENT1")
+        response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-CLIENT1")
         self.assertEqual(response["status_code"], requests.codes.ok)
         self.assertEqual(
             self.CLIENT_CAPABILITIES,
-            response["mapping"][0]["supported-interface-capability"])
+            sorted(response["mapping"][0]["supported-interface-capability"]))
 
     def test_03_check_client_capabilities(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-C2", "XPDR3-CLIENT1")
+        response = test_utils.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-CLIENT1")
         self.assertEqual(response["status_code"], requests.codes.ok)
         self.assertEqual(
             self.CLIENT_CAPABILITIES,
-            response["mapping"][0]["supported-interface-capability"])
+            sorted(response["mapping"][0]["supported-interface-capability"]))
 
     def test_04_100g_ofec_service_path_create(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             "transportpce-device-renderer", "service-path",
             {
                 "service-name": "service_100GE_ofec",
@@ -124,8 +126,8 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                  "XPDR3-NETWORK1-OTUC1"
              ],
              "odu-interface-id": [
-                 "XPDR3-NETWORK1-ODUC1",
-                 "XPDR3-NETWORK1-ODU4"
+                 "XPDR3-NETWORK1-ODU4",
+                 "XPDR3-NETWORK1-ODUC1"
              ],
              "och-interface-id": [
                  "XPDR3-NETWORK1-265:272",
@@ -134,15 +136,18 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
              "eth-interface-id": [
                  "XPDR3-CLIENT1-ETHERNET"
              ]},
-            response["output"]["node-interface"][0])
+            {x: (sorted(response["output"]["node-interface"][0][x])
+                 if isinstance(response["output"]["node-interface"][0][x], list)
+                 else response["output"]["node-interface"][0][x])
+             for x in response["output"]["node-interface"][0].keys()})
         self.assertEqual(
             {"node-id": z_side,
              "otu-interface-id": [
                  "XPDR3-NETWORK1-OTUC1"
              ],
              "odu-interface-id": [
-                 "XPDR3-NETWORK1-ODUC1",
-                 "XPDR3-NETWORK1-ODU4"
+                 "XPDR3-NETWORK1-ODU4",
+                 "XPDR3-NETWORK1-ODUC1"
              ],
              "och-interface-id": [
                  "XPDR3-NETWORK1-265:272",
@@ -151,29 +156,34 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
              "eth-interface-id": [
                  "XPDR3-CLIENT1-ETHERNET"
              ]},
-            response["output"]["node-interface"][1])
+            {x: (sorted(response["output"]["node-interface"][1][x])
+                 if isinstance(response["output"]["node-interface"][1][x], list)
+                 else response["output"]["node-interface"][1][x])
+             for x in response["output"]["node-interface"][1].keys()})
 
     def test_05_get_portmapping_network1(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR3-NETWORK1")
+        response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-NETWORK1")
         self.assertEqual(response["status_code"], requests.codes.ok)
-        self.NETWORK2_CHECK_DICT["supporting-otucn"] = "XPDR3-NETWORK1-OTUC1"
-        self.NETWORK2_CHECK_DICT["lcp-hash-val"] = "FDvaQIf2Z08="
+        self.NETWORK1_CHECK_DICT["supporting-otucn"] = "XPDR3-NETWORK1-OTUC1"
+        self.NETWORK1_CHECK_DICT["lcp-hash-val"] = "FDvaQIf2Z08="
+        self.NETWORK1_CHECK_DICT["connection-map-lcp"] = "XPDR3-CLIENT1"
         self.assertIn(
-            self.NETWORK2_CHECK_DICT,
+            self.NETWORK1_CHECK_DICT,
             response["mapping"])
 
     def test_06_get_portmapping_network1(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-C2", "XPDR3-NETWORK1")
+        response = test_utils.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-NETWORK1")
         self.assertEqual(response["status_code"], requests.codes.ok)
-        self.NETWORK2_CHECK_DICT["supporting-otucn"] = "XPDR3-NETWORK1-OTUC1"
-        self.NETWORK2_CHECK_DICT["lcp-hash-val"] = "AJpkaVmZKJk5"
+        self.NETWORK1_CHECK_DICT["supporting-otucn"] = "XPDR3-NETWORK1-OTUC1"
+        self.NETWORK1_CHECK_DICT["lcp-hash-val"] = "AJpkaVmZKJk5"
+        self.NETWORK1_CHECK_DICT["connection-map-lcp"] = "XPDR3-CLIENT1"
         self.assertIn(
-            self.NETWORK2_CHECK_DICT,
+            self.NETWORK1_CHECK_DICT,
             response["mapping"])
 
     def test_07_check_interface_otsi(self):
         # pylint: disable=line-too-long
-        response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR3-NETWORK1-265:272")
+        response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR3-NETWORK1-265:272")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-265:272",
                         "administrative-state": "inService",
@@ -198,7 +208,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
 
     def test_08_check_interface_otsi(self):
         # pylint: disable=line-too-long
-        response = test_utils_rfc8040.check_node_attribute_request("XPDR-C2", "interface", "XPDR3-NETWORK1-265:272")
+        response = test_utils.check_node_attribute_request("XPDR-C2", "interface", "XPDR3-NETWORK1-265:272")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-265:272",
                         "administrative-state": "inService",
@@ -222,7 +232,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-optical-tributary-signal-interfaces:otsi"]["flexo"])
 
     def test_09_check_interface_otsig(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-OTSIGROUP-100G",
@@ -241,7 +251,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-otsi-group-interfaces:otsi-group"])
 
     def test_10_check_interface_otsig(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-OTSIGROUP-100G",
@@ -260,7 +270,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-otsi-group-interfaces:otsi-group"])
 
     def test_11_check_interface_otuc1(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-OTUC1")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-OTUC1",
@@ -282,7 +292,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-otn-otu-interfaces:otu"])
 
     def test_12_check_interface_otuc1(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-OTUC1")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-OTUC1",
@@ -304,7 +314,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-otn-otu-interfaces:otu"])
 
     def test_13_check_interface_oduc1(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-ODUC1")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-NETWORK1-ODUC1",
@@ -330,7 +340,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
             response["interface"][0]["org-openroadm-otn-odu-interfaces:odu"]["opu"])
 
     def test_14_check_interface_oduc1(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-ODUC1")
         self.assertEqual(response["status_code"], requests.codes.ok)
 
@@ -357,7 +367,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
             response["interface"][0]["org-openroadm-otn-odu-interfaces:odu"]["opu"])
 
     def test_15_check_interface_odu4(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-ODU4")
         self.assertEqual(response["status_code"], requests.codes.ok)
 
@@ -385,7 +395,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
         # TODO: Check the trib-port numbering
 
     def test_16_check_interface_odu4(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-ODU4")
         self.assertEqual(response["status_code"], requests.codes.ok)
 
@@ -413,7 +423,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
         # TODO: Check the trib-port numbering
 
     def test_17_check_interface_100ge_client(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-CLIENT1-ETHERNET")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-CLIENT1-ETHERNET-100G",
@@ -431,7 +441,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-ethernet-interfaces:ethernet"])
 
     def test_18_check_interface_100ge_client(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-CLIENT1-ETHERNET")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR3-CLIENT1-ETHERNET-100G",
@@ -450,7 +460,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
 
     # Delete the service path
     def test_19_service_path_delete_100ge(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             "transportpce-device-renderer", "service-path",
             {
                 "service-name": "service_100GE_ofec",
@@ -478,67 +488,67 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
         self.assertIn("Request processed", response["output"]["result"])
 
     def test_20_check_no_interface_100ge_client(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-CLIENT1-ETHERNET")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_21_check_no_interface_100ge_client(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-CLIENT1-ETHERNET")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_22_check_no_interface_odu4(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-ODU4")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_23_check_no_interface_odu4(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-ODU4")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_24_check_no_interface_otuc2(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-ODUC1")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_25_check_no_interface_otuc2(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-ODUC1")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     # Check if port-mapping data is updated, where the supporting-otucn is deleted
     def test_26_check_no_otuc1(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR3-NETWORK1")
+        response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR3-NETWORK1")
         self.assertRaises(KeyError, lambda: response["supporting-otucn"])
 
     def test_27_check_no_otuc1(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-C2", "XPDR3-NETWORK1")
+        response = test_utils.get_portmapping_node_attr("XPDR-C2", "mapping", "XPDR3-NETWORK1")
         self.assertRaises(KeyError, lambda: response["supporting-otucn"])
 
     def test_28_check_no_interface_otsig(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_29_check_no_interface_otsig(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-OTSIGROUP-100G")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_30_check_no_interface_otsi(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR3-NETWORK1-265:272")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_31_check_no_interface_otsi(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-C2", "interface", "XPDR3-NETWORK1-265:272")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     # 200G 31.6 Gbaud mode for muxponder, with qam16
     def test_32_service_path_create_otuc2(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             "transportpce-device-renderer", "service-path",
             {
                 "service-name": "service_OTUC2",
@@ -588,23 +598,24 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
              ]},
             response["output"]["node-interface"][1])
         # Update the network dict variable for mpdr
-        self.NETWORK2_CHECK_DICT["logical-connection-point"] = "XPDR2-NETWORK1"
-        self.NETWORK2_CHECK_DICT["supporting-circuit-pack-name"] = "1/2/2-PLUG-NET"
-        self.NETWORK2_CHECK_DICT["port-qual"] = "switch-network"
-        self.NETWORK2_CHECK_DICT["xponder-type"] = "mpdr"
-        self.NETWORK2_CHECK_DICT["lcp-hash-val"] = "LY9PxYJqUbw="
+        self.NETWORK1_CHECK_DICT["logical-connection-point"] = "XPDR2-NETWORK1"
+        self.NETWORK1_CHECK_DICT["supporting-circuit-pack-name"] = "1/2/2-PLUG-NET"
+        self.NETWORK1_CHECK_DICT["port-qual"] = "switch-network"
+        self.NETWORK1_CHECK_DICT["xponder-type"] = "mpdr"
+        self.NETWORK1_CHECK_DICT["lcp-hash-val"] = "LY9PxYJqUbw="
 
     def test_33_get_portmapping_network1(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+        response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
         self.assertEqual(response["status_code"], requests.codes.ok)
-        self.NETWORK2_CHECK_DICT["supporting-otucn"] = "XPDR2-NETWORK1-OTUC2"
+        self.NETWORK1_CHECK_DICT["supporting-otucn"] = "XPDR2-NETWORK1-OTUC2"
+        del self.NETWORK1_CHECK_DICT["connection-map-lcp"]
         self.assertIn(
-            self.NETWORK2_CHECK_DICT,
+            self.NETWORK1_CHECK_DICT,
             response["mapping"])
 
     def test_34_check_interface_otsi(self):
         # pylint: disable=line-too-long
-        response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-265:272")
+        response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-265:272")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR2-NETWORK1-265:272",
                         "administrative-state": "inService",
@@ -628,7 +639,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-optical-tributary-signal-interfaces:otsi"]["flexo"])
 
     def test_35_check_interface_otsig(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-200G")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR2-NETWORK1-OTSIGROUP-200G",
@@ -647,7 +658,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                              response["interface"][0]["org-openroadm-otsi-group-interfaces:otsi-group"])
 
     def test_36_check_interface_otuc2(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
         self.assertEqual(response["status_code"], requests.codes.ok)
         input_dict_1 = {"name": "XPDR2-NETWORK1-OTUC2",
@@ -672,7 +683,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
     # as there is no change in code and are covered in test02_otn_renderer
 
     def test_37_service_path_delete_otuc2(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             "transportpce-device-renderer", "service-path",
             {
                 "modulation-format": "dp-qam16",
@@ -698,32 +709,32 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
             })
         self.assertEqual(response["status_code"], requests.codes.ok)
         self.assertIn("Request processed", response["output"]["result"])
-        del self.NETWORK2_CHECK_DICT["supporting-otucn"]
+        del self.NETWORK1_CHECK_DICT["supporting-otucn"]
 
     def test_38_check_no_interface_otuc2(self):
-        response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
+        response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-OTUC2")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_39_check_no_interface_otsig(self):
-        response = test_utils_rfc8040.check_node_attribute_request(
+        response = test_utils.check_node_attribute_request(
             "XPDR-A2", "interface", "XPDR2-NETWORK1-OTSIGROUP-200G")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_40_check_no_interface_otsi(self):
-        response = test_utils_rfc8040.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
+        response = test_utils.check_node_attribute_request("XPDR-A2", "interface", "XPDR2-NETWORK1-755:768")
         self.assertEqual(response["status_code"], requests.codes.conflict)
 
     def test_41_check_no_otuc2(self):
-        response = test_utils_rfc8040.portmapping_request("XPDR-A2", "XPDR2-NETWORK1")
+        response = test_utils.get_portmapping_node_attr("XPDR-A2", "mapping", "XPDR2-NETWORK1")
         self.assertRaises(KeyError, lambda: response["supporting-otucn"])
 
     # Disconnect the XPDR
     def test_42_xpdr_device_disconnection(self):
-        response = test_utils_rfc8040.unmount_device("XPDR-A2")
+        response = test_utils.unmount_device("XPDR-A2")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_43_xpdr_device_disconnected(self):
-        response = test_utils_rfc8040.check_device_connection("XPDR-A2")
+        response = test_utils.check_device_connection("XPDR-A2")
         self.assertEqual(response["status_code"], requests.codes.conflict)
         self.assertIn(response["connection-status"]["error-type"], ("protocol", "application"))
         self.assertEqual(response["connection-status"]["error-tag"], "data-missing")
@@ -731,7 +742,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                          "Request could not be completed because the relevant data model content does not exist")
 
     def test_44_xpdr_device_not_connected(self):
-        response = test_utils_rfc8040.get_portmapping_node_info("XPDR-A2")
+        response = test_utils.get_portmapping_node_attr("XPDR-A2", "node-info", None)
         self.assertEqual(response["status_code"], requests.codes.conflict)
         self.assertIn(response["node-info"]["error-type"], ("protocol", "application"))
         self.assertEqual(response["node-info"]["error-tag"], "data-missing")
@@ -739,11 +750,11 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                          "Request could not be completed because the relevant data model content does not exist")
 
     def test_45_xpdr_device_disconnection(self):
-        response = test_utils_rfc8040.unmount_device("XPDR-C2")
+        response = test_utils.unmount_device("XPDR-C2")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_46_xpdr_device_disconnected(self):
-        response = test_utils_rfc8040.check_device_connection("XPDR-C2")
+        response = test_utils.check_device_connection("XPDR-C2")
         self.assertEqual(response["status_code"], requests.codes.conflict)
         self.assertIn(response["connection-status"]["error-type"], ("protocol", "application"))
         self.assertEqual(response["connection-status"]["error-tag"], "data-missing")
@@ -751,7 +762,7 @@ class TransportPCE400GPortMappingTesting(unittest.TestCase):
                          "Request could not be completed because the relevant data model content does not exist")
 
     def test_47_xpdr_device_not_connected(self):
-        response = test_utils_rfc8040.get_portmapping_node_info("XPDR-C2")
+        response = test_utils.get_portmapping_node_attr("XPDR-C2", "node-info", None)
         self.assertEqual(response["status_code"], requests.codes.conflict)
         self.assertIn(response["node-info"]["error-type"], ("protocol", "application"))
         self.assertEqual(response["node-info"]["error-tag"], "data-missing")