tests: mock HTTP post calls to prevent race conditions

Previously, multiple tests were publishing the same task concurrently,
which increased the likelihood of race conditions and flaky failures.
This update replaces real HTTP post calls with mocks, making the tests
deterministic and isolated from the server.

Author: geetu040

tests/test_api/test_http.py

@@ -1,8 +1,7 @@
-from requests import Response, Request
-import time
-import xmltodict
+from requests import Response, Request, Session
+from unittest.mock import patch
 import pytest
-from openml.testing import TestBase, TestAPIBase
+from openml.testing import TestAPIBase
 import os
 from pathlib import Path
 from urllib.parse import urljoin
@@ -122,32 +121,6 @@ def test_get_refresh_cache(self):
         self.assertEqual(response2.status_code, 200)
         self.assertEqual(response1.content, response2.content)
 
-    @pytest.mark.uses_test_server()
-    def test_post_and_delete(self):
-        task_xml = """
-        <oml:task_inputs xmlns:oml="http://openml.org/openml">
-            <oml:task_type_id>5</oml:task_type_id>
-            <oml:input name="source_data">193</oml:input>
-            <oml:input name="estimation_procedure">17</oml:input>
-        </oml:task_inputs>
-        """
-        # post
-        response = self.http_client.post(
-            "task",
-            files={"description": task_xml},
-        )
-        self.assertEqual(response.status_code, 200)
-        xml_resp = xmltodict.parse(response.content)
-        task_id = int(xml_resp["oml:upload_task"]["oml:id"])
-
-        # cleanup incase of failure
-        TestBase._mark_entity_for_removal("task", task_id)
-        TestBase.logger.info(f"collected from {__file__}: {task_id}")
-
-        # delete
-        response = self.http_client.delete(f"task/{task_id}")
-        self.assertEqual(response.status_code, 200)
-
     @pytest.mark.uses_test_server()
     def test_download_creates_file(self):
         # small stable resource
@@ -198,3 +171,44 @@ def handler(response, path: Path, encoding: str):
 
         assert path.exists()
         assert path.read_text() == "HANDLED"
+
+    def test_post(self):
+        resource_name = "resource"
+        resource_files = {"description": """Resource Description File"""}
+
+        with patch.object(Session, "request") as mock_request:
+            mock_request.return_value = Response()
+            mock_request.return_value.status_code = 200
+
+            self.http_client.post(
+                resource_name,
+                files=resource_files,
+            )
+
+            mock_request.assert_called_once_with(
+                method="POST",
+                url=self.http_client.server + self.http_client.base_url + resource_name,
+                params={},
+                data={'api_key': self.http_client.api_key},
+                headers=self.http_client.headers,
+                files=resource_files,
+            )
+
+    def test_delete(self):
+        resource_name = "resource"
+        resource_id = 123
+
+        with patch.object(Session, "request") as mock_request:
+            mock_request.return_value = Response()
+            mock_request.return_value.status_code = 200
+
+            self.http_client.delete(f"{resource_name}/{resource_id}")
+
+            mock_request.assert_called_once_with(
+                method="DELETE",
+                url=self.http_client.server + self.http_client.base_url + resource_name + "/" + str(resource_id),
+                params={'api_key': self.http_client.api_key},
+                data={},
+                headers=self.http_client.headers,
+                files=None,
+            )

tests/test_api/test_versions.py

@@ -1,49 +1,106 @@
-from time import time
 import pytest
-from openml.testing import TestBase, TestAPIBase
-from openml._api import ResourceV1API, ResourceV2API, FallbackProxy, ResourceAPI
+from requests import Session, Response
+from unittest.mock import patch
+from openml.testing import TestAPIBase
+from openml._api import FallbackProxy, ResourceAPI
 from openml.enums import ResourceType, APIVersion
 from openml.exceptions import OpenMLNotSupportedError
 
 
-@pytest.mark.uses_test_server()
 class TestResourceAPIBase(TestAPIBase):
     resource: ResourceAPI | FallbackProxy
 
