tests: Add request customization tests for PDF/X, flatten, Word

- Added parameterized tests for `test_convert_to_pdfx_success` and
  `test_async_convert_to_pdfx_success` to validate multiple output types.
- Introduced sync and async tests to verify request customization for
  PDF to PDF/X, Word, and flattening PDF forms.
- Ensured validation logic for accepted input/output types and custom
  metadata integrations in payload and headers.

Assisted-by: Codex

Author: datalogics-kam

tests/test_convert_to_pdfx.py

@@ -19,12 +19,21 @@
 )
 
 
-def test_convert_to_pdfx_success(monkeypatch: pytest.MonkeyPatch) -> None:
+@pytest.mark.parametrize(
+    "output_type",
+    [
+        pytest.param("PDF/X-1a", id="pdfx-1a"),
+        pytest.param("PDF/X-3", id="pdfx-3"),
+        pytest.param("PDF/X-4", id="pdfx-4"),
+        pytest.param("PDF/X-6", id="pdfx-6"),
+    ],
+)
+def test_convert_to_pdfx_success(
+    monkeypatch: pytest.MonkeyPatch, output_type: PdfXType
+) -> None:
     monkeypatch.delenv("PDFREST_API_KEY", raising=False)
     input_file = make_pdf_file(PdfRestFileID.generate(1))
     output_id = str(PdfRestFileID.generate())
-    output_type: PdfXType = "PDF/X-4"
-
     payload_dump = PdfToPdfxPayload.model_validate(
         {"files": [input_file], "output_type": output_type, "output": "print-ready"}
     ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True)
@@ -72,12 +81,21 @@ def handler(request: httpx.Request) -> httpx.Response:
 
 
 @pytest.mark.asyncio
-async def test_async_convert_to_pdfx_success(monkeypatch: pytest.MonkeyPatch) -> None:
+@pytest.mark.parametrize(
+    "output_type",
+    [
+        pytest.param("PDF/X-1a", id="async-pdfx-1a"),
+        pytest.param("PDF/X-3", id="async-pdfx-3"),
+        pytest.param("PDF/X-4", id="async-pdfx-4"),
+        pytest.param("PDF/X-6", id="async-pdfx-6"),
+    ],
+)
+async def test_async_convert_to_pdfx_success(
+    monkeypatch: pytest.MonkeyPatch, output_type: PdfXType
+) -> None:
     monkeypatch.delenv("PDFREST_API_KEY", raising=False)
     input_file = make_pdf_file(PdfRestFileID.generate(2))
     output_id = str(PdfRestFileID.generate())
-    output_type: PdfXType = "PDF/X-1a"
-
     payload_dump = PdfToPdfxPayload.model_validate(
         {"files": [input_file], "output_type": output_type}
     ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True)
@@ -120,6 +138,123 @@ def handler(request: httpx.Request) -> httpx.Response:
     assert str(response.input_id) == str(input_file.id)
 
 
