run autopep8 on functional tests
[transportpce.git] / tests / transportpce_tests / 1.2.1 / test_pce.py
index 7ff098f62341f355d3c2e77137a91a2e93f97599..00aab10de22aa02ae3a1996dfc4489b7a40feba0 100644 (file)
@@ -70,16 +70,13 @@ class TransportPCEtesting(unittest.TestCase):
 
      # Load simple bidirectional topology
     def test_01_load_simple_topology_bi(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology"
-        data = self.simple_topo_bi_dir_data
-        response = test_utils.put_xmlrequest(url, data)
+        response = test_utils.put_xmlrequest(test_utils.URL_CONFIG_ORDM_TOPO, self.simple_topo_bi_dir_data)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     # Get existing nodeId
     def test_02_get_nodeId(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
-        response = test_utils.get_request(url)
+        response = test_utils.get_ordm_topo_request("node/ROADMA01-SRG1")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(
@@ -88,8 +85,7 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Get existing linkId
     def test_03_get_linkId(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX"
-        response = test_utils.get_request(url)
+        response = test_utils.get_ordm_topo_request("link/XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(
@@ -99,29 +95,10 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Path Computation success
     def test_04_path_computation_xpdr_bi(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service-1",
-                "resource-reserve": "true",
-                "pce-metric": "hop-count",
-                "service-handler-header": {
-                    "request-id": "request-1"
-                },
-                "service-a-end": {
-                    "node-id": "XPDRA01",
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "nodeA"
-                },
-                "service-z-end": {
-                    "node-id": "XPDRC01",
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "nodeC"
-                }
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request-1", "service-1",
+                                                       {"node-id": "XPDRA01", "service-rate": "100",
+                                                           "service-format": "Ethernet", "clli": "nodeA"},
+                                                       {"node-id": "XPDRC01", "service-rate": "100", "service-format": "Ethernet", "clli": "nodeC"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -130,29 +107,10 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Path Computation success
     def test_05_path_computation_rdm_bi(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service-1",
-                "resource-reserve": "true",
-                "pce-metric": "hop-count",
-                "service-handler-header": {
-                    "request-id": "request-1"
-                },
-                "service-a-end": {
-                    "node-id": "ROADMA01",
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "NodeA"
-                },
-                "service-z-end": {
-                    "node-id": "ROADMC01",
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "NodeC"
-                }
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request-1", "service-1",
+                                                       {"node-id": "ROADMA01", "service-rate": "100",
+                                                           "service-format": "Ethernet", "clli": "NodeA"},
+                                                       {"node-id": "ROADMC01", "service-rate": "100", "service-format": "Ethernet", "clli": "NodeC"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -161,30 +119,25 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Delete topology
     def test_06_delete_simple_topology_bi(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology"
-        response = test_utils.delete_request(url)
+        response = test_utils.delete_request(test_utils.URL_CONFIG_ORDM_TOPO)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     # Test deleted topology
     def test_07_test_topology_simple_bi_deleted(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/node/ROADMA01-SRG1"
-        response = test_utils.get_request(url)
-        self.assertEqual(response.status_code, 404)
+        response = test_utils.get_ordm_topo_request("node/ROADMA01-SRG1")
+        self.assertEqual(response.status_code, requests.codes.conflict)
         time.sleep(1)
 
     # Load simple bidirectional topology
     def test_08_load_simple_topology_uni(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology"
-        data = self.simple_topo_uni_dir_data
-        response = test_utils.put_xmlrequest(url, data)
+        response = test_utils.put_xmlrequest(test_utils.URL_CONFIG_ORDM_TOPO, self.simple_topo_uni_dir_data)
         self.assertEqual(response.status_code, 201)
         time.sleep(2)
 
     # Get existing nodeId
     def test_09_get_nodeId(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-1-2"
-        response = test_utils.get_request(url)
+        response = test_utils.get_ordm_topo_request("node/XPONDER-1-2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(
@@ -194,8 +147,7 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Get existing linkId
     def test_10_get_linkId(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/link/XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX"
-        response = test_utils.get_request(url)
+        response = test_utils.get_ordm_topo_request("link/XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(
@@ -205,29 +157,10 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Path Computation success
     def test_11_path_computation_xpdr_uni(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service-1",
-                "resource-reserve": "true",
-                "pce-metric": "hop-count",
-                "service-handler-header": {
-                    "request-id": "request-1"
-                },
-                "service-a-end": {
-                    "node-id": "XPONDER-1-2",
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "ORANGE1"
-                },
-                "service-z-end": {
-                    "node-id": "XPONDER-3-2",
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "ORANGE3"
-                }
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request-1", "service-1",
+                                                       {"node-id": "XPONDER-1-2", "service-rate": "100",
+                                                           "service-format": "Ethernet", "clli": "ORANGE1"},
+                                                       {"node-id": "XPONDER-3-2", "service-rate": "100", "service-format": "Ethernet", "clli": "ORANGE3"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -236,29 +169,10 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Path Computation success
     def test_12_path_computation_rdm_uni(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service1",
-                "resource-reserve": "true",
-                "service-handler-header": {
-                    "request-id": "request1"
-                },
-                "service-a-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "cll21",
-                    "node-id": "OpenROADM-2-1"
-                },
-                "service-z-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "clli": "ncli22",
-                    "node-id": "OpenROADM-2-2"
-                },
-                "pce-metric": "hop-count"
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request1", "service1",
+                                                       {"service-rate": "100", "service-format": "Ethernet",
+                                                           "clli": "cll21", "node-id": "OpenROADM-2-1"},
+                                                       {"service-rate": "100", "service-format": "Ethernet", "clli": "ncli22", "node-id": "OpenROADM-2-2"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -279,30 +193,25 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Delete topology
     def test_13_delete_simple_topology(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology"
-        response = test_utils.delete_request(url)
+        response = test_utils.delete_request(test_utils.URL_CONFIG_ORDM_TOPO)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     # Test deleted topology
     def test_14_test_topology_simple_deleted(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-1-2"
-        response = test_utils.get_request(url)
-        self.assertEqual(response.status_code, 404)
+        response = test_utils.get_ordm_topo_request("node/XPONDER-1-2")
+        self.assertEqual(response.status_code, requests.codes.conflict)
         time.sleep(1)
 
     # Load complex topology
     def test_15_load_complex_topology(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology"
-        data = self.complex_topo_uni_dir_data
-        response = test_utils.put_xmlrequest(url, data)
+        response = test_utils.put_xmlrequest(test_utils.URL_CONFIG_ORDM_TOPO, self.complex_topo_uni_dir_data)
         self.assertEqual(response.status_code, 201)
         time.sleep(2)
 
     # Get existing nodeId
     def test_16_get_nodeId(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
-        response = test_utils.get_request(url)
+        response = test_utils.get_ordm_topo_request("node/XPONDER-3-2")
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertEqual(
@@ -312,14 +221,8 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Test failed path computation
     def test_17_fail_path_computation(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-handler-header": {
-                    "request-id": "request-1"
-                }
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.post_request(test_utils.URL_PATH_COMPUTATION_REQUEST,
+                                           {"input": {"service-handler-header": {"request-id": "request-1"}}})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Service Name is not set',
@@ -328,94 +231,50 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Test1 success path computation
     def test_18_success1_path_computation(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service1",
-                "resource-reserve": "true",
-                "service-handler-header": {
-                    "request-id": "request1"
-                },
-                "service-a-end": {
-                    "service-format": "Ethernet",
-                    "service-rate": "100",
-                    "clli": "ORANGE2",
-                    "node-id": "XPONDER-2-2",
-                    "tx-direction": {
-                        "port": {
-                            "port-device-name": "Some port-device-name",
-                            "port-type": "Some port-type",
-                            "port-name": "Some port-name",
-                            "port-rack": "Some port-rack",
-                            "port-shelf": "Some port-shelf",
-                            "port-slot": "Some port-slot",
-                            "port-sub-slot": "Some port-sub-slot"
-                        }
-                    },
-                    "rx-direction": {
-                        "port": {
-                            "port-device-name": "Some port-device-name",
-                            "port-type": "Some port-type",
-                            "port-name": "Some port-name",
-                            "port-rack": "Some port-rack",
-                            "port-shelf": "Some port-shelf",
-                            "port-slot": "Some port-slot",
-                            "port-sub-slot": "Some port-sub-slot"
-                        }
-                    }
-                },
-                "service-z-end": {
-                    "service-format": "Ethernet",
-                    "service-rate": "100",
-                    "clli": "ORANGE1",
-                    "node-id": "XPONDER-1-2",
-                    "tx-direction": {
-                        "port": {
-                            "port-device-name": "Some port-device-name",
-                            "port-type": "Some port-type",
-                            "port-name": "Some port-name",
-                            "port-rack": "Some port-rack",
-                            "port-shelf": "Some port-shelf",
-                            "port-slot": "Some port-slot",
-                            "port-sub-slot": "Some port-sub-slot"
-                        }
-                    },
-                    "rx-direction": {
-                        "port": {
-                            "port-device-name": "Some port-device-name",
-                            "port-type": "Some port-type",
-                            "port-name": "Some port-name",
-                            "port-rack": "Some port-rack",
-                            "port-shelf": "Some port-shelf",
-                            "port-slot": "Some port-slot",
-                            "port-sub-slot": "Some port-sub-slot"
-                        }
-                    }
-                },
-                "hard-constraints": {
-                    "customer-code": [
-                        "Some customer-code"
-                    ],
-                    "co-routing": {
-                        "existing-service": [
-                            "Some existing-service"
-                        ]
-                    }
-                },
-                "soft-constraints": {
-                    "customer-code": [
-                        "Some customer-code"
-                    ],
-                    "co-routing": {
-                        "existing-service": [
-                            "Some existing-service"
-                        ]
-                    }
-                },
-                "pce-metric": "hop-count",
-                "locally-protected-links": "true"
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request1", "service1",
+                                                       {"service-format": "Ethernet", "service-rate": "100", "clli": "ORANGE2", "node-id": "XPONDER-2-2",
+                                                        "tx-direction": {"port": {
+                                                            "port-device-name": "Some port-device-name",
+                                                            "port-type": "Some port-type",
+                                                            "port-name": "Some port-name",
+                                                            "port-rack": "Some port-rack",
+                                                            "port-shelf": "Some port-shelf",
+                                                            "port-slot": "Some port-slot",
+                                                            "port-sub-slot": "Some port-sub-slot"
+                                                        }},
+                                                           "rx-direction": {"port": {
+                                                               "port-device-name": "Some port-device-name",
+                                                               "port-type": "Some port-type",
+                                                               "port-name": "Some port-name",
+                                                               "port-rack": "Some port-rack",
+                                                               "port-shelf": "Some port-shelf",
+                                                               "port-slot": "Some port-slot",
+                                                               "port-sub-slot": "Some port-sub-slot"
+                                                           }}},
+                                                       {"service-format": "Ethernet", "service-rate": "100", "clli": "ORANGE1", "node-id": "XPONDER-1-2",
+                                                           "tx-direction": {"port": {
+                                                               "port-device-name": "Some port-device-name",
+                                                               "port-type": "Some port-type",
+                                                               "port-name": "Some port-name",
+                                                               "port-rack": "Some port-rack",
+                                                               "port-shelf": "Some port-shelf",
+                                                               "port-slot": "Some port-slot",
+                                                               "port-sub-slot": "Some port-sub-slot"
+                                                           }},
+                                                           "rx-direction": {"port": {
+                                                               "port-device-name": "Some port-device-name",
+                                                               "port-type": "Some port-type",
+                                                               "port-name": "Some port-name",
+                                                               "port-rack": "Some port-rack",
+                                                               "port-shelf": "Some port-shelf",
+                                                               "port-slot": "Some port-slot",
+                                                               "port-sub-slot": "Some port-sub-slot"
+                                                           }}},
+                                                       {"customer-code": ["Some customer-code"],
+                                                           "co-routing": {"existing-service": ["Some existing-service"]}},
+                                                       {"customer-code": ["Some customer-code"],
+                                                           "co-routing": {"existing-service": ["Some existing-service"]}},
+                                                       "hop-count", {"locally-protected-links": "true"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -424,29 +283,10 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Test2 success path computation with path description
     def test_19_success2_path_computation(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service 1",
-                "resource-reserve": "true",
-                "service-handler-header": {
-                    "request-id": "request 1"
-                },
-                "service-a-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-1-2",
-                    "clli": "ORANGE1"
-                },
-                "service-z-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-3-2",
-                    "clli": "ORANGE3"
-                },
-                "pce-metric": "hop-count"
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request 1", "service 1",
+                                                       {"service-rate": "100", "service-format": "Ethernet",
+                                                           "node-id": "XPONDER-1-2", "clli": "ORANGE1"},
+                                                       {"service-rate": "100", "service-format": "Ethernet", "node-id": "XPONDER-3-2", "clli": "ORANGE3"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -459,34 +299,12 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Test3 success path computation with hard-constraints exclude
     def test_20_success3_path_computation(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service 1",
-                "resource-reserve": "true",
-                "service-handler-header": {
-                    "request-id": "request 1"
-                },
-                "service-a-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-1-2",
-                    "clli": "ORANGE1"
-                },
-                "service-z-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-3-2",
-                    "clli": "ORANGE3"
-                },
-                "hard-constraints": {
-                    "exclude_": {
-                        "node-id": ["OpenROADM-2-1", "OpenROADM-2-2"]
-                    }
-                },
-                "pce-metric": "hop-count"
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request 1", "service 1",
+                                                       {"service-rate": "100", "service-format": "Ethernet",
+                                                           "node-id": "XPONDER-1-2", "clli": "ORANGE1"},
+                                                       {"service-rate": "100", "service-format": "Ethernet",
+                                                           "node-id": "XPONDER-3-2", "clli": "ORANGE3"},
+                                                       {"exclude_": {"node-id": ["OpenROADM-2-1", "OpenROADM-2-2"]}})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -499,29 +317,10 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Path computation before deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
     def test_21_path_computation_before_oms_attribute_deletion(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service 1",
-                "resource-reserve": "true",
-                "service-handler-header": {
-                    "request-id": "request 1"
-                },
-                "service-a-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-2-2",
-                    "clli": "ORANGE2"
-                },
-                "service-z-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-1-2",
-                    "clli": "ORANGE1"
-                },
-                "pce-metric": "hop-count"
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request 1", "service 1",
+                                                       {"service-rate": "100", "service-format": "Ethernet",
+                                                           "node-id": "XPONDER-2-2", "clli": "ORANGE2"},
+                                                       {"service-rate": "100", "service-format": "Ethernet", "node-id": "XPONDER-1-2", "clli": "ORANGE1"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -540,38 +339,16 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Delete oms-attribute in the link :openroadm1-3 to openroadm1-2
     def test_22_delete_oms_attribute_in_openroadm13toopenroadm12_link(self):
-        url = ("{}/config/ietf-network:networks/network/openroadm-topology/ietf-network-topology:link/"
-               "OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2/org-openroadm-network-topology:OMS-attributes/span"
-               )
-        response = test_utils.delete_request(url)
+        response = test_utils.del_oms_attr_request("OpenROADM-1-3-DEG2-to-OpenROADM-1-2-DEG2")
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     # Path computation after deleting oms-attribute of the link :openroadm1-3 to openroadm1-2
     def test_23_path_computation_after_oms_attribute_deletion(self):
-        url = "{}/operations/transportpce-pce:path-computation-request"
-        data = {"input": {
-                "service-name": "service 1",
-                "resource-reserve": "true",
-                "service-handler-header": {
-                    "request-id": "request 1"
-                },
-                "service-a-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-2-2",
-                    "clli": "ORANGE2"
-                },
-                "service-z-end": {
-                    "service-rate": "100",
-                    "service-format": "Ethernet",
-                    "node-id": "XPONDER-1-2",
-                    "clli": "ORANGE1"
-                },
-                "pce-metric": "hop-count"
-                }
-                }
-        response = test_utils.post_request(url, data)
+        response = test_utils.path_computation_request("request 1", "service 1",
+                                                       {"service-rate": "100", "service-format": "Ethernet",
+                                                           "node-id": "XPONDER-2-2", "clli": "ORANGE2"},
+                                                       {"service-rate": "100", "service-format": "Ethernet", "node-id": "XPONDER-1-2", "clli": "ORANGE1"})
         self.assertEqual(response.status_code, requests.codes.ok)
         res = response.json()
         self.assertIn('Path is calculated',
@@ -590,16 +367,14 @@ class TransportPCEtesting(unittest.TestCase):
 
     # Delete complex topology
     def test_24_delete_complex_topology(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology"
-        response = test_utils.delete_request(url)
+        response = test_utils.delete_request(test_utils.URL_CONFIG_ORDM_TOPO)
         self.assertEqual(response.status_code, requests.codes.ok)
         time.sleep(2)
 
     # Test deleted complex topology
     def test_25_test_topology_complex_deleted(self):
-        url = "{}/config/ietf-network:networks/network/openroadm-topology/node/XPONDER-3-2"
-        response = test_utils.get_request(url)
-        self.assertEqual(response.status_code, 404)
+        response = test_utils.get_ordm_topo_request("node/XPONDER-3-2")
+        self.assertEqual(response.status_code, requests.codes.conflict)
         time.sleep(1)