Switch functional tests to RFC8040

[transportpce.git] / tests / transportpce_tests / tapi / test03_tapi_device_change_notifications.py

diff --git a/tests/transportpce_tests/tapi/test03_tapi_device_change_notifications.py b/tests/transportpce_tests/tapi/test03_tapi_device_change_notifications.py
index 69de9452fc719f405ffa7a0c3810c6e2a368a2ac..e36e3052da5adb9c10abce500da47f243f60d76f 100644 (file)
--- a/tests/transportpce_tests/tapi/test03_tapi_device_change_notifications.py
+++ b/tests/transportpce_tests/tapi/test03_tapi_device_change_notifications.py
@@ -20,7 +20,7 @@ import sys
 sys.path.append('transportpce_tests/common/')
 # pylint: disable=wrong-import-position
 # pylint: disable=import-error
-import test_utils_rfc8040  # nopep8
+import test_utils  # nopep8
 
 # pylint: disable=too-few-public-methods
 
@@ -111,34 +111,34 @@ class TransportPCEFulltesting(unittest.TestCase):
         cls.init_failed = False
         os.environ['JAVA_MIN_MEM'] = '1024M'
         os.environ['JAVA_MAX_MEM'] = '4096M'
-        cls.processes = test_utils_rfc8040.start_tpce()
+        cls.processes = test_utils.start_tpce()
         # TAPI feature is not installed by default in Karaf
         if "USE_LIGHTY" not in os.environ or os.environ['USE_LIGHTY'] != 'True':
             print("installing tapi feature...")
-            result = test_utils_rfc8040.install_karaf_feature("odl-transportpce-tapi")
+            result = test_utils.install_karaf_feature("odl-transportpce-tapi")
             if result.returncode != 0:
                 cls.init_failed = True
             print("Restarting OpenDaylight...")
-            test_utils_rfc8040.shutdown_process(cls.processes[0])
-            cls.processes[0] = test_utils_rfc8040.start_karaf()
-            test_utils_rfc8040.process_list[0] = cls.processes[0]
-            cls.init_failed = not test_utils_rfc8040.wait_until_log_contains(
-                test_utils_rfc8040.KARAF_LOG, test_utils_rfc8040.KARAF_OK_START_MSG, time_to_wait=60)
+            test_utils.shutdown_process(cls.processes[0])
+            cls.processes[0] = test_utils.start_karaf()
+            test_utils.process_list[0] = cls.processes[0]
+            cls.init_failed = not test_utils.wait_until_log_contains(
+                test_utils.KARAF_LOG, test_utils.KARAF_OK_START_MSG, time_to_wait=60)
         if cls.init_failed:
             print("tapi installation feature failed...")
-            test_utils_rfc8040.shutdown_process(cls.processes[0])
+            test_utils.shutdown_process(cls.processes[0])
             sys.exit(2)
-        cls.processes = test_utils_rfc8040.start_tpce()
-        cls.processes = test_utils_rfc8040.start_sims([('xpdra', cls.NODE_VERSION_221),
-                                                       ('roadma', cls.NODE_VERSION_221),
-                                                       ('roadmc', cls.NODE_VERSION_221),
-                                                       ('xpdrc', cls.NODE_VERSION_221)])
+        cls.processes = test_utils.start_tpce()
+        cls.processes = test_utils.start_sims([('xpdra', cls.NODE_VERSION_221),
+                                               ('roadma', cls.NODE_VERSION_221),
+                                               ('roadmc', cls.NODE_VERSION_221),
+                                               ('xpdrc', cls.NODE_VERSION_221)])
 
     @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):  # instruction executed before each test method
@@ -147,23 +147,23 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_01_connect_xpdrA(self):
-        response = test_utils_rfc8040.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION_221))
-        self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+        response = test_utils.mount_device("XPDR-A1", ('xpdra', self.NODE_VERSION_221))
+        self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
     def test_02_connect_xpdrC(self):
-        response = test_utils_rfc8040.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_221))
-        self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+        response = test_utils.mount_device("XPDR-C1", ('xpdrc', self.NODE_VERSION_221))
+        self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
     def test_03_connect_rdmA(self):