+def test_convert_to_pdfx_request_customization(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    output_id = str(PdfRestFileID.generate())
+    captured_timeout: dict[str, float | dict[str, float] | None] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.method == "POST" and request.url.path == "/pdfx":
+            assert request.url.params["trace"] == "true"
+            assert request.headers["X-Debug"] == "sync"
+            captured_timeout["value"] = request.extensions.get("timeout")
+            payload = json.loads(request.content.decode("utf-8"))
+            assert payload["output_type"] == "PDF/X-3"
+            assert payload["debug"] == "yes"
+            assert payload["id"] == str(input_file.id)
+            assert payload["output"] == "custom"
+            return httpx.Response(
+                200,
+                json={"inputId": [input_file.id], "outputId": [output_id]},
+            )
+        if request.method == "GET" and request.url.path == f"/resource/{output_id}":
+            assert request.url.params["format"] == "info"
+            assert request.url.params["trace"] == "true"
+            assert request.headers["X-Debug"] == "sync"
+            return httpx.Response(
+                200,
+                json=build_file_info_payload(
+                    output_id, "custom.pdf", "application/pdf"
+                ),
+            )
+        msg = f"Unexpected request {request.method} {request.url}"
+        raise AssertionError(msg)
+
+    transport = httpx.MockTransport(handler)
+    with PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client:
+        response = client.convert_to_pdfx(
+            input_file,
+            output_type="PDF/X-3",
+            output="custom",
+            extra_query={"trace": "true"},
+            extra_headers={"X-Debug": "sync"},
+            extra_body={"debug": "yes"},
+            timeout=0.33,
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert response.output_file.name == "custom.pdf"
+    timeout_value = captured_timeout["value"]
+    assert timeout_value is not None
+    if isinstance(timeout_value, dict):
+        assert all(
+            component == pytest.approx(0.33) for component in timeout_value.values()
+        )
+    else:
+        assert timeout_value == pytest.approx(0.33)
+
+
+@pytest.mark.asyncio
+async def test_async_convert_to_pdfx_request_customization(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(2))
+    output_id = str(PdfRestFileID.generate())
+    captured_timeout: dict[str, float | dict[str, float] | None] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.method == "POST" and request.url.path == "/pdfx":
+            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["output_type"] == "PDF/X-6"
+            assert payload["id"] == str(input_file.id)
+            assert payload["extra"] == {"note": "async"}
+            return httpx.Response(
+                200,
+                json={"inputId": [input_file.id], "outputId": [output_id]},
+            )
+        if request.method == "GET" and request.url.path == f"/resource/{output_id}":
+            assert request.url.params["format"] == "info"
+            assert request.url.params["trace"] == "async"
+            assert request.headers["X-Debug"] == "async"
+            return httpx.Response(
+                200,
+                json=build_file_info_payload(
+                    output_id, "async-custom.pdf", "application/pdf"
+                ),
+            )
+        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:
+        response = await client.convert_to_pdfx(
+            input_file,
+            output_type="PDF/X-6",
+            extra_query={"trace": "async"},
+            extra_headers={"X-Debug": "async"},
+            extra_body={"extra": {"note": "async"}},
+            timeout=0.72,
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert response.output_file.name == "async-custom.pdf"
+    timeout_value = captured_timeout["value"]
+    assert timeout_value is not None
+    if isinstance(timeout_value, dict):
+        assert all(
+            component == pytest.approx(0.72) for component in timeout_value.values()
+        )
+    else:
+        assert timeout_value == pytest.approx(0.72)
+
+
 def test_convert_to_pdfx_validation(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.delenv("PDFREST_API_KEY", raising=False)
     pdf_file = make_pdf_file(PdfRestFileID.generate(1))
@@ -152,3 +287,14 @@ def test_convert_to_pdfx_validation(monkeypatch: pytest.MonkeyPatch) -> None:
         pytest.raises(ValidationError, match="PDF/X-1a"),
     ):
         client.convert_to_pdfx(pdf_file, output_type="PDF/X-5")  # type: ignore[arg-type]
+
+    with (
+        PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client,
+        pytest.raises(
+            ValidationError, match="List should have at most 1 item after validation"
+        ),
+    ):
+        client.convert_to_pdfx(
+            [pdf_file, make_pdf_file(PdfRestFileID.generate())],
+            output_type="PDF/X-3",
+        )

tests/test_convert_to_word.py

@@ -71,6 +71,68 @@ def handler(request: httpx.Request) -> httpx.Response:
     assert str(response.input_id) == str(input_file.id)
 
 
+def test_convert_to_word_request_customization(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    output_id = str(PdfRestFileID.generate())
+    captured_timeout: dict[str, float | dict[str, float] | None] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.method == "POST" and request.url.path == "/word":
+            assert request.url.params["trace"] == "true"
+            assert request.headers["X-Debug"] == "sync"
+            captured_timeout["value"] = request.extensions.get("timeout")
+            payload = json.loads(request.content.decode("utf-8"))
+            assert payload["debug"] is True
+            assert payload["id"] == str(input_file.id)
+            assert payload["output"] == "custom"
+            return httpx.Response(
+                200,
+                json={
+                    "inputId": [input_file.id],
+                    "outputId": [output_id],
+                },
+            )
+        if request.method == "GET" and request.url.path == f"/resource/{output_id}":
+            assert request.url.params["format"] == "info"
+            assert request.url.params["trace"] == "true"
+            assert request.headers["X-Debug"] == "sync"
+            return httpx.Response(
+                200,
+                json=build_file_info_payload(
+                    output_id,
+                    "custom.docx",
+                    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                ),
+            )
+        msg = f"Unexpected request {request.method} {request.url}"
+        raise AssertionError(msg)
+
+    transport = httpx.MockTransport(handler)
+    with PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client:
+        response = client.convert_to_word(
+            input_file,
+            output="custom",
+            extra_query={"trace": "true"},
+            extra_headers={"X-Debug": "sync"},
+            extra_body={"debug": True},
+            timeout=0.4,
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert response.output_file.name == "custom.docx"
+    timeout_value = captured_timeout["value"]
+    assert timeout_value is not None
+    if isinstance(timeout_value, dict):
+        assert all(
+            component == pytest.approx(0.4) for component in timeout_value.values()
+        )
+    else:
+        assert timeout_value == pytest.approx(0.4)
+
+
 @pytest.mark.asyncio
 async def test_async_convert_to_word_success(
     monkeypatch: pytest.MonkeyPatch,
@@ -125,6 +187,67 @@ def handler(request: httpx.Request) -> httpx.Response:
     assert str(response.input_id) == str(input_file.id)
 
 
+@pytest.mark.asyncio
+async def test_async_convert_to_word_request_customization(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(2))
+    output_id = str(PdfRestFileID.generate())
+    captured_timeout: dict[str, float | dict[str, float] | None] = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        if request.method == "POST" and request.url.path == "/word":
+            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["debug"] == "yes"
+            assert payload["id"] == str(input_file.id)
+            return httpx.Response(
+                200,
+                json={
+                    "inputId": [input_file.id],
+                    "outputId": [output_id],
+                },
+            )
+        if request.method == "GET" and request.url.path == f"/resource/{output_id}":
+            assert request.url.params["format"] == "info"
+            assert request.url.params["trace"] == "async"
+            assert request.headers["X-Debug"] == "async"
+            return httpx.Response(
+                200,
+                json=build_file_info_payload(
+                    output_id,
+                    "async-custom.docx",
+                    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                ),
+            )
+        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:
+        response = await client.convert_to_word(
+            input_file,
+            extra_query={"trace": "async"},
+            extra_headers={"X-Debug": "async"},
+            extra_body={"debug": "yes"},
+            timeout=0.55,
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert response.output_file.name == "async-custom.docx"
+    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)
+
+
 def test_convert_to_word_validation(monkeypatch: pytest.MonkeyPatch) -> None:
     monkeypatch.delenv("PDFREST_API_KEY", raising=False)
     pdf_file = make_pdf_file(PdfRestFileID.generate(1))