-    def _publish_and_delete(self):
-        task_xml = """
-        <oml:task_inputs xmlns:oml="http://openml.org/openml">
-            <oml:task_type_id>5</oml:task_type_id>
-            <oml:input name="source_data">193</oml:input>
-            <oml:input name="estimation_procedure">17</oml:input>
-        </oml:task_inputs>
-        """
-        # publish
-        task_id = self.resource.publish(
-            "task",
-            files={"description": task_xml},
-        )
-        self.assertIsNotNone(task_id)
-
-        # cleanup incase of failure
-        TestBase._mark_entity_for_removal("task", task_id)
-        TestBase.logger.info(f"collected from {__file__}: {task_id}")
-
-        # delete
-        success = self.resource.delete(task_id)
-        self.assertTrue(success)
-
-    def _tag_and_untag(self):
-        resource_id = 1
-        unique_indicator = str(time()).replace(".", "")
-        tag = f"{self.__class__.__name__}_test_tag_and_untag_{unique_indicator}"
-
-        tags = self.resource.tag(resource_id, tag)
-        self.assertIn(tag, tags)
-
-        tags = self.resource.untag(resource_id, tag)
-        self.assertNotIn(tag, tags)
-
+    @property
+    def http_client(self):
+        return self.resource._http
+
+    def _publish(self):
+        resource_name = "task"
+        resource_files = {"description": """Resource Description File"""}
+        resource_id = 123
+
+        with patch.object(Session, "request") as mock_request:
+            mock_request.return_value = Response()
+            mock_request.return_value.status_code = 200
+            mock_request.return_value._content = f'<oml:upload_task xmlns:oml="http://openml.org/openml">\n\t<oml:id>{resource_id}</oml:id>\n</oml:upload_task>\n'.encode("utf-8")
+
+            published_resource_id = self.resource.publish(
+                resource_name,
+                files=resource_files,
+            )
+
+            self.assertEqual(resource_id, published_resource_id)
+
+            mock_request.assert_called_once_with(
+                method="POST",
+                url=self.http_client.server + self.http_client.base_url + resource_name,
+                params={},
+                data={'api_key': self.http_client.api_key},
+                headers=self.http_client.headers,
+                files=resource_files,
+            )
+
+    def _delete(self):
+        resource_name = "task"
+        resource_id = 123
+
+        with patch.object(Session, "request") as mock_request:
+            mock_request.return_value = Response()
+            mock_request.return_value.status_code = 200
+            mock_request.return_value._content = f'<oml:task_delete xmlns:oml="http://openml.org/openml">\n  <oml:id>{resource_id}</oml:id>\n</oml:task_delete>\n'.encode("utf-8")
+
+            self.resource.delete(resource_id)
+
+            mock_request.assert_called_once_with(
+                method="DELETE",
+                url=self.http_client.server + self.http_client.base_url + resource_name + "/" + str(resource_id),
+                params={'api_key': self.http_client.api_key},
+                data={},
+                headers=self.http_client.headers,
+                files=None,
+            )
+
+    def _tag(self):
+        resource_id = 123
+        resource_tag = "TAG"
+
+        with patch.object(Session, "request") as mock_request:
+            mock_request.return_value = Response()
+            mock_request.return_value.status_code = 200
+            mock_request.return_value._content = f'<oml:task_tag xmlns:oml="http://openml.org/openml"><oml:id>{resource_id}</oml:id><oml:tag>{resource_tag}</oml:tag></oml:task_tag>'.encode("utf-8")
+
+            tags = self.resource.tag(resource_id, resource_tag)
+            self.assertIn(resource_tag, tags)
+
+            mock_request.assert_called_once_with(
+                method="POST",
+                url=self.http_client.server + self.http_client.base_url + self.resource.resource_type + "/tag",
+                params={},
+                data={'api_key': self.http_client.api_key, 'task_id': resource_id, 'tag': resource_tag},
+                headers=self.http_client.headers,
+                files=None,
+            )
+
+    def _untag(self):
+        resource_id = 123
+        resource_tag = "TAG"
+
+        with patch.object(Session, "request") as mock_request:
+            mock_request.return_value = Response()
+            mock_request.return_value.status_code = 200
+            mock_request.return_value._content = f'<oml:task_untag xmlns:oml="http://openml.org/openml"><oml:id>{resource_id}</oml:id></oml:task_untag>'.encode("utf-8")
+
+            tags = self.resource.untag(resource_id, resource_tag)
+            self.assertNotIn(resource_tag, tags)
+
+            mock_request.assert_called_once_with(
+                method="POST",
+                url=self.http_client.server + self.http_client.base_url + self.resource.resource_type + "/untag",
+                params={},
+                data={'api_key': self.http_client.api_key, 'task_id': resource_id, 'tag': resource_tag},
+                headers=self.http_client.headers,
+                files=None,
+            )
 
 class TestResourceV1API(TestResourceAPIBase):
     def setUp(self):
@@ -53,11 +110,17 @@ def setUp(self):
             resource_type=ResourceType.TASK,
         )
 
-    def test_publish_and_delete(self):
-        self._publish_and_delete()
+    def test_publish(self):
+        self._publish()
+
+    def test_delete(self):
+        self._delete()
 
-    def test_tag_and_untag(self):
-        self._tag_and_untag()
+    def test_tag(self):
+        self._tag()
+
+    def test_untag(self):
+        self._untag()
 
 
 class TestResourceV2API(TestResourceAPIBase):
@@ -68,16 +131,29 @@ def setUp(self):
             resource_type=ResourceType.TASK,
         )
 
-    def test_publish_and_delete(self):
+    def test_publish(self):
+        with pytest.raises(OpenMLNotSupportedError):
+            self._publish()
+
+    def test_delete(self):
+        with pytest.raises(OpenMLNotSupportedError):
+            self._delete()
+
+    def test_tag(self):
         with pytest.raises(OpenMLNotSupportedError):
-            self._tag_and_untag()
+            self._tag()
 
-    def test_tag_and_untag(self):
+    def test_untag(self):
         with pytest.raises(OpenMLNotSupportedError):
-            self._tag_and_untag()
+            self._untag()
 
 
 class TestResourceFallbackAPI(TestResourceAPIBase):
+    @property
+    def http_client(self):
+        # since these methods are not implemented for v2, they will fallback to v1 api
+        return self.http_clients[APIVersion.V1]
+
     def setUp(self):
         super().setUp()
         resource_v1 = self._create_resource(
@@ -90,8 +166,14 @@ def setUp(self):
         )
         self.resource = FallbackProxy(resource_v2, resource_v1)
 
-    def test_publish_and_delete(self):
-        self._publish_and_delete()
+    def test_publish(self):
+        self._publish()
+
+    def test_delete(self):
+        self._delete()
+
+    def test_tag(self):
+        self._tag()
 
-    def test_tag_and_untag(self):
-        self._tag_and_untag()
+    def test_untag(self):
+        self._untag()