Live flatten/linearize/rasterize: add async variants, missing sync tests

Assisted-by: Codex

Author: datalogics-cgreen

tests/live/test_live_flatten_annotations.py

@@ -57,22 +57,37 @@ def test_live_flatten_annotations_success(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("flatten-annotations", id="custom-output"),
+    ],
+)
 async def test_live_async_flatten_annotations_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_annotations: PdfRestFile,
+    output_name: str | None,
 ) -> None:
+    kwargs: dict[str, str] = {}
+    if output_name is not None:
+        kwargs["output"] = output_name
+
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
         response = await client.flatten_annotations(
-            uploaded_pdf_for_annotations, output="async"
+            uploaded_pdf_for_annotations, **kwargs
         )
 
     assert response.output_files
     output_file = response.output_file
-    assert output_file.name.startswith("async")
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".pdf")
     assert output_file.type == "application/pdf"
     assert output_file.size > 0
     assert response.warning is None

tests/live/test_live_flatten_pdf_forms.py

@@ -55,23 +55,38 @@ def test_live_flatten_pdf_forms(
 
 
 @pytest.mark.asyncio
-async def test_live_async_flatten_pdf_forms_success(
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("flattened-live", id="custom-output"),
+    ],
+)
+async def test_live_async_flatten_pdf_forms(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_with_forms: PdfRestFile,
+    output_name: str | None,
 ) -> None:
+    kwargs: dict[str, str] = {}
+    if output_name is not None:
+        kwargs["output"] = output_name
+
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
         response = await client.flatten_pdf_forms(
             uploaded_pdf_with_forms,
-            output="async-flattened",
+            **kwargs,
         )
 
     assert response.output_files
     output_file = response.output_file
-    assert output_file.name.startswith("async-flattened")
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".pdf")
     assert output_file.type == "application/pdf"
     assert str(response.input_id) == str(uploaded_pdf_with_forms.id)
 

tests/live/test_live_flatten_transparencies.py

@@ -60,22 +60,38 @@ def test_live_flatten_transparencies_success(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("output_name", "quality"),
+    [
+        pytest.param(None, "medium", id="default-output"),
+        pytest.param("flatten-transparency", "high", id="custom-output-high"),
+    ],
+)
 async def test_live_async_flatten_transparencies_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_transparencies: PdfRestFile,
+    output_name: str | None,
+    quality: str,
 ) -> None:
+    kwargs: dict[str, str] = {"quality": quality}
+    if output_name is not None:
+        kwargs["output"] = output_name
+
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
         response = await client.flatten_transparencies(
-            uploaded_pdf_for_transparencies, output="async", quality="low"
+            uploaded_pdf_for_transparencies, **kwargs
         )
 
     assert response.output_files
     output_file = response.output_file
-    assert output_file.name.startswith("async")
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".pdf")
     assert output_file.type == "application/pdf"
     assert output_file.size > 0
     assert response.warning is None

tests/live/test_live_linearize_pdf.py

@@ -57,23 +57,38 @@ def test_live_linearize_pdf(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("linearized-live", id="custom-output"),
+    ],
+)
 async def test_live_async_linearize_pdf(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_linearize: PdfRestFile,
+    output_name: str | None,
 ) -> None:
+    kwargs: dict[str, str] = {}
+    if output_name is not None:
+        kwargs["output"] = output_name
+
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
         response = await client.linearize_pdf(
             uploaded_pdf_for_linearize,
-            output="async-linearized",
+            **kwargs,
         )
 
     assert response.output_files
     output_file = response.output_file
-    assert output_file.name.startswith("async-linearized")
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".pdf")
     assert output_file.type == "application/pdf"
     assert output_file.size > 0
     assert response.warning is None

tests/live/test_live_pdf_info.py

