pytest-remaster 0.0.0__py3-none-any.whl

pytest_remaster/__init__.py

@@ -0,0 +1,13 @@
+"""Golden master testing for pytest with automatic regeneration."""
+
+from pytest_remaster.core import (  # pragma: no cover
+    GoldenMaster,
+    discover_test_cases,
+    discover_test_files,
+)
+
+__all__ = [
+    "GoldenMaster",
+    "discover_test_cases",
+    "discover_test_files",
+]  # pragma: no cover

pytest_remaster/core.py

@@ -0,0 +1,143 @@
+"""Core golden master comparison and discovery logic."""
+
+from __future__ import annotations  # pragma: no cover
+
+import difflib  # pragma: no cover
+import re  # pragma: no cover
+from collections.abc import Callable  # pragma: no cover
+from pathlib import Path  # pragma: no cover
+from typing import Any  # pragma: no cover
+
+import pytest  # pragma: no cover
+
+
+class GoldenMaster:  # pragma: no cover
+    """Golden master comparison with optional auto-regeneration."""
+
+    def __init__(self, remaster: bool) -> None:  # pragma: no cover
+        self._remaster = remaster
+
+    def check(  # pragma: no cover
+        self,
+        actual: Any | Callable[[], Any],
+        expected_path: str | Path,
+        serializer: Callable[[Any], str] = str,
+    ) -> None:
+        """Compare actual output against an expected file.
+
+        Args:
+            actual: The actual value, or a callable that produces it.
+            expected_path: Path to the expected output file.
+            serializer: Converts actual value to string. Default: str().
+        """
+        expected_path = Path(expected_path)
+        if callable(actual) and not isinstance(actual, str):
+            actual = actual()
+        actual_str = serializer(actual).rstrip()
+
+        try:
+            expected_str = expected_path.read_text(encoding="utf-8").rstrip()
+        except FileNotFoundError:
+            expected_str = None
+
+        if expected_str is not None and actual_str == expected_str:
+            return
+
+        if self._remaster:
+            expected_path.parent.mkdir(parents=True, exist_ok=True)
+            expected_path.write_text(actual_str + "\n", encoding="utf-8")
+            action = "created" if expected_str is None else "updated"
+            pytest.fail(
+                f"Golden master {action} at {expected_path}, "
+                f"please review and relaunch.",
+                pytrace=False,
+            )
+        else:
+            if expected_str is None:
+                pytest.fail(
+                    f"Expected file {expected_path} does not exist. "
+                    f"Run with --remaster to create it.",
+                    pytrace=False,
+                )
+            diff = difflib.unified_diff(
+                expected_str.splitlines(keepends=True),
+                actual_str.splitlines(keepends=True),
+                fromfile=str(expected_path),
+                tofile="actual",
+            )
+            pytest.fail(
+                f"Golden master mismatch at {expected_path}:\n{''.join(diff)}",
+                pytrace=False,
+            )
+
+    def check_all(  # pragma: no cover
+        self,
+        *actuals: Any | Callable[[], list[Any]],
+        directory: str | Path,
+        serializer: Callable[[Any], str] = str,
+    ) -> None:
+        """Compare multiple actuals against result_0, result_1, ... files.
+
+        Args:
+            *actuals: Values to compare, or a single callable returning a list.
+            directory: Directory containing result_N files.
+            serializer: Converts each value to string. Default: str().
+        """
+        directory = Path(directory)
+
+        if (
+            len(actuals) == 1
+            and callable(actuals[0])
+            and not isinstance(actuals[0], str)
+        ):
+            actuals = tuple(actuals[0]())
+
+        existing = sorted(
+            (p for p in directory.iterdir() if re.match(r"result_\d+$", p.name)),
+            key=lambda p: int(p.name.split("_")[1]),
+        )
+
+        if self._remaster and len(actuals) != len(existing):
+            for extra in existing[len(actuals) :]:
+                extra.unlink()
+
+        for i, actual in enumerate(actuals):
+            self.check(actual, directory / f"result_{i}", serializer=serializer)
+
+        if not self._remaster and len(actuals) < len(existing):
+            extra_files = [p.name for p in existing[len(actuals) :]]
+            pytest.fail(
+                f"Expected {len(existing)} results but got {len(actuals)}. "
+                f"Extra files: {extra_files}. Run with --remaster to clean up.",
+                pytrace=False,
+            )
+
+
+def discover_test_cases(base_dir: str | Path) -> list[Path]:  # pragma: no cover
+    """Find leaf directories (containing only files) under base_dir.
+
+    Suitable for use with ``@pytest.mark.parametrize``.
+    Returns absolute paths sorted alphabetically.
+    """
+    base_dir = Path(base_dir)
+    result: list[Path] = []
+    for entry in sorted(base_dir.iterdir()):
+        if not entry.is_dir():  # pragma: no cover
+            continue
+        if all(f.is_file() for f in entry.iterdir()):
+            result.append(entry)
+        else:
+            result.extend(discover_test_cases(entry))
+    return result
+
+
+def discover_test_files(
+    base_dir: str | Path, pattern: str = "*.py"
+) -> list[Path]:  # pragma: no cover
+    """Find files matching a glob pattern under base_dir.
+
+    Suitable for use with ``@pytest.mark.parametrize``.
+    Returns absolute paths sorted alphabetically.
+    """
+    base_dir = Path(base_dir)
+    return sorted(base_dir.rglob(pattern))

