Add tests for PNG conversion with page ranges and invalid inputs

- More thoroughly test page ranges in light of new changes.
- Introduced new live tests to validate PNG conversion with various page
  range formats, including valid and invalid cases.
- Added coverage for page range parsing and error scenarios.
- Updated fixtures to support new tests with a 20-page PDF resource.

Assisted-by: Codex

Author: datalogics-kam

tests/live/test_live_graphic_conversions.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
 
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from typing import Any, NamedTuple, get_args
 
 import pytest
 
 from pdfrest import PdfRestApiError, PdfRestClient
+from pdfrest.models import PdfRestFile
 from pdfrest.models._internal import (
     BasePdfRestGraphicPayload,
     BmpPdfRestPayload,
@@ -107,6 +108,19 @@ def _invalid_smoothing_cases() -> list[Any]:
     return cases
 
 
+@pytest.fixture(scope="module")
+def uploaded_20_page_pdf(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> PdfRestFile:
+    resource = get_test_resource_path("20-pages.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(
     ("_endpoint_label", "spec", "color_model"),
     _valid_color_cases(),
@@ -253,3 +267,130 @@ def test_live_graphic_invalid_smoothing(
                 smoothing="none",
                 extra_body={"smoothing": invalid_smoothing},
             )
+
+
+@pytest.mark.parametrize(
+    ("page_range", "expect_success"),
+    [
+        pytest.param("5", True, id="single"),
+        pytest.param("3-7", True, id="ascending-range"),
+        pytest.param("last", True, id="last"),
+        pytest.param("1-last", True, id="entire-document"),
+        pytest.param(["1", "3", "5-7"], True, id="list-mixed"),
+    ],
+)
+def test_live_png_page_range_variants(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_20_page_pdf: PdfRestFile,
+    page_range: Any,
+    expect_success: bool,
+    request: pytest.FixtureRequest,
+) -> None:
+    case_id = request.node.callspec.id
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        info = client.query_pdf_info(uploaded_20_page_pdf)
+
+        assert info.page_count == 20
+        assert str(info.input_id) == str(uploaded_20_page_pdf.id)
+        assert info.filename is None or info.filename.endswith(".pdf")
+
+        if expect_success:
+            response = client.convert_to_png(
+                uploaded_20_page_pdf,
+                output_prefix=f"live-range-{case_id}",
+                page_range=page_range,
+            )
+
+            expected_pages = _expand_page_selection(page_range, total_pages=20)
+            assert len(response.output_files) == len(expected_pages)
+            assert any(
+                file_info.name.endswith(".png") for file_info in response.output_files
+            )
+            assert all(
+                file_info.type == "image/png" and file_info.size > 0
+                for file_info in response.output_files
+            )
+            assert str(response.input_id) == str(uploaded_20_page_pdf.id)
+        else:
+            with pytest.raises(PdfRestApiError):
+                client.convert_to_png(
+                    uploaded_20_page_pdf,
+                    output_prefix=f"live-range-{case_id}",
+                    extra_body={"page_range": page_range},
+                )
+
+
+@pytest.mark.parametrize(
+    "page_override",
+    [
+        pytest.param("0", id="zero"),
+        pytest.param("last-0", id="range-with-zero"),
+        pytest.param("7-3", id="descending-range"),
+        pytest.param("even", id="even"),
+        pytest.param("odd", id="odd"),
+        pytest.param("odd,even", id="odd-even"),
+    ],
+)
+def test_live_png_page_range_invalid_overrides(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_20_page_pdf: PdfRestFile,
+    page_override: str,
+    request: pytest.FixtureRequest,
+) -> None:
+    case_id = request.node.callspec.id
+    with (
+        PdfRestClient(
+            api_key=pdfrest_api_key,
+            base_url=pdfrest_live_base_url,
+        ) as client,
+        pytest.raises(PdfRestApiError),
+    ):
+        client.convert_to_png(
+            uploaded_20_page_pdf,
+            output_prefix=f"live-range-invalid-{case_id}",
+            page_range="1",
+            extra_body={"pages": page_override},
+        )
+
+
+def _expand_page_selection(
+    selection: Any,
+    *,
+    total_pages: int,
+) -> list[int]:
+    def expand_entry(entry: Any) -> list[int]:
+        if isinstance(entry, int):
+            return [entry]
+        text = str(entry).strip()
+        lowered = text.lower()
+        if lowered == "even":
+            return list(range(2, total_pages + 1, 2))
+        if lowered == "odd":
+            return list(range(1, total_pages + 1, 2))
+        if lowered == "last":
+            return [total_pages]
+        if "-" in lowered:
+            start_raw, end_raw = (part.strip() for part in lowered.split("-", 1))
+
+            def resolve(range_token: str) -> int:
+                return total_pages if range_token == "last" else int(range_token)  # noqa: S105
+
+            start = resolve(start_raw)
+            end = resolve(end_raw)
+            step = 1 if end >= start else -1
+            return list(range(start, end + step, step))
+        return [int(text)]
+
+    if isinstance(selection, Sequence) and not isinstance(
+        selection, (str, bytes, bytearray)
+    ):
+        expanded: list[int] = []
+        for segment in selection:
+            expanded.extend(expand_entry(segment))
+        return expanded
+    return expand_entry(selection)

tests/resources/20-pages.pdf

@@ -92,39 +92,49 @@ def test_graphic_payload_invalid_output_prefix(
     [
         pytest.param(
             "0",
-            "Page numbers must be greater than or equal to 1.",
+            "greater than or equal to 1",
             id="scalar-zero",
         ),
         pytest.param(
             ["0"],
-            "Page numbers must be greater than or equal to 1.",
+            "greater than or equal to 1",
             id="list-zero-string",
         ),
         pytest.param(
             [0],
-            "Page numbers must be greater than or equal to 1.",
+            "greater than or equal to 1",
             id="list-zero-int",
         ),
         pytest.param(
             "last-5",
-            "Page range start must be a page number greater than or equal to 1.",
+            "unable to parse string as an integer",
             id="range-last-to-number",
         ),
         pytest.param(
             "3-2",
-            "Page range end must be greater than or equal to the start.",
+            "less than or equal to the end page",
             id="range-descending",
         ),
         pytest.param(
             "foo",
-            "Page range entries must be positive integers, 'last', or a range like '1-3' or '6-last'.",
+            "unable to parse string as an integer",
             id="scalar-word",
         ),
         pytest.param(
             ["1", "foo"],
-            "Page range entries must be positive integers, 'last', or a range like '1-3' or '6-last'.",
+            "unable to parse string as an integer",
             id="list-mixed",
         ),
+        pytest.param(
+            "even",
+            "unable to parse string as an integer",
+            id="even",
+        ),
+        pytest.param(
+            "odd",
+            "unable to parse string as an integer",
+            id="odd",
+        ),
     ],
 )
 def test_graphic_payload_invalid_page_range_value(
@@ -139,3 +149,41 @@ def test_graphic_payload_invalid_page_range_value(
                 "page_range": bad_page_range,
             }
         )
+
+
+@pytest.mark.parametrize("payload_model", PAYLOAD_MODELS)
+@pytest.mark.parametrize(
+    ("page_range", "expected_message"),
+    [
+        pytest.param(
+            "even",
+            "unable to parse string as an integer",
+            id="even",
+        ),
+        pytest.param(
+            "odd",
+            "unable to parse string as an integer",
+            id="odd",
+        ),
+        pytest.param(
+            "5-3",
+            "less than or equal to the end page",
+            id="descending",
+        ),
+    ],
+)
+def test_graphic_payload_rejects_special_ranges(
+    payload_model: type[BasePdfRestGraphicPayload[Any]],
+    page_range: str,
+    expected_message: str,
+) -> None:
+    with pytest.raises(
+        ValidationError,
+        match=expected_message,
+    ):
+        payload_model.model_validate(
+            {
+                "files": [make_pdf_file("12345678-1234-4abc-8def-1234567890ab")],
+                "page_range": page_range,
+            }
+        )