update/refactor tests

Author: geetu040

openml/testing.py

@@ -11,13 +11,12 @@
 import unittest
 from pathlib import Path
 from typing import ClassVar
-from urllib.parse import urljoin
 
 import requests
 
 import openml
 from openml._api import HTTPCache, HTTPClient, MinIOClient
-from openml.enums import RetryPolicy
+from openml.enums import APIVersion, RetryPolicy
 from openml.exceptions import OpenMLServerException
 from openml.tasks import TaskType
 
@@ -283,90 +282,53 @@ def _check_fold_timing_evaluations(  # noqa: PLR0913
 
 
 class TestAPIBase(unittest.TestCase):
-    server: str
-    base_url: str
-    api_key: str
     retries: int
     retry_policy: RetryPolicy
-    dir: str
     ttl: int
+    cache_dir: Path
     cache: HTTPCache
-    http_client: HTTPClient
+    http_clients: dict[APIVersion, HTTPClient]
+    minio_client: MinIOClient
+    current_api_version: APIVersion | None
 
     def setUp(self) -> None:
-        self.server = "https://test.openml.org/"
-        self.base_url = "api/v1/xml"
-        self.api_key = "normaluser"
-        self.retries = 3
-        self.retry_policy = RetryPolicy.HUMAN
-        self.dir = "test_cache"
-        self.ttl = 60 * 60 * 24 * 7
-
-        self.cache = self._get_http_cache(
-            path=Path(self.dir),
-            ttl=self.ttl,
-        )
-        self.http_client = self._get_http_client(
-            server=self.server,
-            base_url=self.base_url,
-            api_key=self.api_key,
-            retries=self.retries,
-            retry_policy=self.retry_policy,
-            cache=self.cache,
-        )
-        self.minio_client = self._get_minio_client(path=Path(self.dir))
+        config = openml._backend.get_config()
 
-        if self.cache.path.exists():
-            shutil.rmtree(self.cache.path)
-
-    def tearDown(self) -> None:
-        if self.cache.path.exists():
-            shutil.rmtree(self.cache.path)
+        self.retries = config.connection.retries
+        self.retry_policy = config.connection.retry_policy
+        self.ttl = config.cache.ttl
+        self.current_api_version = None
 
-    def _get_http_cache(
-        self,
-        path: Path,
-        ttl: int,
-    ) -> HTTPCache:
-        return HTTPCache(
-            path=path,
-            ttl=ttl,
-        )
+        abspath_this_file = Path(inspect.getfile(self.__class__)).absolute()
+        self.cache_dir = abspath_this_file.parent.parent / "files"
+        if not self.cache_dir.is_dir():
+            raise ValueError(
+                f"Cannot find test cache dir, expected it to be {self.cache_dir}!",
+            )
 
-    def _get_http_client(  # noqa: PLR0913
-        self,
-        server: str,
-        base_url: str,
-        api_key: str,
-        retries: int,
-        retry_policy: RetryPolicy,
-        cache: HTTPCache | None = None,
-    ) -> HTTPClient:
-        return HTTPClient(
-            server=server,
-            base_url=base_url,
-            api_key=api_key,
-            retries=retries,
-            retry_policy=retry_policy,
-            cache=cache,
+        self.cache = HTTPCache(
+            path=self.cache_dir,
+            ttl=self.ttl,
         )
-
-    def _get_minio_client(
-        self,
-        path: Path | None = None,
-    ) -> MinIOClient:
-        return MinIOClient(path=path)
-
-    def _get_url(
-        self,
-        server: str | None = None,
-        base_url: str | None = None,
-        path: str | None = None,
-    ) -> str:
-        server = server if server else self.server
-        base_url = base_url if base_url else self.base_url
-        path = path if path else ""
-        return urljoin(self.server, urljoin(self.base_url, path))
+        self.http_clients = {
+            APIVersion.V1: HTTPClient(
+                server="https://test.openml.org/",
+                base_url="api/v1/xml/",
+                api_key="normaluser",
+                retries=self.retries,
+                retry_policy=self.retry_policy,
+                cache=self.cache,
+            ),
+            APIVersion.V2: HTTPClient(
+                server="http://localhost:8002/",
+                base_url="",
+                api_key="",
+                retries=self.retries,
+                retry_policy=self.retry_policy,
+                cache=self.cache,
+            ),
+        }
+        self.minio_client = MinIOClient(path=self.cache_dir)
 
 
 def check_task_existence(

tests/test_api/test_http.py

@@ -4,11 +4,22 @@
 import pytest
 from openml.testing import TestAPIBase
 import os
+from urllib.parse import urljoin
+from openml.enums import APIVersion
 
 
 class TestHTTPClient(TestAPIBase):
+    def setUp(self):
+        super().setUp()
+        self.http_client = self.http_clients[APIVersion.V1]
+
+    def _prepare_url(self, path: str | None = None) -> str:
+        server = self.http_client.server
+        base_url = self.http_client.base_url
+        return urljoin(server, urljoin(base_url, path))
+
     def test_cache(self):
-        url = self._get_url(path="task/31")
+        url = self._prepare_url(path="task/31")
         params = {"param1": "value1", "param2": "value2"}
 
         key = self.cache.get_key(url, params)
@@ -18,6 +29,7 @@ def test_cache(self):
             "test",
             "api",
             "v1",
+            "xml",
             "task",
             "31",
             "param1=value1&param2=value2",
@@ -68,7 +80,7 @@ def test_get_with_cache_creates_cache(self):
 
         # verify cache directory structure exists
         cache_key = self.cache.get_key(
-            self._get_url(path="task/1"),
+            self._prepare_url(path="task/1"),
             {},
         )
         cache_path = self.cache._key_to_path(cache_key)
@@ -94,7 +106,7 @@ def test_get_cache_expires(self):
         self.cache.ttl = 1
         path = "task/1"
 
-        url = self._get_url(path=path)
+        url = self._prepare_url(path=path)
         key = self.cache.get_key(url, {})
         cache_path = self.cache._key_to_path(key) / "meta.json"
 
@@ -115,7 +127,7 @@ def test_get_cache_expires(self):
     def test_get_reset_cache(self):
         path = "task/1"
 
-        url = self._get_url(path=path)
+        url = self._prepare_url(path=path)
         key = self.cache.get_key(url, {})
         cache_path = self.cache._key_to_path(key) / "meta.json"
 

tests/test_api/test_versions.py

@@ -2,18 +2,13 @@
 import pytest
 from openml.testing import TestAPIBase
 from openml._api import ResourceV1API, ResourceV2API, FallbackProxy
-from openml.enums import ResourceType
+from openml.enums import ResourceType, APIVersion
 from openml.exceptions import OpenMLNotSupportedError
 
 
-class TestResourceV1API(TestAPIBase):
-    def setUp(self):
-        super().setUp()
-        self.resource = ResourceV1API(self.http_client)
-        self.resource.resource_type = ResourceType.TASK
-
-    @pytest.mark.uses_test_server()
-    def test_publish_and_delete(self):
+@pytest.mark.uses_test_server()
+class TestResourceAPIBase(TestAPIBase):
+    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>
@@ -22,30 +17,19 @@ def test_publish_and_delete(self):
         </oml:task_inputs>
         """
 
-        task_id = None
-        try:
-            # Publish the task
-            task_id = self.resource.publish(
-                "task",
-                files={"description": task_xml},
-            )
-
-            # Get the task to verify it exists
-            get_response = self.http_client.get(f"task/{task_id}")
-            self.assertEqual(get_response.status_code, 200)
-
-        finally:
-            # delete the task if it was created
-            if task_id is not None:
-                success = self.resource.delete(task_id)
-                self.assertTrue(success)
+        task_id = self.resource.publish(
+            "task",
+            files={"description": task_xml},
+        )
+        self.assertIsNotNone(task_id)
 
+        success = self.resource.delete(task_id)
+        self.assertTrue(success)
 
-    @pytest.mark.uses_test_server()
-    def test_tag_and_untag(self):
+    def _tag_and_untag(self):
         resource_id = 1
         unique_indicator = str(time()).replace(".", "")
-        tag = f"TestResourceV1API_test_tag_and_untag_{unique_indicator}"
+        tag = f"{self.__class__.__name__}_test_tag_and_untag_{unique_indicator}"
 
         tags = self.resource.tag(resource_id, tag)
         self.assertIn(tag, tags)
@@ -54,52 +38,51 @@ def test_tag_and_untag(self):
         self.assertNotIn(tag, tags)
 
 
-class TestResourceV2API(TestResourceV1API):
+class TestResourceV1API(TestResourceAPIBase):
     def setUp(self):
         super().setUp()
-
-        self.server = ""
-        self.base_url = ""
-        self.api_key = ""
-        self.http_client = self._get_http_client(
-            server=self.server,
-            base_url=self.base_url,
-            api_key=self.api_key,
-            retries=self.retries,
-            retry_policy=self.retry_policy,
-            cache=self.cache,
-        )
-
-        self.resource = ResourceV2API(self.http_client)
+        http_client = self.http_clients[APIVersion.V1]
+        self.resource = ResourceV1API(http_client)
         self.resource.resource_type = ResourceType.TASK
 
-    @pytest.mark.xfail(raises=OpenMLNotSupportedError)
     def test_publish_and_delete(self):
-        super().test_tag_and_untag()
-
+        self._publish_and_delete()
 
-    @pytest.mark.xfail(raises=OpenMLNotSupportedError)
     def test_tag_and_untag(self):
-        super().test_tag_and_untag()
+        self._tag_and_untag()
 
 
-class TestResourceFallbackAPI(TestResourceV1API):
+class TestResourceV2API(TestResourceAPIBase):
     def setUp(self):
         super().setUp()
+        http_client = self.http_clients[APIVersion.V2]
+        self.resource = ResourceV2API(http_client)
+        self.resource.resource_type = ResourceType.TASK
+
+    def test_publish_and_delete(self):
+        with pytest.raises(OpenMLNotSupportedError):
+            self._tag_and_untag()
+
+    def test_tag_and_untag(self):
+        with pytest.raises(OpenMLNotSupportedError):
+            self._tag_and_untag()
 
-        self.http_client_v2 = self._get_http_client(
-            server="",
-            base_url="",
-            api_key="",
-            retries=self.retries,
-            retry_policy=self.retry_policy,
-            cache=self.cache,
-        )
 
-        resource_v1 = ResourceV1API(self.http_client)
+class TestResourceFallbackAPI(TestResourceAPIBase):
+    def setUp(self):
+        super().setUp()
+        http_client_v1 = self.http_clients[APIVersion.V1]
+        resource_v1 = ResourceV1API(http_client_v1)
         resource_v1.resource_type = ResourceType.TASK
 
-        resource_v2 = ResourceV2API(self.http_client_v2)
+        http_client_v2 = self.http_clients[APIVersion.V2]
+        resource_v2 = ResourceV2API(http_client_v2)
         resource_v2.resource_type = ResourceType.TASK
 
         self.resource = FallbackProxy(resource_v2, resource_v1)
+
+    def test_publish_and_delete(self):
+        self._publish_and_delete()
+
+    def test_tag_and_untag(self):
+        self._tag_and_untag()