tests: Add async live delete tests and improve sync/async error handling

- Added async live delete tests under `test_live_delete.py`, covering
  success, invalid ID, and missing ID scenarios for `AsyncPdfRestClient`.
- Improved exception handling to use `pytest.RaisesGroup` for both sync
  and async delete error aggregation.
- Enhanced test customization to validate extra query parameters, headers,
  and timeout behavior during async operations.

Assisted-by: Codex

Author: datalogics-kam

tests/live/test_live_delete.py

@@ -5,7 +5,12 @@
 import pytest
 from pydantic import ValidationError
 
-from pdfrest import PdfRestClient, PdfRestDeleteError, PdfRestErrorGroup
+from pdfrest import (
+    AsyncPdfRestClient,
+    PdfRestClient,
+    PdfRestDeleteError,
+    PdfRestErrorGroup,
+)
 from pdfrest.models import PdfRestFileID
 
 from ..resources import get_test_resource_path
@@ -26,6 +31,22 @@ def test_live_delete_files_success(
     assert result is None
 
 
+@pytest.mark.asyncio
+async def test_live_async_delete_files_success(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> None:
+    resource = get_test_resource_path("report.pdf")
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        uploaded = (await client.files.create_from_paths([resource]))[0]
+        result = await client.files.delete(uploaded)
+
+    assert result is None
+
+
 def test_live_delete_files_invalid_id(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
@@ -40,6 +61,21 @@ def test_live_delete_files_invalid_id(
             client.files.delete(uploaded, extra_body={"ids": token_urlsafe(16)})
 
 
+@pytest.mark.asyncio
+async def test_live_async_delete_files_invalid_id(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> None:
+    resource = get_test_resource_path("report.pdf")
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        uploaded = (await client.files.create_from_paths([resource]))[0]
+        with pytest.raises(ValidationError):
+            await client.files.delete(uploaded, extra_body={"ids": token_urlsafe(16)})
+
+
 def test_live_delete_files_missing_id(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
@@ -67,3 +103,33 @@ def test_live_delete_files_missing_id(
             client.files.delete(
                 uploaded, extra_body={"ids": ",".join([bad_id_1, bad_id_2])}
             )
+
+
+@pytest.mark.asyncio
+async def test_live_async_delete_files_missing_id(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> None:
+    resource = get_test_resource_path("report.pdf")
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        bad_id_1 = PdfRestFileID.generate()
+        bad_id_2 = PdfRestFileID.generate()
+        uploaded = (await client.files.create_from_paths([resource]))[0]
+        with pytest.RaisesGroup(
+            pytest.RaisesExc(
+                PdfRestDeleteError,
+                match=f"Failed to delete file {bad_id_1}.*does not exist",
+            ),
+            pytest.RaisesExc(
+                PdfRestDeleteError,
+                match=f"Failed to delete file {bad_id_2}.*does not exist",
+            ),
+            match="Failed to delete one or more files.",
+            check=lambda eg: isinstance(eg, PdfRestErrorGroup),
+        ):
+            await client.files.delete(
+                uploaded, extra_body={"ids": ",".join([bad_id_1, bad_id_2])}
+            )

tests/test_delete_files.py

@@ -27,7 +27,10 @@ def test_delete_payload_serialization() -> None:
 
 
 def test_delete_payload_rejects_empty() -> None:
-    with pytest.raises(ValidationError):
+    with pytest.raises(
+        ValidationError,
+        match="List should have at least 1 item after validation",
+    ):
         DeletePayload.model_validate({"files": []})
 
 
@@ -133,16 +136,19 @@ def handler(request: httpx.Request) -> httpx.Response:
     transport = httpx.MockTransport(handler)
     with (
         PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client,
-        pytest.raises(PdfRestErrorGroup) as exc_info,
+        pytest.RaisesGroup(
+            pytest.RaisesExc(
+                PdfRestDeleteError,
+                match=(
+                    f"Failed to delete file {file_repr.id}.*File could not be deleted"
+                ),
+            ),
+            match="Failed to delete one or more files.",
+            check=lambda eg: isinstance(eg, PdfRestErrorGroup),
+        ),
     ):
         client.files.delete(file_repr)
 
-    assert len(exc_info.value.exceptions) == 1
-    inner = exc_info.value.exceptions[0]
-    assert isinstance(inner, PdfRestDeleteError)
-    assert inner.file_id == str(file_repr.id)
-    assert "File could not be deleted" in str(inner)
-
 
 def test_delete_files_aggregates_multiple_failures(
     monkeypatch: pytest.MonkeyPatch,
@@ -168,16 +174,17 @@ def handler(request: httpx.Request) -> httpx.Response:
     transport = httpx.MockTransport(handler)
     with (
         PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client,
-        pytest.raises(PdfRestErrorGroup) as exc_info,
+        pytest.RaisesGroup(
+            pytest.RaisesExc(
+                PdfRestDeleteError,
+                match=f"Failed to delete file {second.id}.*Permission denied",
+            ),
+            match="Failed to delete one or more files.",
+            check=lambda eg: isinstance(eg, PdfRestErrorGroup),
+        ),
     ):
         client.files.delete([first, second])
 
-    assert len(exc_info.value.exceptions) == 1
-    inner = exc_info.value.exceptions[0]
-    assert isinstance(inner, PdfRestDeleteError)
-    assert inner.file_id == str(second.id)
-    assert "Permission denied" in str(inner)
-
 
 @pytest.mark.asyncio
 async def test_async_delete_files_success(
@@ -218,6 +225,57 @@ def handler(request: httpx.Request) -> httpx.Response:
     assert result is None
 
 
+@pytest.mark.asyncio
+async def test_async_delete_files_request_customization(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    file_repr = make_pdf_file(PdfRestFileID.generate(2))
+    captured_timeout: dict[str, float | dict[str, float] | None] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.method == "POST" and request.url.path == "/delete":
+            assert request.url.params["trace"] == "async"
+            assert request.headers["X-Debug"] == "async"
+            captured_timeout["value"] = request.extensions.get("timeout")
+            payload = json.loads(request.content.decode("utf-8"))
+            assert payload["ids"] == str(file_repr.id)
+            assert payload["diagnostics"] == "enabled"
+            return httpx.Response(
+                200,
+                json={
+                    "deletionResponses": {
+                        str(file_repr.id): "Successfully Deleted",
+                    }
+                },
+            )
+        msg = f"Unexpected request {request.method} {request.url}"
+        raise AssertionError(msg)
+
+    transport = httpx.MockTransport(handler)
+    async with AsyncPdfRestClient(
+        api_key=ASYNC_API_KEY,
+        transport=transport,
+    ) as client:
+        result = await client.files.delete(
+            file_repr,
+            extra_query={"trace": "async"},
+            extra_headers={"X-Debug": "async"},
+            extra_body={"diagnostics": "enabled"},
+            timeout=0.55,
+        )
+
+    assert result is None
+    timeout_value = captured_timeout["value"]
+    assert timeout_value is not None
+    if isinstance(timeout_value, dict):
+        assert all(
+            component == pytest.approx(0.55) for component in timeout_value.values()
+        )
+    else:
+        assert timeout_value == pytest.approx(0.55)
+
+
 @pytest.mark.asyncio
 async def test_async_delete_files_raises_error_group(
     monkeypatch: pytest.MonkeyPatch,