pytest_remaster/plugin.py

@@ -0,0 +1,54 @@
+"""Pytest plugin for golden master testing with automatic regeneration."""
+
+from __future__ import annotations  # pragma: no cover
+
+from typing import TYPE_CHECKING  # pragma: no cover
+
+import pytest  # pragma: no cover
+
+if TYPE_CHECKING:  # pragma: no cover
+    from pytest_remaster.core import GoldenMaster
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:  # pragma: no cover
+    group = parser.getgroup(
+        "remaster", "Golden master testing with automatic regeneration"
+    )
+    group.addoption(
+        "--remaster",
+        action="store_true",
+        dest="remaster",
+        default=None,
+        help="Regenerate golden master files when comparison fails.",
+    )
+    group.addoption(
+        "--no-remaster",
+        action="store_false",
+        dest="remaster",
+        help="Compare against golden master files without regenerating.",
+    )
+    parser.addini(
+        "remaster-by-default",
+        type="bool",
+        default=True,
+        help="Whether to regenerate golden master files by default (default: True).",
+    )
+
+
+@pytest.fixture  # pragma: no cover
+def remaster(request: pytest.FixtureRequest) -> bool:  # pragma: no cover
+    """Whether tests should regenerate golden master files."""
+    if (cli := request.config.getoption("remaster")) is not None:
+        return bool(cli)
+    result: bool = request.config.getini("remaster-by-default")
+    return result
+
+
+@pytest.fixture  # pragma: no cover
+def golden_master(
+    remaster: bool,  # pylint: disable=redefined-outer-name
+) -> GoldenMaster:  # pragma: no cover
+    """Golden master comparison fixture."""
+    from pytest_remaster.core import GoldenMaster  # pylint: disable=import-outside-toplevel
+
+    return GoldenMaster(remaster=remaster)

pytest_remaster-0.0.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: pytest-remaster
+Version: 0.0.0
+Summary: Golden master testing for pytest with automatic regeneration.
+Author: Pierre Sassoulas
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Pierre-Sassoulas/pytest-remaster
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=7
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pylint>4; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+[![PyPI version](https://badge.fury.io/py/pytest-remaster.svg)](https://badge.fury.io/py/pytest-remaster)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytest-remaster)](https://pypi.org/project/pytest-remaster/)
+[![PyPI - License](https://img.shields.io/pypi/l/pytest-remaster)](https://pypi.org/project/pytest-remaster/)
+
+# pytest-remaster
+
+Framework for golden master testing for pytest with automatic regeneration of the golden
+master.
+
+## Usage
+
+By default, golden master files are automatically regenerated when a comparison fails.
+Use `--no-remaster` to get strict failures instead.
+
+The default can be changed in `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+remaster-by-default = false
+```

pytest_remaster-0.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pytest_remaster/__init__.py,sha256=4SMDIcU8nsmnBdJSBCksm5B7-ddpRFfbwhZz-Bs0g2s,303
+pytest_remaster/core.py,sha256=PmVl6w1fPSDpJII2pdPargCJewr5iMlpm2TdXoDwPcU,5063
+pytest_remaster/plugin.py,sha256=XXgOavLi_07UAXBy3eHJn_fdmVrKD3ks6c9mnJ1vCPw,1737
+pytest_remaster-0.0.0.dist-info/licenses/LICENSE,sha256=Vjs_JOq3WNrBenjiN_uYE7PHRbDMgeVRqh5doPioyLI,1073
+pytest_remaster-0.0.0.dist-info/METADATA,sha256=Dc1SdRF7uYyWFJxpeIPmo7JrIcmA2KEUBMvL1c2KUmg,1790
+pytest_remaster-0.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pytest_remaster-0.0.0.dist-info/entry_points.txt,sha256=nDuTiytFZYTZJA_dqr_RaCP1kyQmq_ymuofhPBToibc,45
+pytest_remaster-0.0.0.dist-info/top_level.txt,sha256=8KgXdYqLwtFgKc6G9Ip9F79Vl4wt3HK4mlmrOF00hTs,16
+pytest_remaster-0.0.0.dist-info/RECORD,,

pytest_remaster-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytest_remaster-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+remaster = pytest_remaster.plugin

pytest_remaster-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pierre Sassoulas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_remaster-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_remaster