ENH: unit tests for 'get_node' API

Author: dmgav

src/save_and_restore_api/_api_async.py

@@ -11,6 +11,13 @@ async def close(self):
         await self._client.aclose()
         self._client = None
 
+    async def __aenter__(self):
+        self.open()
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.close()
+
     async def send_request(
         self, method, url, *, params=None, url_params=None, headers=None, data=None, timeout=None, auth=None
     ):

src/save_and_restore_api/_api_base.py

@@ -1,4 +1,5 @@
 # import getpass
+import json
 import pprint
 from collections.abc import Mapping
 
@@ -42,17 +43,14 @@ class _SaveRestoreAPI_Base:
     HTTPClientError = HTTPClientError
     HTTPServerError = HTTPServerError
 
+    ROOT_NODE_UID = "44bef5de-e8e6-4014-af37-b8f6c8a939a2"
+
     def __init__(self, *, base_url, timeout, request_fail_exceptions=True):
         self._base_url = base_url
         self._timeout = timeout
         self._client = None
-        self._root_node_uid = "44bef5de-e8e6-4014-af37-b8f6c8a939a2"
         self._auth = None
 
-    @property
-    def ROOT_NODE_UID(self):
-        return self._root_node_uid
-
     @staticmethod
     def gen_auth(username, password):
         return httpx.BasicAuth(username=username, password=password)
@@ -109,11 +107,13 @@ def _process_comm_exception(self, *, method, params, client_response):
             common_params = {"request": exc.request, "response": exc.response}
             if client_response and (client_response.status_code < 500):
                 # Include more detail that httpx does by default.
-                message = (
-                    f"{exc.response.status_code}: "
-                    f"{exc.response.json()['detail'] if client_response.content else ''} "
-                    f"{exc.request.url}"
-                )
+                response_text = ""
+                if client_response.content:
+                    try:
+                        response_text = exc.response.json()["detail"]
+                    except json.JSONDecodeError:
+                        response_text = exc.response.text
+                message = f"{exc.response.status_code}: {response_text} {exc.request.url}"
                 raise self.HTTPClientError(message, **common_params) from exc
             else:
                 raise self.HTTPServerError(exc, **common_params) from exc

src/save_and_restore_api/_api_threads.py

@@ -11,6 +11,13 @@ def close(self):
         self._client.close()
         self._client = None
 
+    def __enter__(self):
+        self.open()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
     def send_request(
         self, method, url, *, params=None, url_params=None, headers=None, data=None, timeout=None, auth=None
     ):

tests/test_package.py

@@ -18,63 +18,127 @@
 base_url = "http://localhost:8080/save-restore"
 
 
-def test_version():
+def test_version_01():
+    """
+    Test that the versioning works correctly.
+    """
     assert importlib.metadata.version("save_and_restore_api") == save_and_restore_api.__version__
 
 
+# # fmt: off
+# @pytest.mark.parametrize("library", ["THREADS", "ASYNC"])
+# # fmt: on
+# def test_api_call_01(library):
+#     """
+#     Test generic API call
+#     """
+#     username, password = user_username, user_password
+
+#     if not _is_async(library):
+#         SR = SaveRestoreAPI_Threads(base_url=base_url, timeout=2)
+#         SR.set_auth(username=user_username, password=user_password)
+#         SR.open()
+#         response = SR.login(username=username, password=password)
+#         assert response["userName"] == username
+#         SR.close()
+#         SR.open()
+#         response = SR.login(username=username, password=password)
+#         assert response["userName"] == username
+#         SR.close()
+#     else:
+#         async def testing():
+#             SR = SaveRestoreAPI_Async(base_url=base_url, timeout=2)
+#             SR.set_auth(username=user_username, password=user_password)
+#             SR.open()
+#             response = await SR.login(username=username, password=password)
+#             assert response["userName"] == username
+#             await SR.close()
+#             SR.open()
+#             response = await SR.login(username=username, password=password)
+#             assert response["userName"] == username
+#             await SR.close()
+
+#         asyncio.run(testing())
+
+
 # fmt: off
 @pytest.mark.parametrize("library", ["THREADS", "ASYNC"])
 @pytest.mark.parametrize("username, password, roles, code", [
     (admin_username, admin_password,  ["ROLE_SAR-ADMIN"], 200),
     (user_username, user_password,  ["ROLE_SAR-USER"], 200),
     (read_username, read_password,  [], 200),
-    (user_username, read_password,  [], 401),
+    (user_username, read_password,  [], 401),  # Incorrect password
+    (user_username + "_a", user_password,  [], 401),  # Incorrect login
 ])
 # fmt: on
 def test_login_01(username, password, roles, library, code):
