Code Review / transportpce.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
add a method to check nodes configs in func tests
[transportpce.git] / tests / transportpce_tests / 2.2.1 / test_otn_renderer.py
diff --git a/tests/transportpce_tests/2.2.1/test_otn_renderer.py b/tests/transportpce_tests/2.2.1/test_otn_renderer.py
index 48ca830c4149033404328ed4c5d7e76ed04c16b0..6e41792439f96c157e8645236dbfcd0f6f907118 100644 (file)
--- a/tests/transportpce_tests/2.2.1/test_otn_renderer.py
+++ b/tests/transportpce_tests/2.2.1/test_otn_renderer.py
@@ -23,7 +23,7 @@ class TransportPCEtesting(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.processes = test_utils.start_tpce()
-        cls.processes = test_utils.start_sims(['spdrav2'])
+        cls.processes = test_utils.start_sims(['spdra'])
 
     @classmethod
     def tearDownClass(cls):
@@ -35,15 +35,12 @@ class TransportPCEtesting(unittest.TestCase):
         time.sleep(5)
 
     def test_01_connect_SPDR_SA1(self):
-        response = test_utils.mount_device("SPDR-SA1", 'spdrav2')
+        response = test_utils.mount_device("SPDR-SA1", 'spdra')
         self.assertEqual(response.status_code, requests.codes.created, test_utils.CODE_SHOULD_BE_201)
         time.sleep(10)
 
-        url = ("{}/operational/network-topology:"
-               "network-topology/topology/topology-netconf/node/SPDR-SA1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        url = "{}/operational/network-topology:network-topology/topology/topology-netconf/node/SPDR-SA1"
+        response = test_utils.get_request(url)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(
@@ -51,11 +48,8 @@ class TransportPCEtesting(unittest.TestCase):
             'connected')
 
     def test_02_get_portmapping_CLIENT1(self):
-        url = ("{}/config/transportpce-portmapping:network/"
-               "nodes/SPDR-SA1/mapping/XPDR1-CLIENT1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        url = "{}/config/transportpce-portmapping:network/nodes/SPDR-SA1/mapping/XPDR1-CLIENT1"
+        response = test_utils.get_request(url)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn(
@@ -72,11 +66,8 @@ class TransportPCEtesting(unittest.TestCase):
             res['mapping'])
 
     def test_03_get_portmapping_NETWORK1(self):
-        url = ("{}/config/transportpce-portmapping:network/"
-               "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        url = "{}/config/transportpce-portmapping:network/nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
+        response = test_utils.get_request(url)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn(
@@ -93,7 +84,7 @@ class TransportPCEtesting(unittest.TestCase):
             res['mapping'])
 
     def test_04_service_path_create_OCH_OTU4(self):
-        url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
+        url = "{}/operations/transportpce-device-renderer:service-path"
         data = {"renderer:input": {
             "service-name": "service_ODU4",
             "wave-number": "1",
@@ -102,9 +93,7 @@ class TransportPCEtesting(unittest.TestCase):
             "nodes": [
                 {"node-id": "SPDR-SA1",
                  "dest-tp": "XPDR1-NETWORK1"}]}}
-        response = requests.request(
-            "POST", url, data=json.dumps(data),
-            headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.post_request(url, data)
         time.sleep(3)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -116,11 +105,8 @@ class TransportPCEtesting(unittest.TestCase):
              'och-interface-id': ['XPDR1-NETWORK1-1']}, res["output"]['node-interface'])
 
     def test_05_get_portmapping_NETWORK1(self):
-        url = ("{}/config/transportpce-portmapping:network/"
-               "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        url = "{}/config/transportpce-portmapping:network/nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
+        response = test_utils.get_request(url)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn(
@@ -137,34 +123,16 @@ class TransportPCEtesting(unittest.TestCase):
             res['mapping'])
 
     def test_06_check_interface_och(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
 
-        input_dict = {'name': 'XPDR1-NETWORK1-1',
-                      'administrative-state': 'inService',
-                      'supporting-circuit-pack-name': 'CP1-CFP0',
-                      'type': 'org-openroadm-interfaces:opticalChannel',
-                      'supporting-port': 'CP1-CFP0-P1'
-                      }
-        # assertDictContainsSubset is deprecated
-        '''
-        self.assertDictContainsSubset({'name': 'XPDR1-NETWORK1-1', 'administrative-state': 'inService',
-                                       'supporting-circuit-pack-name': 'CP1-CFP0',
-                                       'type': 'org-openroadm-interfaces:opticalChannel',
-                                       'supporting-port': 'CP1-CFP0-P1'}, res['interface'][0])
-        '''
-        self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
-                                   'administrative-state': 'inService',
-                                   'supporting-circuit-pack-name': 'CP1-CFP0',
-                                   'type': 'org-openroadm-interfaces:opticalChannel',
-                                   'supporting-port': 'CP1-CFP0-P1'
-                                   } ,**res['interface'][0]),
+        self.assertDictEqual(dict(res['interface'][0], **{'name': 'XPDR1-NETWORK1-1',
+                                                          'administrative-state': 'inService',
+                                                          'supporting-circuit-pack-name': 'CP1-CFP0',
+                                                          'type': 'org-openroadm-interfaces:opticalChannel',
+                                                          'supporting-port': 'CP1-CFP0-P1'
+                                                          }),
                              res['interface'][0])
 
         self.assertDictEqual(
@@ -173,12 +141,7 @@ class TransportPCEtesting(unittest.TestCase):
             res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
 
     def test_07_check_interface_OTU(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-OTU"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
@@ -197,14 +160,14 @@ class TransportPCEtesting(unittest.TestCase):
                         'fec': 'scfec'
                         }
 
-        self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+        self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
                              res['interface'][0])
 
         self.assertDictEqual(input_dict_2,
-            res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
+                             res['interface'][0]['org-openroadm-otn-otu-interfaces:otu'])
 
     def test_08_otn_service_path_create_ODU4(self):
-        url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
+        url = "{}/operations/transportpce-device-renderer:otn-service-path"
         data = {"renderer:input": {
             "service-name": "service_ODU4",
             "operation": "create",
@@ -213,9 +176,7 @@ class TransportPCEtesting(unittest.TestCase):
             "nodes": [
                 {"node-id": "SPDR-SA1",
                  "network-tp": "XPDR1-NETWORK1"}]}}
-        response = requests.request(
-            "POST", url, data=json.dumps(data),
-            headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.post_request(url, data)
         time.sleep(3)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -226,11 +187,8 @@ class TransportPCEtesting(unittest.TestCase):
              'odu-interface-id': ['XPDR1-NETWORK1-ODU4']}, res["output"]['node-interface'])
 
     def test_09_get_portmapping_NETWORK1(self):
-        url = ("{}/config/transportpce-portmapping:network/"
-               "nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        url = "{}/config/transportpce-portmapping:network/nodes/SPDR-SA1/mapping/XPDR1-NETWORK1"
+        response = test_utils.get_request(url)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn(
@@ -249,12 +207,7 @@ class TransportPCEtesting(unittest.TestCase):
             res['mapping'])
 
     def test_10_check_interface_ODU4(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-ODU4"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU4', 'administrative-state': 'inService',
@@ -262,21 +215,25 @@ class TransportPCEtesting(unittest.TestCase):
                         'type': 'org-openroadm-interfaces:otnOdu',
                         'supporting-port': 'CP1-CFP0-P1'}
         input_dict_2 = {'odu-function': 'org-openroadm-otn-common-types:ODU-TTP',
-                        'rate': 'org-openroadm-otn-common-types:ODU4'}
+                        'rate': 'org-openroadm-otn-common-types:ODU4',
+                        'expected-dapi': 'Swfw02qXGyI=',
+                        'expected-sapi': 'Swfw02qXGyI=',
+                        'tx-dapi': 'Swfw02qXGyI=',
+                        'tx-sapi': 'Swfw02qXGyI='}
 
-        self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+        self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
                              res['interface'][0])
-        self.assertDictEqual(dict(input_dict_2,
-                                  **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+        self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
+                                  **input_dict_2
                                   ),
-                                  res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
+                             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']
                              )
         self.assertDictEqual(
             {u'payload-type': u'21', u'exp-payload-type': u'21'},
             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 
     def test_11_otn_service_path_create_10GE(self):
-        url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
+        url = "{}/operations/transportpce-device-renderer:otn-service-path"
         data = {"renderer:input": {
             "service-name": "service1",
             "operation": "create",
@@ -289,9 +246,7 @@ class TransportPCEtesting(unittest.TestCase):
                 {"node-id": "SPDR-SA1",
                  "client-tp": "XPDR1-CLIENT1",
                  "network-tp": "XPDR1-NETWORK1"}]}}
-        response = requests.request(
-            "POST", url, data=json.dumps(data),
-            headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.post_request(url, data)
         time.sleep(3)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -304,12 +259,7 @@ class TransportPCEtesting(unittest.TestCase):
              'eth-interface-id': ['XPDR1-CLIENT1-ETHERNET10G']}, res["output"]['node-interface'])
 
     def test_12_check_interface_10GE_CLIENT(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-CLIENT1-ETHERNET10G"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         input_dict = {'name': 'XPDR1-CLIENT1-ETHERNET10G',
@@ -318,19 +268,14 @@ class TransportPCEtesting(unittest.TestCase):
                       'type': 'org-openroadm-interfaces:ethernetCsmacd',
                       'supporting-port': 'CP1-SFP4-P1'
                       }
