This is a sample HTML page used for live convert-to-pdf testing.
+ + diff --git a/tests/resources/test.eml b/tests/resources/test.eml new file mode 100644 index 00000000..35652b1e --- /dev/null +++ b/tests/resources/test.eml @@ -0,0 +1,15 @@ +From: sender@example.com +To: recipient@example.com +Subject: Test Email +Date: Fri, 7 Jun 2024 12:00:00 +0000 +Message-ID: <1234567890@example.com> +MIME-Version: 1.0 +Content-Type: text/plain; charset="UTF-8" +Content-Transfer-Encoding: 7bit + +Hello, + +This is a simple test email message sent as a sample .eml file. + +Best regards, +Sender diff --git a/tests/test_convert_email_to_pdf.py b/tests/test_convert_email_to_pdf.py new file mode 100644 index 00000000..754a2f45 --- /dev/null +++ b/tests/test_convert_email_to_pdf.py @@ -0,0 +1,276 @@ +from __future__ import annotations + +import json + +import httpx +import pytest +from pydantic import ValidationError + +from pdfrest import AsyncPdfRestClient, PdfRestClient +from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID +from pdfrest.models._internal import ConvertEmailToPdfPayload + +from .convert_to_pdf_test_helpers import make_source_file +from .graphics_test_helpers import ASYNC_API_KEY, VALID_API_KEY, build_file_info_payload + + +def test_convert_email_to_pdf_success(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "message/rfc822", + "example.eml", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertEmailToPdfPayload.model_validate( + { + "files": [input_file], + "output": "converted", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + assert request.url.params["format"] == "info" + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "converted.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_email_to_pdf( + input_file, + output="converted", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "converted.pdf" + assert response.output_file.type == "application/pdf" + assert response.warning is None + assert str(response.input_id) == str(input_file.id) + + +def test_convert_email_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "message/rfc822", + "message.eml", + ) + 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 == "/pdf": + 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["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_email_to_pdf( + input_file, + output="custom", + extra_query={"trace": "true"}, + extra_headers={"X-Debug": "sync"}, + extra_body={"debug": True}, + timeout=0.5, + ) + + 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.5) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.5) + + +def test_convert_email_to_pdf_validation_errors() -> None: + email_file = make_source_file( + str(PdfRestFileID.generate(1)), + "message/rfc822", + "message.eml", + ) + image_file = make_source_file( + str(PdfRestFileID.generate(2)), + "image/jpeg", + "photo.jpg", + ) + + with pytest.raises(ValidationError, match="Must be an RFC822 email file"): + ConvertEmailToPdfPayload.model_validate({"files": [image_file]}) + + with pytest.raises( + ValidationError, + match="List should have at most 1 item after validation", + ): + ConvertEmailToPdfPayload.model_validate({"files": [email_file, image_file]}) + + +@pytest.mark.asyncio +async def test_async_convert_email_to_pdf_success( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "message/rfc822", + "async-message.eml", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertEmailToPdfPayload.model_validate( + { + "files": [input_file], + "output": "async-converted", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "async-converted.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_email_to_pdf( + input_file, + output="async-converted", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "async-converted.pdf" + assert response.output_file.type == "application/pdf" + assert str(response.input_id) == str(input_file.id) + + +@pytest.mark.asyncio +async def test_async_convert_email_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "message/rfc822", + "async-message.eml", + ) + 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 == "/pdf": + 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"] is True + assert payload["id"] == str(input_file.id) + assert payload["output"] == "async-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["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_email_to_pdf( + input_file, + output="async-custom", + extra_query={"trace": "async"}, + extra_headers={"X-Debug": "async"}, + extra_body={"debug": True}, + timeout=0.6, + ) + + 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.6) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.6) diff --git a/tests/test_convert_html_to_pdf.py b/tests/test_convert_html_to_pdf.py new file mode 100644 index 00000000..294ab2ad --- /dev/null +++ b/tests/test_convert_html_to_pdf.py @@ -0,0 +1,356 @@ +from __future__ import annotations + +import json + +import httpx +import pytest +from pydantic import ValidationError + +from pdfrest import AsyncPdfRestClient, PdfRestClient +from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID +from pdfrest.models._internal import ConvertHtmlToPdfPayload + +from .convert_to_pdf_test_helpers import make_source_file +from .graphics_test_helpers import ASYNC_API_KEY, VALID_API_KEY, build_file_info_payload + + +def test_convert_html_to_pdf_success(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "text/html", + "example.html", + ) + output_id = str(PdfRestFileID.generate()) + + payload_dump = ConvertHtmlToPdfPayload.model_validate( + { + "files": [input_file], + "output": "html-out", + "page_size": "A4", + "page_margin": "10mm", + "page_orientation": "landscape", + "web_layout": "tablet", + "compression": "lossy", + "downsample": 300, + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + "warning": "html warning", + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "html-out.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_html_to_pdf( + input_file, + output="html-out", + page_size="A4", + page_margin="10mm", + page_orientation="landscape", + web_layout="tablet", + compression="lossy", + ) + + assert response.output_file.name == "html-out.pdf" + assert response.output_file.type == "application/pdf" + assert response.warning == "html warning" + + +def test_convert_html_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "text/html", + "example.html", + ) + 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 == "/pdf": + 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["downsample"] == 300 + 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["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_html_to_pdf( + input_file, + output="custom", + downsample=300, + extra_query={"trace": "true"}, + extra_headers={"X-Debug": "sync"}, + extra_body={"debug": True}, + timeout=0.5, + ) + + 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.5) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.5) + + +def test_convert_html_to_pdf_validation_errors() -> None: + with pytest.raises(ValidationError, match="Must be an HTML file"): + ConvertHtmlToPdfPayload.model_validate( + { + "files": [ + make_source_file( + str(PdfRestFileID.generate(2)), + "application/msword", + "example.doc", + ) + ] + } + ) + + with pytest.raises(ValidationError, match="String should match pattern"): + ConvertHtmlToPdfPayload.model_validate( + { + "files": [ + make_source_file( + str(PdfRestFileID.generate()), + "text/html", + "example.html", + ) + ], + "page_margin": "bad-margin", + } + ) + + +@pytest.mark.parametrize( + "page_margin", + [ + pytest.param("8mm", id="whole-millimeters"), + pytest.param("2.5in", id="decimal-inches"), + pytest.param("10.25mm", id="long-decimal-millimeters"), + pytest.param("0in", id="zero-inches"), + ], +) +def test_convert_html_to_pdf_page_margin_accepts_documented_values( + page_margin: str, +) -> None: + payload = ConvertHtmlToPdfPayload.model_validate( + { + "files": [ + make_source_file( + str(PdfRestFileID.generate()), + "text/html", + "example.html", + ) + ], + "page_margin": page_margin, + } + ) + + assert payload.page_margin == page_margin + + +@pytest.mark.parametrize( + "page_margin", + [ + pytest.param("8", id="missing-unit"), + pytest.param("mm", id="missing-number"), + pytest.param("2.5 in", id="embedded-space"), + pytest.param("8MM", id="uppercase-unit"), + pytest.param(" 8mm", id="leading-space"), + pytest.param("8mm ", id="trailing-space"), + ], +) +def test_convert_html_to_pdf_page_margin_rejects_invalid_values( + page_margin: str, +) -> None: + with pytest.raises(ValidationError, match="String should match pattern"): + ConvertHtmlToPdfPayload.model_validate( + { + "files": [ + make_source_file( + str(PdfRestFileID.generate()), + "text/html", + "example.html", + ) + ], + "page_margin": page_margin, + } + ) + + +@pytest.mark.asyncio +async def test_async_convert_html_to_pdf_success( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "text/html", + "example.html", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertHtmlToPdfPayload.model_validate( + { + "files": [input_file], + "output": "async-converted", + "compression": "lossy", + "downsample": 300, + "page_size": "letter", + "page_margin": "1.0in", + "page_orientation": "portrait", + "web_layout": "desktop", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "async-converted.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_html_to_pdf( + input_file, + output="async-converted", + page_orientation="portrait", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "async-converted.pdf" + assert response.output_file.type == "application/pdf" + assert str(response.input_id) == str(input_file.id) + + +@pytest.mark.asyncio +async def test_async_convert_html_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "text/html", + "example.html", + ) + 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 == "/pdf": + 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"] is True + assert payload["id"] == str(input_file.id) + assert payload["output"] == "async-custom" + assert payload["downsample"] == 300 + 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["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_html_to_pdf( + input_file, + output="async-custom", + downsample=300, + extra_query={"trace": "async"}, + extra_headers={"X-Debug": "async"}, + extra_body={"debug": True}, + timeout=0.6, + ) + + 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.6) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.6) diff --git a/tests/test_convert_image_to_pdf.py b/tests/test_convert_image_to_pdf.py new file mode 100644 index 00000000..5c569a06 --- /dev/null +++ b/tests/test_convert_image_to_pdf.py @@ -0,0 +1,269 @@ +from __future__ import annotations + +import json + +import httpx +import pytest +from pydantic import ValidationError + +from pdfrest import AsyncPdfRestClient, PdfRestClient +from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID +from pdfrest.models._internal import ConvertImageToPdfPayload + +from .convert_to_pdf_test_helpers import make_source_file +from .graphics_test_helpers import ASYNC_API_KEY, VALID_API_KEY, build_file_info_payload + + +def test_convert_image_to_pdf_success(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "image/png", + "example.png", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertImageToPdfPayload.model_validate( + { + "files": [input_file], + "output": "converted", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + assert request.url.params["format"] == "info" + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "converted.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_image_to_pdf( + input_file, + output="converted", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "converted.pdf" + assert response.output_file.type == "application/pdf" + assert response.warning is None + assert str(response.input_id) == str(input_file.id) + + +def test_convert_image_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "image/jpeg", + "photo.jpg", + ) + 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 == "/pdf": + 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["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_image_to_pdf( + input_file, + output="custom", + extra_query={"trace": "true"}, + extra_headers={"X-Debug": "sync"}, + extra_body={"debug": True}, + timeout=0.5, + ) + + 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.5) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.5) + + +def test_convert_image_to_pdf_validation_errors() -> None: + with pytest.raises(ValidationError, match="Must be a supported image file type"): + ConvertImageToPdfPayload.model_validate( + { + "files": [ + make_source_file( + str(PdfRestFileID.generate(2)), + "text/html", + "example.html", + ) + ] + } + ) + + +@pytest.mark.asyncio +async def test_async_convert_image_to_pdf_success( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "image/tiff", + "scan.tiff", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertImageToPdfPayload.model_validate( + { + "files": [input_file], + "output": "async-converted", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "async-converted.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_image_to_pdf( + input_file, + output="async-converted", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "async-converted.pdf" + assert response.output_file.type == "application/pdf" + assert str(response.input_id) == str(input_file.id) + + +@pytest.mark.asyncio +async def test_async_convert_image_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "image/png", + "async.png", + ) + 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 == "/pdf": + 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"] is True + assert payload["id"] == str(input_file.id) + assert payload["output"] == "async-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["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_image_to_pdf( + input_file, + output="async-custom", + extra_query={"trace": "async"}, + extra_headers={"X-Debug": "async"}, + extra_body={"debug": True}, + timeout=0.6, + ) + + 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.6) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.6) diff --git a/tests/test_convert_office_to_pdf.py b/tests/test_convert_office_to_pdf.py new file mode 100644 index 00000000..7a77f29b --- /dev/null +++ b/tests/test_convert_office_to_pdf.py @@ -0,0 +1,306 @@ +from __future__ import annotations + +import json + +import httpx +import pytest +from pydantic import ValidationError + +from pdfrest import AsyncPdfRestClient, PdfRestClient +from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID +from pdfrest.models._internal import ConvertOfficeToPdfPayload + +from .convert_to_pdf_test_helpers import make_source_file +from .graphics_test_helpers import ASYNC_API_KEY, VALID_API_KEY, build_file_info_payload + + +def test_convert_office_to_pdf_word_success(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + "example.docx", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertOfficeToPdfPayload.model_validate( + { + "files": [input_file], + "output": "converted", + "compression": "lossless", + "downsample": 150, + "tagged_pdf": True, + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + assert request.url.params["format"] == "info" + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "converted.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_office_to_pdf( + input_file, + output="converted", + compression="lossless", + downsample=150, + tagged_pdf=True, + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "converted.pdf" + assert response.output_file.type == "application/pdf" + assert response.warning is None + assert str(response.input_id) == str(input_file.id) + + +def test_convert_office_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "application/vnd.ms-excel", + "example.xls", + ) + 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 == "/pdf": + 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["compression"] == "lossy" + assert payload["downsample"] == 600 + assert payload["locale"] == "US" + 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["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_office_to_pdf( + input_file, + output="custom", + compression="lossy", + downsample=600, + locale="US", + extra_query={"trace": "true"}, + extra_headers={"X-Debug": "sync"}, + extra_body={"debug": True}, + timeout=0.5, + ) + + 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.5) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.5) + + +def test_convert_office_to_pdf_validation_errors() -> None: + word_file = make_source_file( + str(PdfRestFileID.generate(1)), + "application/msword", + "example.doc", + ) + image_file = make_source_file( + str(PdfRestFileID.generate(2)), + "image/jpeg", + "photo.jpg", + ) + + with pytest.raises(ValidationError, match="Must be a Microsoft Office file"): + ConvertOfficeToPdfPayload.model_validate({"files": [image_file]}) + + with pytest.raises( + ValidationError, match="locale is only supported for Excel inputs" + ): + ConvertOfficeToPdfPayload.model_validate( + {"files": [word_file], "locale": "Germany"} + ) + + with pytest.raises( + ValidationError, + match="List should have at most 1 item after validation", + ): + ConvertOfficeToPdfPayload.model_validate({"files": [word_file, image_file]}) + + +@pytest.mark.asyncio +async def test_async_convert_office_to_pdf_success( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "application/vnd.ms-excel", + "sheet.xls", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertOfficeToPdfPayload.model_validate( + { + "files": [input_file], + "output": "async-converted", + "compression": "lossy", + "downsample": 300, + "tagged_pdf": False, + "locale": "US", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "async-converted.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_office_to_pdf( + input_file, + output="async-converted", + locale="US", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "async-converted.pdf" + assert response.output_file.type == "application/pdf" + assert str(response.input_id) == str(input_file.id) + + +@pytest.mark.asyncio +async def test_async_convert_office_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "application/vnd.ms-excel", + "sheet.xls", + ) + 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 == "/pdf": + 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"] is True + assert payload["compression"] == "lossy" + assert payload["downsample"] == 600 + assert payload["locale"] == "US" + assert payload["id"] == str(input_file.id) + assert payload["output"] == "async-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["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_office_to_pdf( + input_file, + output="async-custom", + compression="lossy", + downsample=600, + locale="US", + extra_query={"trace": "async"}, + extra_headers={"X-Debug": "async"}, + extra_body={"debug": True}, + timeout=0.6, + ) + + 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.6) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.6) diff --git a/tests/test_convert_postscript_to_pdf.py b/tests/test_convert_postscript_to_pdf.py new file mode 100644 index 00000000..20ae98ac --- /dev/null +++ b/tests/test_convert_postscript_to_pdf.py @@ -0,0 +1,283 @@ +from __future__ import annotations + +import json + +import httpx +import pytest +from pydantic import ValidationError + +from pdfrest import AsyncPdfRestClient, PdfRestClient +from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID +from pdfrest.models._internal import ConvertPostscriptToPdfPayload + +from .convert_to_pdf_test_helpers import make_source_file +from .graphics_test_helpers import ASYNC_API_KEY, VALID_API_KEY, build_file_info_payload + + +def test_convert_postscript_to_pdf_success(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "application/postscript", + "example.ps", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertPostscriptToPdfPayload.model_validate( + { + "files": [input_file], + "output": "converted", + "compression": "lossless", + "downsample": 150, + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + assert request.url.params["format"] == "info" + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "converted.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_postscript_to_pdf( + input_file, + output="converted", + compression="lossless", + downsample=150, + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "converted.pdf" + assert response.output_file.type == "application/pdf" + assert response.warning is None + assert str(response.input_id) == str(input_file.id) + + +def test_convert_postscript_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(1)), + "application/eps", + "example.eps", + ) + 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 == "/pdf": + 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["compression"] == "lossy" + assert payload["downsample"] == 600 + 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["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_postscript_to_pdf( + input_file, + output="custom", + compression="lossy", + downsample=600, + extra_query={"trace": "true"}, + extra_headers={"X-Debug": "sync"}, + extra_body={"debug": True}, + timeout=0.5, + ) + + 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.5) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.5) + + +def test_convert_postscript_to_pdf_validation_errors() -> None: + with pytest.raises(ValidationError, match="Must be a PostScript or EPS file"): + ConvertPostscriptToPdfPayload.model_validate( + { + "files": [ + make_source_file( + str(PdfRestFileID.generate(2)), + "message/rfc822", + "message.eml", + ) + ] + } + ) + + +@pytest.mark.asyncio +async def test_async_convert_postscript_to_pdf_success( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "application/x-eps", + "graphic.eps", + ) + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertPostscriptToPdfPayload.model_validate( + { + "files": [input_file], + "output": "async-converted", + "compression": "lossless", + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + seen: dict[str, int] = {"post": 0, "get": 0} + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + seen["post"] += 1 + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [input_file.id], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + seen["get"] += 1 + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "async-converted.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_postscript_to_pdf( + input_file, + output="async-converted", + compression="lossless", + ) + + assert seen == {"post": 1, "get": 1} + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "async-converted.pdf" + assert response.output_file.type == "application/pdf" + assert str(response.input_id) == str(input_file.id) + + +@pytest.mark.asyncio +async def test_async_convert_postscript_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + input_file = make_source_file( + str(PdfRestFileID.generate(2)), + "application/postscript", + "graphic.ps", + ) + 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 == "/pdf": + 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"] is True + assert payload["compression"] == "lossy" + assert payload["downsample"] == 600 + assert payload["id"] == str(input_file.id) + assert payload["output"] == "async-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["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_postscript_to_pdf( + input_file, + output="async-custom", + compression="lossy", + downsample=600, + extra_query={"trace": "async"}, + extra_headers={"X-Debug": "async"}, + extra_body={"debug": True}, + timeout=0.6, + ) + + 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.6) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.6) diff --git a/tests/test_convert_url_to_pdf.py b/tests/test_convert_url_to_pdf.py new file mode 100644 index 00000000..7f78bdbd --- /dev/null +++ b/tests/test_convert_url_to_pdf.py @@ -0,0 +1,247 @@ +from __future__ import annotations + +import json + +import httpx +import pytest +from pydantic import ValidationError + +from pdfrest import AsyncPdfRestClient, PdfRestClient +from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID +from pdfrest.models._internal import ConvertUrlToPdfPayload + +from .graphics_test_helpers import ASYNC_API_KEY, VALID_API_KEY, build_file_info_payload + + +def test_convert_url_to_pdf_success(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + url = "https://example.com/page" + output_id = str(PdfRestFileID.generate()) + payload_dump = ConvertUrlToPdfPayload.model_validate( + { + "url": url, + "output": "url-out", + "compression": "lossy", + "page_size": "letter", + "page_margin": "2.5in", + "page_orientation": "portrait", + "web_layout": "desktop", + "downsample": 300, + } + ).model_dump(mode="json", by_alias=True, exclude_none=True, exclude_unset=True) + + def handler(request: httpx.Request) -> httpx.Response: + if request.method == "POST" and request.url.path == "/pdf": + payload = json.loads(request.content.decode("utf-8")) + assert payload == payload_dump + return httpx.Response( + 200, + json={ + "inputId": [PdfRestFileID.generate()], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "url-out.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_url_to_pdf( + url, + output="url-out", + page_size="letter", + page_margin="2.5in", + page_orientation="portrait", + web_layout="desktop", + downsample=300, + ) + + assert response.output_file.name == "url-out.pdf" + assert response.output_file.type == "application/pdf" + + +def test_convert_url_to_pdf_validation_errors() -> None: + with pytest.raises(ValidationError, match="Input should be a valid URL"): + ConvertUrlToPdfPayload.model_validate({"url": "not-a-url"}) + + with pytest.raises(ValidationError, match="at least 1 item"): + ConvertUrlToPdfPayload.model_validate({"url": []}) + + with pytest.raises(ValidationError, match="at most 1 item"): + ConvertUrlToPdfPayload.model_validate( + {"url": ["https://example.com/one", "https://example.com/two"]} + ) + + with pytest.raises(ValidationError, match="String should match pattern"): + ConvertUrlToPdfPayload.model_validate( + {"url": "https://example.com", "page_margin": "mm"} + ) + + +@pytest.mark.parametrize( + "page_margin", + [ + pytest.param("8mm", id="whole-millimeters"), + pytest.param("2.5in", id="decimal-inches"), + pytest.param("10.25mm", id="long-decimal-millimeters"), + pytest.param("0in", id="zero-inches"), + ], +) +def test_convert_url_to_pdf_page_margin_accepts_documented_values( + page_margin: str, +) -> None: + payload = ConvertUrlToPdfPayload.model_validate( + {"url": "https://example.com/page", "page_margin": page_margin} + ) + + assert payload.page_margin == page_margin + + +@pytest.mark.parametrize( + "page_margin", + [ + pytest.param("8", id="missing-unit"), + pytest.param("mm", id="missing-number"), + pytest.param("2.5 in", id="embedded-space"), + pytest.param("8MM", id="uppercase-unit"), + pytest.param(" 8mm", id="leading-space"), + pytest.param("8mm ", id="trailing-space"), + ], +) +def test_convert_url_to_pdf_page_margin_rejects_invalid_values( + page_margin: str, +) -> None: + with pytest.raises(ValidationError, match="String should match pattern"): + ConvertUrlToPdfPayload.model_validate( + {"url": "https://example.com/page", "page_margin": page_margin} + ) + + +def test_convert_url_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + url = "https://example.com/page" + 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 == "/pdf": + assert request.url.params["trace"] == "sync" + assert request.headers["X-Debug"] == "sync" + captured_timeout["value"] = request.extensions.get("timeout") + payload = json.loads(request.content.decode("utf-8")) + assert payload["url"] == url + assert payload["output"] == "sync-url" + assert payload["page_orientation"] == "portrait" + assert payload["debug"] == "yes" + return httpx.Response( + 200, + json={ + "inputId": [PdfRestFileID.generate()], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + assert request.url.params["trace"] == "sync" + assert request.headers["X-Debug"] == "sync" + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "sync-url.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_url_to_pdf( + url, + output="sync-url", + page_orientation="portrait", + extra_query={"trace": "sync"}, + extra_headers={"X-Debug": "sync"}, + extra_body={"debug": "yes"}, + timeout=0.5, + ) + + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "sync-url.pdf" + timeout_value = captured_timeout["value"] + assert timeout_value is not None + if isinstance(timeout_value, dict): + assert all( + component == pytest.approx(0.5) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.5) + + +@pytest.mark.asyncio +async def test_async_convert_url_to_pdf_request_customization( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.delenv("PDFREST_API_KEY", raising=False) + url = "https://example.com/page" + 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 == "/pdf": + 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["url"] == url + assert payload["output"] == "async-url" + assert payload["page_orientation"] == "portrait" + assert payload["debug"] == "yes" + return httpx.Response( + 200, + json={ + "inputId": [PdfRestFileID.generate()], + "outputId": [output_id], + }, + ) + if request.method == "GET" and request.url.path == f"/resource/{output_id}": + assert request.url.params["trace"] == "async" + assert request.headers["X-Debug"] == "async" + return httpx.Response( + 200, + json=build_file_info_payload( + output_id, "async-url.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_url_to_pdf( + url, + output="async-url", + page_orientation="portrait", + extra_query={"trace": "async"}, + extra_headers={"X-Debug": "async"}, + extra_body={"debug": "yes"}, + timeout=0.6, + ) + + assert isinstance(response, PdfRestFileBasedResponse) + assert response.output_file.name == "async-url.pdf" + timeout_value = captured_timeout["value"] + assert timeout_value is not None + if isinstance(timeout_value, dict): + assert all( + component == pytest.approx(0.6) for component in timeout_value.values() + ) + else: + assert timeout_value == pytest.approx(0.6)