Add tests for PDF redaction features

datalogics-kam · datalogics-kam · commit 45fc7607c5f9 · 2025-11-06T10:45:10.000-06:00
- Introduced live tests for `preview_redactions` and `apply_redactions`
  to validate redaction workflows.
- Added unit tests for `PdfRedactionPreviewPayload` and
  `PdfRedactionApplyPayload` models, ensuring accurate payload
  validation.
- Verified handling of invalid inputs, including incorrect redaction
  instructions and color values.
- Updated test fixtures and utilities for live and isolated testing
  scenarios.

Assisted-by: Codex
diff --git a/tests/live/test_live_pdf_redactions.py b/tests/live/test_live_pdf_redactions.py
@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from typing import get_args
+
+import pytest
+
+from pdfrest import PdfRestApiError, PdfRestClient
+from pdfrest.models import PdfRestFile
+from pdfrest.types import PdfRedactionInstruction, PdfRedactionPreset
+
+from ..resources import get_test_resource_path
+
+
+@pytest.fixture(scope="module")
+def uploaded_pdf_for_redaction(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> PdfRestFile:
+    resource = get_test_resource_path("redactable-text.pdf")
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        return client.files.create_from_paths([resource])[0]
+
+
+@pytest.mark.parametrize(
+    "instruction",
+    [
+        pytest.param(
+            {
+                "type": "literal",
+                "value": "The quick brown fox jumped over the lazy dog.",
+            },
+            id="literal",
+        ),
+        pytest.param({"type": "regex", "value": r"\b\d{3}-\d{2}-\d{4}\b"}, id="regex"),
+        *[
+            pytest.param({"type": "preset", "value": preset}, id=f"preset-{preset}")
+            for preset in get_args(PdfRedactionPreset)
+        ],
+    ],
+)
+def test_live_redaction_preview_and_apply_single(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_redaction: PdfRestFile,
+    instruction: PdfRedactionInstruction,
+) -> None:
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        preview = client.preview_redactions(
+            uploaded_pdf_for_redaction,
+            redactions=[instruction],
+            output="redaction-preview",
+        )
+
+        assert preview.output_files
+        preview_file = preview.output_files[0]
+        assert preview_file.name.endswith("redaction-preview.pdf")
+        assert preview_file.type == "application/pdf"
+
+        applied = client.apply_redactions(
+            preview_file,
+            output="redaction-final",
+        )
+
+        assert applied.output_files
+        final_file = applied.output_files[0]
+        assert final_file.name.endswith("redaction-final.pdf")
+        assert final_file.type == "application/pdf"
+
+
+@pytest.mark.parametrize(
+    "instructions",
+    [
+        pytest.param(
+            [
+                {
+                    "type": "literal",
+                    "value": "The quick brown fox jumped over the lazy dog.",
+                },
+                {"type": "regex", "value": r"\b\d{3}-\d{2}-\d{4}\b"},
+            ],
+            id="literal-and-regex",
+        ),
+        pytest.param(
+            [
+                {"type": "preset", "value": "email"},
+                {"type": "preset", "value": "phone_number"},
+            ],
+            id="preset-email-and-phone",
+        ),
+        pytest.param(
+            [
+                {"type": "preset", "value": "credit_card"},
+                {"type": "preset", "value": "bank_routing_number"},
+                {"type": "preset", "value": "swift_bic_number"},
+            ],
+            id="multiple-presets",
+        ),
+    ],
+)
+def test_live_redaction_preview_and_apply_multiple(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_redaction: PdfRestFile,
+    instructions: list[PdfRedactionInstruction],
+) -> None:
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        preview = client.preview_redactions(
+            uploaded_pdf_for_redaction,
+            redactions=instructions,
+            output="redaction-preview-multi",
+        )
+
+        assert preview.output_files
+        preview_file = preview.output_files[0]
+        assert preview_file.name.endswith("redaction-preview-multi.pdf")
+        assert preview_file.type == "application/pdf"
+
+        applied = client.apply_redactions(
+            preview_file,
+            output="redaction-final-multi",
+        )
+
+        assert applied.output_files
+        final_file = applied.output_files[0]
+        assert final_file.name.endswith("redaction-final-multi.pdf")
+        assert final_file.type == "application/pdf"
+
+
+@pytest.mark.parametrize(
+    "extra_body",
+    [
+        pytest.param({"redactions": "invalid"}, id="invalid-redactions"),
+        pytest.param({"rgb_color": "-1,-1,-1"}, id="invalid-rgb"),
+    ],
+)
+def test_live_redactions_invalid_payloads(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_redaction: PdfRestFile,
+    extra_body: dict[str, object],
+) -> None:
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        if "redactions" in extra_body:
+            with pytest.raises(PdfRestApiError):
+                client.preview_redactions(
+                    uploaded_pdf_for_redaction,
+                    redactions=[{"type": "literal", "value": "placeholder"}],
+                    extra_body=extra_body,
+                )
+        else:
+            preview = client.preview_redactions(
+                uploaded_pdf_for_redaction,
+                redactions=[{"type": "literal", "value": "placeholder"}],
+            )
+            preview_file = preview.output_files[0]
+            with pytest.raises(PdfRestApiError):
+                client.apply_redactions(preview_file, extra_body=extra_body)
diff --git a/tests/resources/redactable-text.pdf b/tests/resources/redactable-text.pdf
diff --git a/tests/test_pdf_redaction_apply.py b/tests/test_pdf_redaction_apply.py
@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from pdfrest import PdfRestClient
+from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID
+from pdfrest.models._internal import PdfRedactionApplyPayload
+from pdfrest.types import PdfRGBColor
+
+from .graphics_test_helpers import VALID_API_KEY, build_file_info_payload, make_pdf_file
+
+
+@pytest.mark.parametrize(
+    "rgb_color",
+    [
+        pytest.param((255, 255, 255), id="tuple"),
+        pytest.param([10, 20, 30], id="list"),
+        pytest.param(None, id="none"),
+    ],
+)
+def test_apply_redactions_success(
+    monkeypatch: pytest.MonkeyPatch,
+    rgb_color: PdfRGBColor | list[int] | None,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    output_id = str(PdfRestFileID.generate())
+
+    payload_data: dict[str, object] = {"files": [input_file]}
+    if rgb_color is not None:
+        payload_data["rgb_color"] = rgb_color
+    payload_data["output"] = "final-output"
+
+    payload_model_dump = PdfRedactionApplyPayload.model_validate(
+        payload_data
+    ).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-with-redacted-text-applied"
+        ):
+            body = json.loads(request.content.decode("utf-8"))
+            assert body == payload_model_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}":
+            return httpx.Response(
+                200,
+                json=build_file_info_payload(
+                    output_id, "final-output.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.apply_redactions(
+            input_file,
+            rgb_color=rgb_color,
+            output="final-output",
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert response.output_files[0].name == "final-output.pdf"
+    assert response.output_files[0].type == "application/pdf"
+
+
+def test_apply_redactions_invalid_color(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    transport = httpx.MockTransport(lambda request: (_ for _ in ()).throw(RuntimeError))
+
+    with PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client:
+        with pytest.raises(ValidationError, match="Field required"):
+            client.apply_redactions(input_file, rgb_color=[255, 255])
+
+        with pytest.raises(ValidationError, match="greater than or equal to 0"):
+            client.apply_redactions(input_file, rgb_color=[-1, 0, 0])
diff --git a/tests/test_pdf_redaction_preview.py b/tests/test_pdf_redaction_preview.py
@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from pdfrest import PdfRestClient
+from pdfrest.models import PdfRestFileBasedResponse, PdfRestFileID
+from pdfrest.models._internal import PdfRedactionPreviewPayload
+from pdfrest.types import PdfRedactionInstruction
+
+from .graphics_test_helpers import VALID_API_KEY, build_file_info_payload, make_pdf_file
+
+
+@pytest.mark.parametrize(
+    "redactions",
+    [
+        pytest.param(
+            [
+                {"type": "literal", "value": "Sensitive"},
+                {"type": "preset", "value": "email"},
+            ],
+            id="list",
+        ),
+        pytest.param({"type": "regex", "value": "\\d{3}-\\d{2}-\\d{4}"}, id="single"),
+    ],
+)
+def test_preview_redactions_success(
+    monkeypatch: pytest.MonkeyPatch,
+    redactions: PdfRedactionInstruction | list[PdfRedactionInstruction],
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    output_id = str(PdfRestFileID.generate())
+    payload_model_dump = PdfRedactionPreviewPayload.model_validate(
+        {
+            "files": [input_file],
+            "redactions": redactions,
+            "output": "preview-output",
+        }
+    ).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-with-redacted-text-preview"
+        ):
+            body = json.loads(request.content.decode("utf-8"))
+            assert body == payload_model_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}":
+            return httpx.Response(
+                200,
+                json=build_file_info_payload(
+                    output_id, "preview-output.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.preview_redactions(
+            input_file,
+            redactions=redactions,
+            output="preview-output",
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert str(response.input_id) == str(input_file.id)
+    assert response.output_files[0].name == "preview-output.pdf"
+    assert response.output_files[0].type == "application/pdf"
+    assert response.warning is None
+
+
+def test_preview_redactions_invalid_preset(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    transport = httpx.MockTransport(lambda request: (_ for _ in ()).throw(RuntimeError))
+
+    with (
+        PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client,
+        pytest.raises(ValidationError, match="Input should be 'email'"),
+    ):
+        client.preview_redactions(
+            input_file,
+            redactions=[{"type": "preset", "value": "unknown"}],
+        )
+
+
+def test_preview_redactions_reject_json_string(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    transport = httpx.MockTransport(lambda request: (_ for _ in ()).throw(RuntimeError))
+
+    with (
+        PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client,
+        pytest.raises(ValidationError, match="valid dictionary"),
+    ):
+        client.preview_redactions(
+            input_file,
+            redactions=json.dumps([{"type": "literal", "value": "secret"}]),  # type: ignore[arg-type]
+        )
+
+
+def test_preview_redactions_requires_instruction(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("PDFREST_API_KEY", raising=False)
+    input_file = make_pdf_file(PdfRestFileID.generate(1))
+    transport = httpx.MockTransport(lambda request: (_ for _ in ()).throw(RuntimeError))
+
+    with (
+        PdfRestClient(api_key=VALID_API_KEY, transport=transport) as client,
+        pytest.raises(ValidationError, match="at least 1 item"),
+    ):
+        client.preview_redactions(input_file, redactions=[])