-        response = test_utils_rfc8040.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
-        self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+        response = test_utils.mount_device("ROADM-A1", ('roadma', self.NODE_VERSION_221))
+        self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
     def test_04_connect_rdmC(self):
-        response = test_utils_rfc8040.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
-        self.assertEqual(response.status_code, requests.codes.created, test_utils_rfc8040.CODE_SHOULD_BE_201)
+        response = test_utils.mount_device("ROADM-C1", ('roadmc', self.NODE_VERSION_221))
+        self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
 
     def test_05_connect_xprdA_N1_to_roadmA_PP1(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.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'}})
@@ -172,7 +172,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(2)
 
     def test_06_connect_roadmA_PP1_to_xpdrA_N1(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.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'}})
@@ -181,7 +181,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(2)
 
     def test_07_connect_xprdC_N1_to_roadmC_PP1(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'transportpce-networkutils', 'init-xpdr-rdm-links',
             {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '1', 'network-num': '1',
                              'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
@@ -190,7 +190,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(2)
 
     def test_08_connect_roadmC_PP1_to_xpdrC_N1(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'transportpce-networkutils', 'init-rdm-xpdr-links',
             {'links-input': {'xpdr-node': 'XPDR-C1', 'xpdr-num': '1', 'network-num': '1',
                              'rdm-node': 'ROADM-C1', 'srg-num': '1', 'termination-point-num': 'SRG1-PP1-TXRX'}})
@@ -210,7 +210,7 @@ class TransportPCEFulltesting(unittest.TestCase):
                 "fiber-type": "smf",
                 "SRLG-length": 100000,
                 "pmd": 0.5}]}}
-        response = test_utils_rfc8040.add_oms_attr_request(
+        response = test_utils.add_oms_attr_request(
             "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
@@ -226,13 +226,13 @@ class TransportPCEFulltesting(unittest.TestCase):
                 "fiber-type": "smf",
                 "SRLG-length": 100000,
                 "pmd": 0.5}]}}
-        response = test_utils_rfc8040.add_oms_attr_request(
+        response = test_utils.add_oms_attr_request(
             "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX", data)
         self.assertEqual(response.status_code, requests.codes.created)
 
 # test service-create for Eth service from xpdr to xpdr
     def test_11_create_connectivity_service_Ethernet(self):
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-connectivity', 'create-connectivity-service', self.cr_serv_input_data)
         time.sleep(self.WAITING)
         self.uuid_services.eth = response['output']['service']['uuid']
@@ -260,7 +260,7 @@ class TransportPCEFulltesting(unittest.TestCase):
 #        time.sleep(self.WAITING)
 
     def test_12_get_service_Ethernet(self):
-        response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
+        response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
         self.assertEqual(response['services'][0]['service-name'], str(self.uuid_services.eth))
@@ -270,7 +270,7 @@ class TransportPCEFulltesting(unittest.TestCase):
 
     def test_13_get_connectivity_service_Ethernet(self):
         self.tapi_serv_details["service-id-or-name"] = str(self.uuid_services.eth)
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-connectivity', 'get-connectivity-service-details', self.tapi_serv_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(response['output']['service']['operational-state'], 'ENABLED')
@@ -286,14 +286,14 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "outOfService",
             "port-qual": "xpdr-network"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8144/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     def test_15_check_update_portmapping(self):
-        response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C1", None, None)
+        response = test_utils.get_portmapping_node_attr("XPDR-C1", None, None)
         self.assertEqual(response['status_code'], requests.codes.ok)
         mapping_list = response['nodes'][0]['mapping']
         for mapping in mapping_list:
@@ -310,7 +310,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_16_check_update_openroadm_topo(self):
-        response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+        response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         node_list = response['network'][0]['node']
         nb_updated_tp = 0
@@ -344,9 +344,9 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_17_check_update_tapi_neps(self):
-        self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+        self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
         self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+OTSi"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -364,7 +364,7 @@ class TransportPCEFulltesting(unittest.TestCase):
                 self.assertEqual(nep['administrative-state'], 'UNLOCKED',
                                  "Administrative State should be 'UNLOCKED'")
         self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+DSR"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -384,8 +384,8 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_18_check_update_tapi_links(self):
-        self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-topology-details', self.tapi_topo)
         time.sleep(2)
         self.assertEqual(response['status_code'], requests.codes.ok)
@@ -404,14 +404,14 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_19_check_update_service_Ethernet(self):
-        response = test_utils_rfc8040.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
+        response = test_utils.get_ordm_serv_list_attr_request("services", str(self.uuid_services.eth))
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(response['services'][0]['operational-state'], 'outOfService')
         self.assertEqual(response['services'][0]['administrative-state'], 'inService')
 
     def test_20_check_update_connectivity_service_Ethernet(self):
         self.tapi_serv_details["service-id-or-name"] = str(self.uuid_services.eth)
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-connectivity', 'get-connectivity-service-details', self.tapi_serv_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         self.assertEqual(response['output']['service']['operational-state'], 'DISABLED')
@@ -426,14 +426,14 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "inService",
             "port-qual": "xpdr-network"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8144/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     def test_22_check_update_portmapping_ok(self):
-        response = test_utils_rfc8040.get_portmapping_node_attr("XPDR-C1", None, None)
+        response = test_utils.get_portmapping_node_attr("XPDR-C1", None, None)
         self.assertEqual(response['status_code'], requests.codes.ok)
         mapping_list = response['nodes'][0]['mapping']
         for mapping in mapping_list:
@@ -444,7 +444,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_23_check_update_openroadm_topo_ok(self):
-        response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+        response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         node_list = response['network'][0]['node']
         for node in node_list:
@@ -462,9 +462,9 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_24_check_update_tapi_neps_ok(self):
-        self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+        self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
         self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+OTSi"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -475,7 +475,7 @@ class TransportPCEFulltesting(unittest.TestCase):
                              "Administrative State should be 'UNLOCKED'")
 
         self.node_details["node-id-or-name"] = "XPDR-C1-XPDR1+DSR"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -487,8 +487,8 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_25_check_update_tapi_links_ok(self):
