libreoffice-haystack 1.0.0__tar.gz → 2.0.0__tar.gz

libreoffice_haystack-2.0.0/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## [integrations/libreoffice-v1.1.1] - 2026-08-25
+
+### 🐛 Bug Fixes
+
+- Fix new issues raised by ruff 0.16.0 (#3670)
+- LibreOffice - serialize output_file_type and increase unit tests coverage (#3793)
+
+### 🧪 Testing
+
+- Track test coverage for all integrations (#3065)
+
+### 🧹 Chores
+
+- Re-standardize READMEs (#3768)
+
+## [integrations/libreoffice-v1.1.0] - 2026-03-30
+
+### 🚀 Features
+
+- Add mime_type to ByteStream in LibreOfficeFileConverter (#3057)
+
+
+## [integrations/libreoffice-v1.0.0] - 2026-03-25
+
+### 🚀 Features
+
+- Add new `LibreOfficeFileConverter` integration (#3006)
+
+<!-- generated by git-cliff -->

{libreoffice_haystack-1.0.0 → libreoffice_haystack-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: libreoffice-haystack
-Version: 1.0.0
+Version: 2.0.0
 Summary: LibreOffice integration for Haystack
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/tree/main/integrations/libreoffice#readme
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
@@ -12,14 +12,14 @@ License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: haystack-ai
 Description-Content-Type: text/markdown
 
@@ -28,6 +28,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/libreoffice-haystack.svg)](https://pypi.org/project/libreoffice-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/libreoffice-haystack.svg)](https://pypi.org/project/libreoffice-haystack)
 
+- [Integration page](https://haystack.deepset.ai/integrations/libreoffice-file-converter)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/libreoffice/CHANGELOG.md)
 
 ---
@@ -35,3 +36,5 @@ Description-Content-Type: text/markdown
 ## Contributing
 
 Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
+
+To run integration tests locally, you need LibreOffice installed and available on your `PATH`.

{libreoffice_haystack-1.0.0 → libreoffice_haystack-2.0.0}/README.md

@@ -3,6 +3,7 @@
 [![PyPI - Version](https://img.shields.io/pypi/v/libreoffice-haystack.svg)](https://pypi.org/project/libreoffice-haystack)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/libreoffice-haystack.svg)](https://pypi.org/project/libreoffice-haystack)
 
+- [Integration page](https://haystack.deepset.ai/integrations/libreoffice-file-converter)
 - [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/libreoffice/CHANGELOG.md)
 
 ---
@@ -10,3 +11,5 @@
 ## Contributing
 
 Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
+
+To run integration tests locally, you need LibreOffice installed and available on your `PATH`.

{libreoffice_haystack-1.0.0 → libreoffice_haystack-2.0.0}/pyproject.toml

@@ -7,7 +7,7 @@ name = "libreoffice-haystack"
 dynamic = ["version"]
 description = "LibreOffice integration for Haystack"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = "Apache-2.0"
 keywords = []
 authors = [{ name = "deepset GmbH", email = "info@deepset.ai" }, { name = "Max Swain" }]
@@ -15,11 +15,11 @@ classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
@@ -64,7 +64,8 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
+unit-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x -m "not integration" {args:tests}'
+integration-cov-append-retry = 'pytest --cov=haystack_integrations --cov-append --reruns 3 --reruns-delay 30 -x -m "integration" {args:tests}'
 types = "mypy -p haystack_integrations.components.converters.libreoffice {args}"
 
 [tool.mypy]
@@ -126,6 +127,7 @@ ignore = [
     "PLR0912",
     "PLR0913",
     "PLR0915",
+    "PLR0917",
     # Allow `Any` type - used legitimately for dynamic types and SDK boundaries
     "ANN401",
 ]
@@ -143,6 +145,7 @@ ban-relative-imports = "parents"
 [tool.coverage.run]
 source = ["haystack_integrations"]
 branch = true
+relative_files = true
 parallel = false
 
 [tool.coverage.report]

{libreoffice_haystack-1.0.0 → libreoffice_haystack-2.0.0}/src/haystack_integrations/components/converters/libreoffice/converter.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import mimetypes
 import os
 import shutil
 import subprocess
@@ -9,11 +10,10 @@ from asyncio import create_subprocess_exec
 from collections.abc import Iterable
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from typing import Any, ClassVar, Literal, TypedDict, get_args
+from typing import Any, ClassVar, Literal, Self, TypedDict, get_args
 
 from haystack import component, default_from_dict, default_to_dict
 from haystack.dataclasses import ByteStream
-from typing_extensions import Self
 
 OUTPUT_FILE_TYPE = Literal[
     "pdf",
@@ -109,6 +109,26 @@ class LibreOfficeFileConverter:
     """A non-exhaustive mapping of supported conversion types by this component.
     See https://help.libreoffice.org/latest/en-GB/text/shared/guide/convertfilters.html for more information."""
 
+    MIME_TYPE_FALLBACKS: ClassVar[dict[str, str]] = {
+        "pdf": "application/pdf",
+        "doc": "application/msword",
+        "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "odt": "application/vnd.oasis.opendocument.text",
+        "rtf": "application/rtf",
+        "txt": "text/plain",
+        "html": "text/html",
+        "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "xls": "application/vnd.ms-excel",
+        "ods": "application/vnd.oasis.opendocument.spreadsheet",
+        "csv": "text/csv",
+        "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "ppt": "application/vnd.ms-powerpoint",
+        "odp": "application/vnd.oasis.opendocument.presentation",
+        "epub": "application/epub+zip",
+        "png": "image/png",
+        "jpg": "image/jpeg",
+    }
+
     def __init__(
         self,
         output_file_type: OUTPUT_FILE_TYPE | None = None,
@@ -137,7 +157,7 @@ class LibreOfficeFileConverter:
         :returns:
             Dictionary with serialized data.
         """
-        return default_to_dict(self)
+        return default_to_dict(self, output_file_type=self.output_file_type)
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self:
@@ -224,6 +244,12 @@ class LibreOfficeFileConverter:
             )
             raise ValueError(msg)
 
+    def _resolve_mime_type(self, output_path: Path, output_file_type: str) -> str | None:
+        mime_type, _ = mimetypes.guess_type(str(output_path))
+        if mime_type is None:
+            return self.MIME_TYPE_FALLBACKS.get(output_file_type)
+        return mime_type
+
     @component.output_types(output=list[ByteStream])
     def run(
         self,
@@ -251,6 +277,7 @@ class LibreOfficeFileConverter:
         :raises ValueError: If a source's file type is not in :attr:`SUPPORTED_TYPES`,
             or if `output_file_type` is not a valid conversion target for it,
             or if `output_file_type` has not been provided anywhere.
+        :raises subprocess.CalledProcessError: If soffice exits with a non-zero status.
         """
         resolved_output_file_type = output_file_type or self.output_file_type
         if resolved_output_file_type is None:
@@ -269,14 +296,24 @@ class LibreOfficeFileConverter:
                     output_path, args = self._get_conversion_args(tmp_path, tmpdir, resolved_output_file_type)
 
                     subprocess.run(args, check=True)  # noqa: S603 - ruff doesn't know the arguments have been validated
-                    outputs.append(ByteStream(data=output_path.read_bytes()))
+                    outputs.append(
+                        ByteStream(
+                            data=output_path.read_bytes(),
+                            mime_type=self._resolve_mime_type(output_path, resolved_output_file_type),
+                        )
+                    )
                     continue
 
                 self._validate_args(resolved_output_file_type, str(source).split(".")[-1])
                 output_path, args = self._get_conversion_args(source, tmpdir, resolved_output_file_type)
 
                 subprocess.run(args, check=True)  # noqa: S603
-                outputs.append(ByteStream(data=output_path.read_bytes()))
+                outputs.append(
+                    ByteStream(
+                        data=output_path.read_bytes(),
+                        mime_type=self._resolve_mime_type(output_path, resolved_output_file_type),
+                    )
+                )
 
         return {"output": outputs}
 
@@ -309,6 +346,7 @@ class LibreOfficeFileConverter:
         :raises ValueError: If a source's file type is not in :attr:`SUPPORTED_TYPES`,
             or if `output_file_type` is not a valid conversion target for it,
             or if `output_file_type` has not been provided anywhere.
+        :raises subprocess.CalledProcessError: If soffice exits with a non-zero status.
         """
         resolved_output_file_type = output_file_type or self.output_file_type
         if resolved_output_file_type is None:
@@ -328,8 +366,14 @@ class LibreOfficeFileConverter:
 
                     process = await create_subprocess_exec(*args)
                     # Wait for process to complete as only one instance of soffice can occur at once
-                    await process.wait()
-                    outputs.append(ByteStream(data=output_path.read_bytes()))
+                    if returncode := await process.wait():
+                        raise subprocess.CalledProcessError(returncode, args)
+                    outputs.append(
+                        ByteStream(
+                            data=output_path.read_bytes(),
+                            mime_type=self._resolve_mime_type(output_path, resolved_output_file_type),
+                        )
+                    )
                     continue
 
                 self._validate_args(resolved_output_file_type, str(source).split(".")[-1])
@@ -337,8 +381,14 @@ class LibreOfficeFileConverter:
 
                 process = await create_subprocess_exec(*args)
                 # Wait for process to complete as only one instance of soffice can occur at once
-                await process.wait()
-
-                outputs.append(ByteStream(data=output_path.read_bytes()))
+                if returncode := await process.wait():
+                    raise subprocess.CalledProcessError(returncode, args)
+
+                outputs.append(
+                    ByteStream(
+                        data=output_path.read_bytes(),
+                        mime_type=self._resolve_mime_type(output_path, resolved_output_file_type),
+                    )
+                )
 
         return {"output": outputs}

libreoffice_haystack-2.0.0/tests/conftest.py

@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import subprocess
+from collections.abc import Generator
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from haystack_integrations.components.converters.libreoffice import LibreOfficeFileConverter
+
+CONVERTER_MODULE = "haystack_integrations.components.converters.libreoffice.converter"
+
+
+@pytest.fixture
+def real_converter() -> LibreOfficeFileConverter:
+    """A converter backed by an actual LibreOffice installation, for the integration tests."""
+    return LibreOfficeFileConverter()
+
+
+@pytest.fixture
+def mock_converter() -> Generator[LibreOfficeFileConverter, None]:
+    """A converter that believes soffice is installed, so no LibreOffice binary is needed."""
+    with patch("shutil.which", return_value="/usr/bin/soffice"):
+        yield LibreOfficeFileConverter()
+
+
+@pytest.fixture
+def fake_soffice() -> Generator[SimpleNamespace, None]:
+    """
+    Stand in for soffice on both the sync and the async call, so no LibreOffice is needed.
+
+    Writes the file the real binary would have produced, deriving the output path from the
+    same argv the converter built, so the tests break if that contract changes. `calls`
+    records every argv; set `returncode` non-zero to report a failed conversion.
+
+    The sync side only raises on a non-zero `returncode` when the caller opted in with
+    `check=True`, exactly as `subprocess.run` does, so dropping that argument fails a test
+    instead of passing quietly.
+    """
+    fake = SimpleNamespace(calls=[], returncode=0)
+
+    def _convert(args: list[str]) -> None:
+        fake.calls.append(args)
+        if fake.returncode:
+            return
+        outdir = Path(args[args.index("--outdir") + 1])
+        suffix = args[args.index("--convert-to") + 1]
+        (outdir / Path(args[-1]).name).with_suffix(f".{suffix}").write_bytes(b"converted bytes")
+
+    def _run(args: list[str], *, check: bool = False, **_: object) -> None:
+        _convert(args)
+        if fake.returncode and check:
+            raise subprocess.CalledProcessError(fake.returncode, args)
+
+    async def _exec(*args: str) -> AsyncMock:
+        _convert(list(args))
+        process = AsyncMock()
+        process.wait = AsyncMock(return_value=fake.returncode)
+        return process
+
+    with (
+        patch(f"{CONVERTER_MODULE}.subprocess.run", side_effect=_run),
+        patch(f"{CONVERTER_MODULE}.create_subprocess_exec", side_effect=_exec),
+    ):
+        yield fake
+
+
+@pytest.fixture
+def test_files_path() -> Path:
+    """Directory holding the sample office documents, resolved relative to this file."""
+    return Path(__file__).parent / "test_files"

libreoffice_haystack-2.0.0/tests/test_converter.py

@@ -0,0 +1,239 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import subprocess
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+from haystack.dataclasses import ByteStream
+
+from haystack_integrations.components.converters.libreoffice import LibreOfficeFileConverter
+
+TYPE = "haystack_integrations.components.converters.libreoffice.converter.LibreOfficeFileConverter"
+
+
+def _converted_to(args: list[str]) -> str:
+    """The output file type the converter asked soffice for."""
+    return args[args.index("--convert-to") + 1]
+
+
+async def _convert(converter: LibreOfficeFileConverter, is_async: bool, *args: Any, **kwargs: Any) -> Any:
+    """Call `run_async` or `run`, so one test body can cover both."""
+    return await converter.run_async(*args, **kwargs) if is_async else converter.run(*args, **kwargs)
+
+
+def _configured_converter(output_file_type: str) -> LibreOfficeFileConverter:
+    """A converter with an `output_file_type` set at init time, needing no LibreOffice installation."""
+    with patch("shutil.which", return_value="/usr/bin/soffice"):
+        return LibreOfficeFileConverter(output_file_type=output_file_type)
+
+
+class TestInit:
+    def test_init(self, mock_converter: LibreOfficeFileConverter) -> None:
+        assert isinstance(mock_converter.soffice_path, str)
+        assert mock_converter.output_file_type is None
+        assert _configured_converter("pdf").output_file_type == "pdf"
+
+    def test_raises_when_soffice_is_not_installed(self) -> None:
+        with patch("shutil.which", return_value=None):
+            with pytest.raises(FileNotFoundError, match="LibreOffice"):
+                LibreOfficeFileConverter()
+
+
+class TestSerde:
+    def test_to_dict(self, mock_converter: LibreOfficeFileConverter) -> None:
+        assert mock_converter.to_dict() == {"type": TYPE, "init_parameters": {"output_file_type": None}}
+        assert _configured_converter("pdf").to_dict() == {"type": TYPE, "init_parameters": {"output_file_type": "pdf"}}
+
+    def test_from_dict(self) -> None:
+        with patch("shutil.which", return_value="/usr/bin/soffice"):
+            converter = LibreOfficeFileConverter.from_dict({"type": TYPE, "init_parameters": {}})
+        assert isinstance(converter.soffice_path, str)
+        # Dictionaries serialized before `output_file_type` was included still deserialize.
+        assert converter.output_file_type is None
+
+    def test_round_trip_keeps_converting_to_the_configured_type(
+        self, fake_soffice: SimpleNamespace, tmp_path: Path
+    ) -> None:
+        source = tmp_path / "sample.doc"
+        source.write_bytes(b"doc")
+
+        with patch("shutil.which", return_value="/usr/bin/soffice"):
+            deserialized = LibreOfficeFileConverter.from_dict(_configured_converter("pdf").to_dict())
+
+        # The converter that came back out of the round trip still needs no `output_file_type` argument.
+        assert deserialized.run([source])["output"][0].mime_type == "application/pdf"
+        assert _converted_to(fake_soffice.calls[-1]) == "pdf"
+
+
+class TestGetConversionArgs:
+    def test_builds_the_soffice_command_line(self, mock_converter: LibreOfficeFileConverter, tmp_path: Path) -> None:
+        source = tmp_path / "sample.doc"
+        source.write_bytes(b"doc")
+
+        output_path, args = mock_converter._get_conversion_args(source, tmp_path, "pdf")
+
+        assert args == ["/usr/bin/soffice", "--headless", "--convert-to", "pdf", "--outdir", str(tmp_path), str(source)]
+        assert output_path == tmp_path / "sample.pdf"
+
+    def test_rejects_an_output_directory_that_does_not_exist(
+        self, mock_converter: LibreOfficeFileConverter, tmp_path: Path
+    ) -> None:
+        source = tmp_path / "sample.doc"
+        source.write_bytes(b"doc")
+
+        with pytest.raises(OSError, match="must exist and be writable"):
+            mock_converter._get_conversion_args(source, tmp_path / "missing", "pdf")
+
+
+class TestValidateArgs:
+    @pytest.mark.parametrize(
+        ("output_file_type", "error"),
+        [
+            # .pdf is not a supported input type in SUPPORTED_TYPES
+            ("docx", "input_file_type"),
+            # .doc -> .png is not a valid conversion
+            ("png", "is not supported for"),
+            # .xyz is not one of the OUTPUT_FILE_TYPE values at all
+            ("xyz", "is not supported and must be one of type"),
+        ],
+    )
+    def test_rejects_unsupported_conversions(
+        self, mock_converter: LibreOfficeFileConverter, output_file_type: str, error: str
+    ) -> None:
+        source = "test_file.pdf" if output_file_type == "docx" else "test_file.doc"
+        with pytest.raises(ValueError, match=error):
+            mock_converter.run([source], output_file_type=output_file_type)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("is_async", [False, True], ids=["run", "run_async"])
+class TestConvert:
+    """`run` and `run_async` share their logic, so every case here covers both."""
+
+    async def test_converts_each_source_in_order(
+        self, mock_converter: LibreOfficeFileConverter, fake_soffice: SimpleNamespace, tmp_path: Path, is_async: bool
+    ) -> None:
+        first, second = tmp_path / "first.doc", tmp_path / "second.ppt"
+        first.write_bytes(b"doc")
+        second.write_bytes(b"ppt")
+
+        result = await _convert(mock_converter, is_async, [first, second], output_file_type="pdf")
+
+        assert [stream.data for stream in result["output"]] == [b"converted bytes"] * 2
+        assert [stream.mime_type for stream in result["output"]] == ["application/pdf"] * 2
+        assert len(fake_soffice.calls) == 2
+
+    async def test_writes_a_bytestream_to_a_temporary_file_before_converting(
+        self, mock_converter: LibreOfficeFileConverter, fake_soffice: SimpleNamespace, is_async: bool
+    ) -> None:
+        result = await _convert(mock_converter, is_async, [ByteStream(data=b"raw doc bytes")], output_file_type="pdf")
+
+        assert [stream.data for stream in result["output"]] == [b"converted bytes"]
+        # The source handed to soffice is the temporary file, not the original path.
+        assert Path(fake_soffice.calls[-1][-1]).name == "input"
+
+    async def test_rejects_a_source_that_does_not_exist(
+        self, mock_converter: LibreOfficeFileConverter, is_async: bool
+    ) -> None:
+        with pytest.raises(FileNotFoundError):
+            await _convert(mock_converter, is_async, ["nonexistent_file.doc"], output_file_type="docx")
+
+    async def test_uses_the_output_file_type_from_init(
+        self, fake_soffice: SimpleNamespace, tmp_path: Path, is_async: bool
+    ) -> None:
+        source = tmp_path / "sample.doc"
+        source.write_bytes(b"doc")
+
+        result = await _convert(_configured_converter("pdf"), is_async, [source])
+
+        assert result["output"][0].mime_type == "application/pdf"
+        assert _converted_to(fake_soffice.calls[-1]) == "pdf"
+
+    async def test_argument_overrides_the_output_file_type_from_init(
+        self, fake_soffice: SimpleNamespace, tmp_path: Path, is_async: bool
+    ) -> None:
+        source = tmp_path / "sample.doc"
+        source.write_bytes(b"doc")
+
+        await _convert(_configured_converter("docx"), is_async, [source], output_file_type="pdf")
+
+        assert _converted_to(fake_soffice.calls[-1]) == "pdf"
+
+    async def test_requires_an_output_file_type_somewhere(
+        self, mock_converter: LibreOfficeFileConverter, is_async: bool
+    ) -> None:
+        with pytest.raises(ValueError, match="output_file_type must be provided"):
+            await _convert(mock_converter, is_async, ["sample.doc"])
+
+    @pytest.mark.parametrize("as_bytestream", [False, True])
+    async def test_raises_when_soffice_exits_non_zero(
+        self,
+        mock_converter: LibreOfficeFileConverter,
+        fake_soffice: SimpleNamespace,
+        tmp_path: Path,
+        is_async: bool,
+        as_bytestream: bool,
+    ) -> None:
+        path = tmp_path / "sample.doc"
+        path.write_bytes(b"doc")
+        fake_soffice.returncode = 1
+        source = ByteStream(data=b"raw doc bytes") if as_bytestream else path
+
+        with pytest.raises(subprocess.CalledProcessError):
+            await _convert(mock_converter, is_async, [source], output_file_type="pdf")
+
+
+class TestResolveMimeType:
+    @pytest.mark.parametrize(
+        ("guessed", "output_file_type", "expected"),
+        [
+            ("application/pdf", "pdf", "application/pdf"),
+            (None, "docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
+            (None, "unknown", None),
+        ],
+    )
+    def test_falls_back_to_the_mapping_when_the_guess_fails(
+        self,
+        mock_converter: LibreOfficeFileConverter,
+        guessed: str | None,
+        output_file_type: str,
+        expected: str | None,
+    ) -> None:
+        with patch("mimetypes.guess_type", return_value=(guessed, None)):
+            assert mock_converter._resolve_mime_type(Path(f"test.{output_file_type}"), output_file_type) == expected
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+@pytest.mark.parametrize("is_async", [False, True], ids=["run", "run_async"])
+class TestRunIntegration:
+    """End-to-end against a real LibreOffice installation, for both `run` and `run_async`."""
+
+    @pytest.mark.parametrize("as_bytestream", [False, True])
+    async def test_converts_office_files_to_pdf(
+        self,
+        real_converter: LibreOfficeFileConverter,
+        test_files_path: Path,
+        is_async: bool,
+        as_bytestream: bool,
+    ) -> None:
+        paths = [
+            test_files_path / "doc" / "sample_doc.doc",
+            test_files_path / "ppt" / "sample_ppt.ppt",
+            test_files_path / "xls" / "basic_tables_two_sheets.xls",
+        ]
+        sources = [ByteStream(data=paths[0].read_bytes())] if as_bytestream else paths
+
+        result = await _convert(real_converter, is_async, sources, output_file_type="pdf")
+
+        output = result["output"]
+        assert len(output) == len(sources)
+        for stream in output:
+            assert isinstance(stream, ByteStream)
+            assert len(stream.data) > 0
+            assert stream.mime_type == "application/pdf"

libreoffice_haystack-1.0.0/tests/test_converter.py

@@ -1,129 +0,0 @@
-# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from collections.abc import Generator
-from pathlib import Path
-from unittest.mock import patch
-
-import pytest
-from haystack.dataclasses import ByteStream
-
-from haystack_integrations.components.converters.libreoffice import LibreOfficeFileConverter
-
-
-@pytest.fixture
-def converter() -> LibreOfficeFileConverter:
-    return LibreOfficeFileConverter()
-
-
-@pytest.fixture
-def mock_converter() -> Generator[LibreOfficeFileConverter, None]:
-    with patch("shutil.which", return_value="/usr/bin/soffice"):
-        yield LibreOfficeFileConverter()
-
-
-@pytest.fixture
-def test_files_path() -> Path:
-    return Path("tests") / "test_files"
-
-
-class TestLibreOfficeFileConverter:
-    def test_init(self, mock_converter: LibreOfficeFileConverter) -> None:
-        assert isinstance(mock_converter, LibreOfficeFileConverter)
-        assert isinstance(mock_converter.soffice_path, str)
-
-    def test_init_raises_when_soffice_not_found(self) -> None:
-        with patch("shutil.which", return_value=None):
-            with pytest.raises(FileNotFoundError, match="LibreOffice"):
-                LibreOfficeFileConverter()
-
-    def test_to_dict(self, mock_converter: LibreOfficeFileConverter) -> None:
-        data = mock_converter.to_dict()
-        assert data == {
-            "type": "haystack_integrations.components.converters.libreoffice.converter.LibreOfficeFileConverter",
-            "init_parameters": {},
-        }
-
-    def test_from_dict(self) -> None:
-        data = {
-            "type": "haystack_integrations.components.converters.libreoffice.converter.LibreOfficeFileConverter",
-            "init_parameters": {},
-        }
-        with patch("shutil.which", return_value="/usr/bin/soffice"):
-            converter = LibreOfficeFileConverter.from_dict(data)
-        assert isinstance(converter.soffice_path, str)
-
-    def test_run_unsupported_input_type(self, mock_converter: LibreOfficeFileConverter) -> None:
-        # .pdf is not a supported input type in SUPPORTED_TYPES
-        with pytest.raises(ValueError):
-            mock_converter.run(["test_file.pdf"], output_file_type="docx")
-
-    def test_run_unsupported_output_type(self, mock_converter: LibreOfficeFileConverter) -> None:
-        # .doc -> .png is not a valid conversion
-        with pytest.raises(ValueError):
-            mock_converter.run(["test_file.doc"], output_file_type="png")
-
-    def test_run_no_file(self, mock_converter: LibreOfficeFileConverter) -> None:
-        with pytest.raises(FileNotFoundError):
-            mock_converter.run(["nonexistent_file.doc"], output_file_type="docx")
-
-    @pytest.mark.integration
-    def test_run(self, converter: LibreOfficeFileConverter, test_files_path: Path) -> None:
-        paths = [
-            test_files_path / "doc" / "sample_doc.doc",
-            test_files_path / "ppt" / "sample_ppt.ppt",
-            test_files_path / "xls" / "basic_tables_two_sheets.xls",
-        ]
-
-        results = converter.run(paths, output_file_type="pdf")
-
-        output = results["output"]
-        assert len(output) == 3
-        for stream in output:
-            assert isinstance(stream, ByteStream)
-            assert len(stream.data) > 0
-
-    @pytest.mark.integration
-    def test_run_bytestream_source(self, converter: LibreOfficeFileConverter, test_files_path: Path) -> None:
-        source_path = test_files_path / "doc" / "sample_doc.doc"
-        bytestream = ByteStream(data=source_path.read_bytes())
-
-        results = converter.run([bytestream], output_file_type="pdf")
-
-        output = results["output"]
-        assert len(output) == 1
-        assert isinstance(output[0], ByteStream)
-        assert len(output[0].data) > 0
-
-    @pytest.mark.asyncio
-    @pytest.mark.integration
-    async def test_run_async(self, converter: LibreOfficeFileConverter, test_files_path: Path) -> None:
-        paths = [
-            test_files_path / "doc" / "sample_doc.doc",
-            test_files_path / "ppt" / "sample_ppt.ppt",
-            test_files_path / "xls" / "basic_tables_two_sheets.xls",
-        ]
-
-        results = await converter.run_async(paths, output_file_type="pdf")
-
-        output = results["output"]
-        assert len(output) == 3
-        for stream in output:
-            assert isinstance(stream, ByteStream)
-            assert len(stream.data) > 0
-
-    @pytest.mark.asyncio
-    @pytest.mark.integration
-    async def test_run_async_bytestream_source(
-        self, converter: LibreOfficeFileConverter, test_files_path: Path
-    ) -> None:
-        source_path = test_files_path / "doc" / "sample_doc.doc"
-        bytestream = ByteStream(data=source_path.read_bytes())
-
-        results = await converter.run_async([bytestream], output_file_type="pdf")
-
-        output = results["output"]
-        assert len(output) == 1
-        assert isinstance(output[0], ByteStream)
-        assert len(output[0].data) > 0