+    """
+    Tests for the 'login' API.
+    """
     if not _is_async(library):
-        SR = SaveRestoreAPI_Threads(base_url=base_url, timeout=2)
-        SR.set_auth(username=user_username, password=user_password)
-        SR.open()
-        if code == 200:
-            response = SR.login(username=username, password=password)
-            assert response["userName"] == username
-            assert response["roles"] == roles
-        else:
-            with pytest.raises(SR.HTTPClientError, match=f"{code}"):
-                SR.login(username=username, password=password)
-        SR.close()
-    else:
-        async def testing():
-            SR = SaveRestoreAPI_Async(base_url=base_url, timeout=2)
-            SR.set_auth(username=user_username, password=user_password)
+        with SaveRestoreAPI_Threads(base_url=base_url, timeout=2) as SR:
             SR.open()
             if code == 200:
-                response = await SR.login(username=username, password=password)
+                response = SR.login(username=username, password=password)
                 assert response["userName"] == username
                 assert response["roles"] == roles
             else:
                 with pytest.raises(SR.HTTPClientError, match=f"{code}"):
-                    await SR.login(username=username, password=password)
-            await SR.close()
+                    SR.login(username=username, password=password)
+    else:
+        async def testing():
+            async with SaveRestoreAPI_Async(base_url=base_url, timeout=2) as SR:
+                SR.open()
+                if code == 200:
+                    response = await SR.login(username=username, password=password)
+                    assert response["userName"] == username
+                    assert response["roles"] == roles
+                else:
+                    with pytest.raises(SR.HTTPClientError, match=f"{code}"):
+                        await SR.login(username=username, password=password)
 
         asyncio.run(testing())
 
 
+# fmt: off
+@pytest.mark.parametrize("library", ["THREADS", "ASYNC"])
+@pytest.mark.parametrize("node_uid, code", [
+    (SaveRestoreAPI_Threads.ROOT_NODE_UID, 200),
+    ("abc", 404),
+])
+# fmt: on
+def test_get_node_01(node_uid, library, code):
+    """
+    Tests for the 'login' API.
+    """
+    if not _is_async(library):
+        with SaveRestoreAPI_Threads(base_url=base_url, timeout=2) as SR:
+            SR.open()
+            if code == 200:
+                response = SR.get_node(node_uid)
+                assert response["uniqueId"] == node_uid
+            else:
+                with pytest.raises(SR.HTTPClientError, match=f"{code}"):
+                    SR.get_node(node_uid)
+    else:
+        async def testing():
+            async with SaveRestoreAPI_Async(base_url=base_url, timeout=2) as SR:
+                SR.open()
+                if code == 200:
+                    response = await SR.get_node(node_uid)
+                    assert response["uniqueId"] == node_uid
+                else:
+                    with pytest.raises(SR.HTTPClientError, match=f"{code}"):
+                        await SR.get_node(node_uid)
+
+        asyncio.run(testing())
+
+
+
 def test_comm():
     SR = SaveRestoreAPI_Threads(base_url=base_url, timeout=2)
     SR.set_auth(username=user_username, password=user_password)
     SR.open()
     SR.login(username="user", password="userPass")
     SR.get_node(SR.ROOT_NODE_UID)
     SR.close()
-
-
-@pytest.mark.asyncio
-async def test_comm_async():
-    SR = SaveRestoreAPI_Async(base_url=base_url, timeout=2)
-    SR.set_auth(username="user", password="userPass")
-    SR.open()
-    await SR.login(username="user", password="userPass")
-    await SR.get_node(SR.ROOT_NODE_UID)
-    await SR.close()