-        self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-topology-details', self.tapi_topo)
         time.sleep(2)
         link_list = response['output']['topology']['link']
@@ -513,14 +513,14 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "outOfService",
             "port-qual": "roadm-external"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     def test_29_check_update_portmapping(self):
-        response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+        response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
         self.assertEqual(response['status_code'], requests.codes.ok)
         mapping_list = response['nodes'][0]['mapping']
         for mapping in mapping_list:
@@ -537,7 +537,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_30_check_update_openroadm_topo(self):
-        response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+        response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         node_list = response['network'][0]['node']
         nb_updated_tp = 0
@@ -571,9 +571,9 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_31_check_update_tapi_neps(self):
-        self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+        self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
         self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -594,8 +594,8 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_32_check_update_tapi_links(self):
-        self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-topology-details', self.tapi_topo)
         time.sleep(2)
         link_list = response['output']['topology']['link']
@@ -628,14 +628,14 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "inService",
             "port-qual": "roadm-external"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     def test_36_check_update_portmapping_ok(self):
-        response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+        response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
         self.assertEqual(response['status_code'], requests.codes.ok)
         mapping_list = response['nodes'][0]['mapping']
         for mapping in mapping_list:
@@ -649,9 +649,9 @@ class TransportPCEFulltesting(unittest.TestCase):
         self.test_23_check_update_openroadm_topo_ok()
 
     def test_38_check_update_tapi_neps_ok(self):
-        self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+        self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
         self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -682,14 +682,14 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "outOfService",
             "port-qual": "roadm-external"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     def test_43_check_update_portmapping(self):
-        response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+        response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
         self.assertEqual(response['status_code'], requests.codes.ok)
         mapping_list = response['nodes'][0]['mapping']
         for mapping in mapping_list:
@@ -706,7 +706,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_44_check_update_openroadm_topo(self):
-        response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+        response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         node_list = response['network'][0]['node']
         nb_updated_tp = 0
@@ -740,9 +740,9 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_45_check_update_tapi_neps(self):
-        self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+        self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
         self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -763,8 +763,8 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_46_check_update_tapi_links(self):
-        self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-topology-details', self.tapi_topo)
         time.sleep(2)
         self.assertEqual(response['status_code'], requests.codes.ok)
@@ -798,9 +798,9 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "inService",
             "port-qual": "roadm-external"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
