feat: Use HEAD HTTP method to check if a document exists

Author: Darkheir

arango/collection.py

@@ -508,7 +508,7 @@ def has(
         handle, body, headers = self._prep_from_doc(document, rev, check_rev)
 
         request = Request(
-            method="get",
+            method="head",
             endpoint=f"/_api/document/{handle}",
             headers=headers,
             read=self.name,
@@ -519,9 +519,11 @@ def response_handler(resp: Response) -> bool:
                 return False
             if resp.status_code == 412:
                 raise DocumentRevisionError(resp, request)
+            if resp.status_code == 404:
+                return False
             if not resp.is_success:
                 raise DocumentInError(resp, request)
-            return bool(resp.body)
+            return True
 
         return self._execute(request, response_handler)
 

arango/executor.py

@@ -21,7 +21,7 @@
     TransactionInitError,
     TransactionStatusError,
 )
-from arango.job import AsyncJob, BatchJob
+from arango.job import AsyncJob, BatchJob, DummyAsyncJob
 from arango.request import Request
 from arango.response import Response
 from arango.typings import Fields, Json
@@ -99,6 +99,11 @@ def execute(
             False during initialization.
         :rtype: arango.job.AsyncJob | None
         """
+        if request.method == "head":
+            # As of now ArangoDB doesn't support non-blocking HEAD requests,
+            # instead we get the real response and wrap it into a fake async job
+            resp = self._conn.send_request(request)
+            return DummyAsyncJob(self._conn, resp, response_handler)
         if self._return_result:
             request.headers["x-arango-async"] = "store"
         else:

arango/job.py

@@ -204,3 +204,38 @@ def result(self) -> T:
             raise BatchJobResultError("result not available yet")
 
         return self._response_handler(self._response)
+
+
+class DummyAsyncJob(AsyncJob):
+    """Job for tracking and retrieving result of an async API execution.
+
+    :param connection: HTTP connection.
+    :param response: The response.
+    :type response: Response
+    :param response_handler: HTTP response handler.
+    :type response_handler: callable
+    """
+
+    __slots__ = ["_response", "_id", "_response_handler"]
+
+    def __init__(
+        self,
+        connection: Connection,
+        response: Response,
+        response_handler: Callable[[Response], T],
+    ) -> None:
+        self._response = response
+        job_id = uuid4().hex
+        super(DummyAsyncJob, self).__init__(connection, job_id, response_handler)
+
+    def status(self) -> str:
+        return "done"
+
+    def result(self) -> T:
+        return self._response_handler(self._response)
+
+    def cancel(self, ignore_missing: bool = False) -> bool:
+        return True
+
+    def clear(self, ignore_missing: bool = False) -> bool:
+        return True

tests/test_document.py

@@ -1390,7 +1390,7 @@ def test_document_has(col, bad_col, docs):
 
         with assert_raises(DocumentRevisionError) as err:
             col.has(doc_input, rev=bad_rev, check_rev=True)
-        assert err.value.error_code == 1200
+        assert err.value.error_code in  {412, 1200}
 
     # Test existing documents with bad revision
     for doc_input in [
@@ -1400,15 +1400,15 @@ def test_document_has(col, bad_col, docs):
     ]:
         with assert_raises(DocumentRevisionError) as err:
             col.has(doc_input)
-        assert err.value.error_code == 1200
+        assert err.value.error_code in  {412, 1200}
 
         with assert_raises(DocumentRevisionError) as err:
             col.has(doc_input, rev=bad_rev)
-        assert err.value.error_code == 1200
+        assert err.value.error_code in  {412, 1200}
 
         with assert_raises(DocumentRevisionError) as err:
             col.has(doc_input, rev=bad_rev, check_rev=True)
-        assert err.value.error_code == 1200
+        assert err.value.error_code in  {412, 1200}
 
         assert doc_input in col
         assert col.has(doc_input, rev=rev, check_rev=True) is True
@@ -1487,12 +1487,12 @@ def test_document_has(col, bad_col, docs):
     # Test get with bad database
     with assert_raises(DocumentInError) as err:
         bad_col.has(doc_key)
-    assert err.value.error_code in {11, 1228}
+    assert err.value.error_code in {11, 401}
 
     # Test contains with bad database
     with assert_raises(DocumentInError) as err:
         assert doc_key in bad_col
-    assert err.value.error_code in {11, 1228}
+    assert err.value.error_code in {11, 401}
 
 
 def test_document_get(col, bad_col, docs):