-        self.assertDictEqual(dict(input_dict, **res['interface'][0]),
+        self.assertDictEqual(dict(res['interface'][0], **input_dict),
                              res['interface'][0])
         self.assertDictEqual(
             {u'speed': 10000},
             res['interface'][0]['org-openroadm-ethernet-interfaces:ethernet'])
 
     def test_13_check_interface_ODU2E_CLIENT(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-CLIENT1-ODU2e-service1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
 
@@ -345,22 +290,17 @@ class TransportPCEtesting(unittest.TestCase):
             'rate': 'org-openroadm-otn-common-types:ODU2e',
             'monitoring-mode': 'terminated'}
 
-        self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+        self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
                              res['interface'][0])
-        self.assertDictEqual(dict(input_dict_2,
-                             **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
+        self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
+                                  **input_dict_2),
                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
         self.assertDictEqual(
             {u'payload-type': u'03', u'exp-payload-type': u'03'},
             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']['opu'])
 
     def test_14_check_interface_ODU2E_NETWORK(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-ODU2e-service1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         input_dict_1 = {'name': 'XPDR1-NETWORK1-ODU2e-service1', 'administrative-state': 'inService',
@@ -375,28 +315,25 @@ class TransportPCEtesting(unittest.TestCase):
 
         input_dict_3 = {'trib-port-number': 1}
 
-        self.assertDictEqual(dict(input_dict_1, **res['interface'][0]),
+        self.assertDictEqual(dict(res['interface'][0], **input_dict_1),
                              res['interface'][0])
-        self.assertDictEqual(dict(input_dict_2,
-                             **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu']),
+        self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'],
+                                  **input_dict_2),
                              res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'])
-        self.assertDictEqual(dict(input_dict_3,
-                                  **res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
-                                                  'parent-odu-allocation']),
-                             res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
-                               'parent-odu-allocation'])
+        self.assertDictEqual(dict(res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
+            'parent-odu-allocation'], **input_dict_3
+        ),
+            res['interface'][0]['org-openroadm-otn-odu-interfaces:odu'][
+            'parent-odu-allocation'])
         self.assertIn(1,
                       res['interface'][0][
                           'org-openroadm-otn-odu-interfaces:odu'][
                           'parent-odu-allocation']['trib-slots'])
 
     def test_15_check_ODU2E_connection(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request(
+            "SPDR-SA1",
+            "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         input_dict_1 = {
@@ -405,7 +342,7 @@ class TransportPCEtesting(unittest.TestCase):
             'direction': 'bidirectional'
         }
 
-        self.assertDictEqual(dict(input_dict_1, **res['odu-connection'][0]),
+        self.assertDictEqual(dict(res['odu-connection'][0], **input_dict_1),
                              res['odu-connection'][0])
         self.assertDictEqual({u'dst-if': u'XPDR1-NETWORK1-ODU2e-service1'},
                              res['odu-connection'][0]['destination'])
@@ -413,7 +350,7 @@ class TransportPCEtesting(unittest.TestCase):
                              res['odu-connection'][0]['source'])
 
     def test_16_otn_service_path_delete_10GE(self):
-        url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
+        url = "{}/operations/transportpce-device-renderer:otn-service-path"
         data = {"renderer:input": {
             "service-name": "service1",
             "operation": "delete",
@@ -426,9 +363,7 @@ class TransportPCEtesting(unittest.TestCase):
                 {"node-id": "SPDR-SA1",
                  "client-tp": "XPDR1-CLIENT1",
                  "network-tp": "XPDR1-NETWORK1"}]}}
-        response = requests.request(
-            "POST", url, data=json.dumps(data),
-            headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.post_request(url, data)
         time.sleep(3)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -436,43 +371,25 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertTrue(res["output"]["success"])
 
     def test_17_check_no_ODU2E_connection(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request(
+            "SPDR-SA1",
+            "odu-connection/XPDR1-CLIENT1-ODU2e-service1-x-XPDR1-NETWORK1-ODU2e-service1")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_18_check_no_interface_ODU2E_NETWORK(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-ODU2e-service1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU2e-service1")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_19_check_no_interface_ODU2E_CLIENT(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-CLIENT1-ODU2e-service1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ODU2e-service1")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_20_check_no_interface_10GE_CLIENT(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-CLIENT1-ETHERNET10G"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-CLIENT1-ETHERNET10G")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_21_otn_service_path_delete_ODU4(self):
-        url = "{}/operations/transportpce-device-renderer:otn-service-path".format(test_utils.RESTCONF_BASE_URL)
+        url = "{}/operations/transportpce-device-renderer:otn-service-path"
         data = {"renderer:input": {
             "service-name": "service_ODU4",
             "operation": "delete",
@@ -481,9 +398,7 @@ class TransportPCEtesting(unittest.TestCase):
             "nodes": [
                 {"node-id": "SPDR-SA1",
                  "network-tp": "XPDR1-NETWORK1"}]}}
-        response = requests.request(
-            "POST", url, data=json.dumps(data),
-            headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.post_request(url, data)
         time.sleep(3)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -491,16 +406,11 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertTrue(res["output"]["success"])
 
     def test_22_check_no_interface_ODU4(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-ODU4"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-ODU4")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_23_service_path_delete_OCH_OTU4(self):
-        url = "{}/operations/transportpce-device-renderer:service-path".format(test_utils.RESTCONF_BASE_URL)
+        url = "{}/operations/transportpce-device-renderer:service-path"
         data = {"renderer:input": {
             "service-name": "service_OTU4",
             "wave-number": "1",
@@ -509,9 +419,7 @@ class TransportPCEtesting(unittest.TestCase):
             "nodes": [
                 {"node-id": "SPDR-SA1",
                  "dest-tp": "XPDR1-NETWORK1"}]}}
-        response = requests.request(
-            "POST", url, data=json.dumps(data),
-            headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.post_request(url, data)
         time.sleep(3)
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
@@ -519,21 +427,11 @@ class TransportPCEtesting(unittest.TestCase):
         self.assertTrue(res["output"]["success"])
 
     def test_24_check_no_interface_OTU4(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-OTU"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-OTU")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_25_check_no_interface_OCH(self):
-        url = ("{}/config/network-topology:network-topology/topology/topology-netconf/"
-               "node/SPDR-SA1/yang-ext:mount/org-openroadm-device:org-openroadm-device/"
-               "interface/XPDR1-NETWORK1-1"
-               .format(test_utils.RESTCONF_BASE_URL))
-        response = requests.request(
-            "GET", url, headers=test_utils.TYPE_APPLICATION_JSON, auth=(test_utils.ODL_LOGIN, test_utils.ODL_PWD))
+        response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
         self.assertEqual(response.status_code, requests.codes.not_found)
 
     def test_26_disconnect_SPDR_SA1(self):
Repository for Transport PCE project.