@@ -832,14 +832,14 @@ class TransportPCEFulltesting(unittest.TestCase):
             "administrative-state": "outOfService",
             "port-qual": "roadm-external"}]}
         response = requests.request("PUT", url.format("http://127.0.0.1:8141/restconf"),
-                                    data=json.dumps(body), headers=test_utils_rfc8040.TYPE_APPLICATION_JSON,
-                                    auth=(test_utils_rfc8040.ODL_LOGIN, test_utils_rfc8040.ODL_PWD),
-                                    timeout=test_utils_rfc8040.REQUEST_TIMEOUT)
+                                    data=json.dumps(body), headers=test_utils.TYPE_APPLICATION_JSON,
+                                    auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD),
+                                    timeout=test_utils.REQUEST_TIMEOUT)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     def test_57_check_update_portmapping(self):
-        response = test_utils_rfc8040.get_portmapping_node_attr("ROADM-A1", None, None)
+        response = test_utils.get_portmapping_node_attr("ROADM-A1", None, None)
         self.assertEqual(response['status_code'], requests.codes.ok)
         mapping_list = response['nodes'][0]['mapping']
         for mapping in mapping_list:
@@ -856,7 +856,7 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_58_check_update_openroadm_topo(self):
-        response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+        response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         node_list = response['network'][0]['node']
         nb_updated_tp = 0
@@ -883,9 +883,9 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_59_check_update_tapi_neps(self):
-        self.node_details["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
+        self.node_details["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
         self.node_details["node-id-or-name"] = "ROADM-A1+PHOTONIC_MEDIA"
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-node-details', self.node_details)
         self.assertEqual(response['status_code'], requests.codes.ok)
         nep_list = response['output']['node']['owned-node-edge-point']
@@ -906,8 +906,8 @@ class TransportPCEFulltesting(unittest.TestCase):
         time.sleep(1)
 
     def test_60_check_update_tapi_links(self):
-        self.tapi_topo["topology-id-or-name"] = test_utils_rfc8040.T0_FULL_MULTILAYER_TOPO
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        self.tapi_topo["topology-id-or-name"] = test_utils.T0_FULL_MULTILAYER_TOPO
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-topology', 'get-topology-details', self.tapi_topo)
         time.sleep(2)
         self.assertEqual(response['status_code'], requests.codes.ok)
@@ -933,35 +933,35 @@ class TransportPCEFulltesting(unittest.TestCase):
 
     def test_63_delete_connectivity_service_Ethernet(self):
         self.del_serv_input_data["service-id-or-name"] = str(self.uuid_services.eth)
-        response = test_utils_rfc8040.transportpce_api_rpc_request(
+        response = test_utils.transportpce_api_rpc_request(
             'tapi-connectivity', 'delete-connectivity-service', self.del_serv_input_data)
         self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content))
         time.sleep(self.WAITING)
 
     def test_64_disconnect_xponders_from_roadm(self):
-        response = test_utils_rfc8040.get_ietf_network_request('openroadm-topology', 'config')
+        response = test_utils.get_ietf_network_request('openroadm-topology', 'config')
         self.assertEqual(response['status_code'], requests.codes.ok)
         links = response['network'][0]['ietf-network-topology:link']
         for link in links:
             if link["org-openroadm-common-network:link-type"] in ('XPONDER-OUTPUT', 'XPONDER-INPUT'):
-                response = test_utils_rfc8040.del_ietf_network_link_request(
+                response = test_utils.del_ietf_network_link_request(
                     'openroadm-topology', link['link-id'], 'config')
                 self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_65_disconnect_XPDRA(self):
-        response = test_utils_rfc8040.unmount_device("XPDR-A1")
+        response = test_utils.unmount_device("XPDR-A1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_66_disconnect_XPDRC(self):
-        response = test_utils_rfc8040.unmount_device("XPDR-C1")
+        response = test_utils.unmount_device("XPDR-C1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_67_disconnect_ROADMA(self):
-        response = test_utils_rfc8040.unmount_device("ROADM-A1")
+        response = test_utils.unmount_device("ROADM-A1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))
 
     def test_68_disconnect_ROADMC(self):
-        response = test_utils_rfc8040.unmount_device("ROADM-C1")
+        response = test_utils.unmount_device("ROADM-C1")
         self.assertIn(response.status_code, (requests.codes.ok, requests.codes.no_content))