Fill in missing live tests of conversion methods

Assisted-by: Codex

Author: datalogics-cgreen

tests/live/test_live_convert_to_excel.py

@@ -60,20 +60,35 @@ def test_live_convert_to_excel_success(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("async-excel", id="custom-output"),
+    ],
+)
 async def test_live_async_convert_to_excel_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_excel: 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.convert_to_excel(uploaded_pdf_for_excel, output="async")
+        response = await client.convert_to_excel(uploaded_pdf_for_excel, **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(".xlsx")
     assert (
         output_file.type
         == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"

tests/live/test_live_convert_to_pdfa.py

@@ -130,10 +130,19 @@ def test_live_convert_to_pdfa_invalid_output_type(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "invalid_output_type",
+    [
+        pytest.param("PDF/A-0", id="pdfa-0"),
+        pytest.param("PDF/A-99", id="pdfa-99"),
+        pytest.param("pdf/a-2b", id="lowercase"),
+    ],
+)
 async def test_live_async_convert_to_pdfa_invalid_output_type(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_pdfa: PdfRestFile,
+    invalid_output_type: str,
 ) -> None:
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
@@ -143,5 +152,5 @@ async def test_live_async_convert_to_pdfa_invalid_output_type(
             await client.convert_to_pdfa(
                 uploaded_pdf_for_pdfa,
                 output_type="PDF/A-1b",
-                extra_body={"output_type": "PDF/A-0"},
+                extra_body={"output_type": invalid_output_type},
             )

tests/live/test_live_convert_to_pdfx.py

@@ -104,10 +104,19 @@ def test_live_convert_to_pdfx_invalid_output_type(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "invalid_output_type",
+    [
+        pytest.param("PDF/X-0", id="pdfx-0"),
+        pytest.param("PDF/X-99", id="pdfx-99"),
+        pytest.param("pdf/x-4", id="lowercase"),
+    ],
+)
 async def test_live_async_convert_to_pdfx_invalid_output_type(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_pdfx: PdfRestFile,
+    invalid_output_type: str,
 ) -> None:
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
@@ -117,5 +126,5 @@ async def test_live_async_convert_to_pdfx_invalid_output_type(
             await client.convert_to_pdfx(
                 uploaded_pdf_for_pdfx,
                 output_type="PDF/X-1a",
-                extra_body={"output_type": "PDF/X-0"},
+                extra_body={"output_type": invalid_output_type},
             )

tests/live/test_live_convert_to_powerpoint.py

@@ -60,22 +60,37 @@ def test_live_convert_to_powerpoint_success(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("async-powerpoint", id="custom-output"),
+    ],
+)
 async def test_live_async_convert_to_powerpoint_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_powerpoint: 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.convert_to_powerpoint(
-            uploaded_pdf_for_powerpoint, output="async"
+            uploaded_pdf_for_powerpoint, **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(".pptx")
     assert (
         output_file.type
         == "application/vnd.openxmlformats-officedocument.presentationml.presentation"

tests/live/test_live_convert_to_word.py

@@ -58,23 +58,38 @@ def test_live_convert_to_word_success(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("async-word", id="custom-output"),
+    ],
+)
 async def test_live_async_convert_to_word_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_word: 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.convert_to_word(
             uploaded_pdf_for_word,
-            output="async-word",
+            **kwargs,
         )
 
     assert response.output_files
     output_file = response.output_file
-    assert output_file.name.startswith("async-word")
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".docx")
     assert (
         output_file.type
         == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"

tests/live/test_live_convert_xfa_to_acroforms.py

@@ -83,17 +83,29 @@ def test_live_convert_xfa_to_acroforms_invalid_file_id(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "output_name",
+    [
+        pytest.param(None, id="default-output"),
+        pytest.param("async-acroforms", id="custom-output"),
+    ],
+)
 async def test_live_async_convert_xfa_to_acroforms_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
     uploaded_pdf_for_acroforms: 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.convert_xfa_to_acroforms(
-            uploaded_pdf_for_acroforms, output="async"
+            uploaded_pdf_for_acroforms, **kwargs
         )
 
     assert str(response.input_id) == str(uploaded_pdf_for_acroforms.id)
@@ -104,7 +116,10 @@ async def test_live_async_convert_xfa_to_acroforms_success(
 
     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
 

tests/live/test_live_graphic_conversions.py

@@ -121,6 +121,27 @@ def uploaded_20_page_pdf(
         return client.files.create_from_paths([resource])[0]
 
 
+def test_live_convert_to_png_success(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> None:
+    resource = get_test_resource_path("report.pdf")
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        uploaded = client.files.create_from_paths([resource])[0]
+        response = client.convert_to_png(
+            uploaded,
+            output_prefix="live-png",
+            resolution=150,
+        )
+
+    assert response.output_files
+    assert all(file_info.type == "image/png" for file_info in response.output_files)
+    assert str(response.input_id) == str(uploaded.id)
+
+
 @pytest.mark.asyncio
 async def test_live_async_convert_to_png_success(
     pdfrest_api_key: str,
@@ -292,21 +313,29 @@ def test_live_graphic_invalid_smoothing(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("_endpoint_label", "spec", "invalid_smoothing"),
+    _invalid_smoothing_cases(),
+)
 async def test_live_async_graphic_invalid_smoothing(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
+    _endpoint_label: str,
+    spec: _GraphicEndpointSpec,
+    invalid_smoothing: Any,
 ) -> None:
     resource = get_test_resource_path("report.pdf")
     async with AsyncPdfRestClient(
         api_key=pdfrest_api_key,
         base_url=pdfrest_live_base_url,
     ) as client:
         uploaded = (await client.files.create_from_paths([resource]))[0]
+        client_method = getattr(client, spec.method_name)
         with pytest.raises(PdfRestApiError, match=r"(?i)smooth"):
-            await client.convert_to_png(
+            await client_method(
                 uploaded,
                 smoothing="none",
-                extra_body={"smoothing": "super-smooth"},
+                extra_body={"smoothing": invalid_smoothing},
             )