@@ -145,6 +145,23 @@ def test_live_pdf_info_multiple_queries(
         _assert_expected_value(item, getattr(response, item))
 
 
+def test_live_pdf_info_all_queries(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf: PdfRestFile,
+) -> None:
+    with PdfRestClient(
+        api_key=pdfrest_api_key, base_url=pdfrest_live_base_url
+    ) as client:
+        response = client.query_pdf_info(uploaded_pdf, queries=ALLOWED_QUERIES)
+
+    assert isinstance(response, PdfRestInfoResponse)
+    assert str(response.input_id) == str(uploaded_pdf.id)
+    assert response.all_queries_processed is True
+    for query in ALLOWED_QUERIES:
+        _assert_expected_value(query, getattr(response, query))
+
+
 @pytest.mark.asyncio
 async def test_live_pdf_info_async_all_queries(
     pdfrest_api_key: str,

tests/live/test_live_pdf_redactions.py

@@ -136,32 +136,109 @@ def test_live_redaction_preview_and_apply_multiple(
 
 
 @pytest.mark.asyncio
-async def test_live_async_redaction_preview_and_apply(
+@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",
+        ),
+    ],
+)
+async def test_live_async_redaction_preview_and_apply_multiple(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_redaction: PdfRestFile,
+    instructions: list[PdfRedactionInstruction],
 ) -> None:
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
         preview = await client.preview_redactions(
             uploaded_pdf_for_redaction,
-            redactions=[{"type": "literal", "value": "quick brown fox"}],
-            output="async-redaction-preview",
+            redactions=instructions,
+            output="redaction-preview-multi",
         )
 
+        assert preview.output_files
         preview_file = preview.output_files[0]
         applied = await client.apply_redactions(
             preview_file,
-            output="async-redaction-final",
+            output="redaction-final-multi",
+        )
+
+    final_file = applied.output_files[0]
+    assert final_file.name.endswith("redaction-final-multi.pdf")
+    assert final_file.type == "application/pdf"
+
+
+@pytest.mark.asyncio
+@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)
+        ],
+    ],
+)
+async def test_live_async_redaction_preview_and_apply_single(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_redaction: PdfRestFile,
+    instruction: PdfRedactionInstruction,
+) -> None:
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        preview = await client.preview_redactions(
+            uploaded_pdf_for_redaction,
+            redactions=[instruction],
+            output="redaction-preview",
+        )
+
+        preview_file = preview.output_files[0]
+        applied = await client.apply_redactions(
+            preview_file,
+            output="redaction-final",
         )
 
     assert preview.output_files
-    assert preview_file.name.endswith("async-redaction-preview.pdf")
+    assert preview_file.name.endswith("redaction-preview.pdf")
     assert applied.output_files
     final_file = applied.output_files[0]
-    assert final_file.name.endswith("async-redaction-final.pdf")
+    assert final_file.name.endswith("redaction-final.pdf")
     assert final_file.type == "application/pdf"
 
 
@@ -206,18 +283,42 @@ def test_live_redactions_invalid_payloads(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "extra_body",
+    [
+        pytest.param({"redactions": "invalid"}, id="invalid-redactions"),
+        pytest.param({"rgb_color": "-1,-1,-1"}, id="invalid-rgb"),
+    ],
+)
 async def test_live_async_redactions_invalid_payloads(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_redaction: PdfRestFile,
+    extra_body: dict[str, object],
 ) -> None:
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
-        with pytest.raises(PdfRestApiError, match=r"(?i)rgb"):
-            await client.preview_redactions(
+        if "redactions" in extra_body:
+            with pytest.raises(
+                PdfRestApiError,
+                match=(
+                    r"The JSON data provided is not properly formatted\. Please check "
+                    r"your syntax and try again\."
+                ),
+            ):
+                await client.preview_redactions(
+                    uploaded_pdf_for_redaction,
+                    redactions=[{"type": "literal", "value": "placeholder"}],
+                    extra_body=extra_body,
+                )
+        else:
+            preview = await client.preview_redactions(
                 uploaded_pdf_for_redaction,
                 redactions=[{"type": "literal", "value": "placeholder"}],
-                extra_body={"rgb_color": "-1,-1,-1"},
+                extra_body=extra_body,
             )
+            preview_file = preview.output_files[0]
+            with pytest.raises(PdfRestApiError, match=r"(?i)rgb"):
+                await client.apply_redactions(preview_file, extra_body=extra_body)

tests/live/test_live_pdf_split_merge.py

@@ -280,7 +280,7 @@ def test_live_merge_pdfs_invalid_pages(
 
 
 @pytest.mark.asyncio
-async def test_live_async_merge_pdfs(
+async def test_live_async_merge_pdfs_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],

tests/live/test_live_rasterize_pdf.py

@@ -57,22 +57,35 @@ def test_live_rasterize_pdf_success(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("rasterized-live", id="custom-output"),
+    ],
+)
 async def test_live_async_rasterize_pdf_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_rasterize: PdfRestFile,
+    output_name: str | None,
 ) -> None:
+    kwargs: dict[str, str] = {}
+    if output_name is not None:
+        kwargs["output"] = output_name
+
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
-        response = await client.rasterize_pdf(
-            uploaded_pdf_for_rasterize, output="async"
-        )
+        response = await client.rasterize_pdf(uploaded_pdf_for_rasterize, **kwargs)
 
     assert response.output_files
     output_file = response.output_file
-    assert output_file.name.startswith("async")
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".pdf")
     assert output_file.type == "application/pdf"
     assert output_file.size > 0
     assert response.warning is None