pytest-remaster 0.0.0__tar.gz

pytest_remaster-0.0.0/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [Pierre-Sassoulas]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: "pypi/pytest-remaster"
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: Pierre-Sassoulas
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

pytest_remaster-0.0.0/.github/SECURITY.md

@@ -0,0 +1,3 @@
+# Coordinated Disclosure Plan
+
+[Coordinated Disclosure Plan](https://tidelift.com/security)

pytest_remaster-0.0.0/.github/dependabot.yml

@@ -0,0 +1,15 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "monthly"
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "monthly"

pytest_remaster-0.0.0/.github/workflows/ci.yaml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request: ~
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15-dev"]
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - name: Python-${{ matrix.python-version }}
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: pip3 install -e ".[dev]"
+      - name: Test
+        run: pytest

pytest_remaster-0.0.0/.github/workflows/release.yaml

@@ -0,0 +1,65 @@
+name: Release
+
+on:
+  release:
+    types:
+      - published
+
+env:
+  DEFAULT_PYTHON: "3.13"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build release assets
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          check-latest: true
+      - run: python -m pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+        with:
+          name: release-assets
+          path: dist/
+
+  release-pypi:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    needs: ["build"]
+    environment:
+      name: PyPI
+      url: https://pypi.org/project/pytest-remaster/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: release-assets
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
+
+  release-github:
+    name: Upload assets to Github release
+    runs-on: ubuntu-latest
+    needs: ["build"]
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: release-assets
+          path: dist/
+      - uses: sigstore/gh-action-sigstore-python@a5caf349bc536fbef3668a10ed7f5cd309a4b53d # v3.2.0
+        if: github.event_name == 'release'
+        with:
+          inputs: |
+            ./dist/*.tar.gz
+            ./dist/*.whl

pytest_remaster-0.0.0/.gitignore

@@ -0,0 +1,4 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/

pytest_remaster-0.0.0/.pre-commit-config.yaml

@@ -0,0 +1,40 @@
+ci:
+  skip: [pylint]
+
+repos:
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: "v0.15.7"
+    hooks:
+      - id: ruff-check
+        args: ["--fix"]
+      - id: ruff-format
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-merge-conflict
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+      - id: end-of-file-fixer
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: "v2.20.0"
+    hooks:
+      - id: pyproject-fmt
+  - repo: local
+    hooks:
+      - id: pylint
+        name: pylint
+        entry: pylint
+        language: system
+        args: ["-sn", "-rn", "--enable-all-extensions"]
+        types: [python]
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.19.1
+    hooks:
+      - id: mypy
+        args: ["--strict"]
+        additional_dependencies: [pytest>=7.0]
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: v3.8.1
+    hooks:
+      - id: prettier
+        args: [--prose-wrap=always, --print-width=88]

pytest_remaster-0.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,20 @@
+[![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/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools>=77", "setuptools-scm>=8" ]
+
+[project]
+name = "pytest-remaster"
+description = "Golden master testing for pytest with automatic regeneration."
+readme = "README.md"
+license = "MIT"
+authors = [ { name = "Pierre Sassoulas" } ]
+requires-python = ">=3.9"
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Framework :: Pytest",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "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",
+  "Topic :: Software Development :: Testing",
+]
+dynamic = [ "version" ]
+dependencies = [ "pytest>=7" ]
+optional-dependencies.dev = [ "pre-commit", "pylint>4", "pytest-cov" ]
+urls.Homepage = "https://github.com/Pierre-Sassoulas/pytest-remaster"
+entry-points.pytest11.remaster = "pytest_remaster.plugin"
+
+[tool.setuptools_scm]
+
+[tool.pylint]
+messages_control.disable = [
+  "magic-value-comparison",
+  "missing-docstring",
+  "duplicate-code",
+]
+
+[tool.pytest]
+ini_options.testpaths = [ "tests" ]
+ini_options.addopts = "--cov --cov-report=term-missing"
+
+[tool.coverage]
+run.source = [ "pytest_remaster" ]

pytest_remaster-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytest_remaster-0.0.0/src/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-0.0.0/src/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-0.0.0/src/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/src/pytest_remaster.egg-info/PKG-INFO

@@ -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/src/pytest_remaster.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+.gitignore
+.pre-commit-config.yaml
+LICENSE
+README.md
+pyproject.toml
+.github/FUNDING.yml
+.github/SECURITY.md
+.github/dependabot.yml
+.github/workflows/ci.yaml
+.github/workflows/release.yaml
+src/pytest_remaster/__init__.py
+src/pytest_remaster/core.py
+src/pytest_remaster/plugin.py
+src/pytest_remaster.egg-info/PKG-INFO
+src/pytest_remaster.egg-info/SOURCES.txt
+src/pytest_remaster.egg-info/dependency_links.txt
+src/pytest_remaster.egg-info/entry_points.txt
+src/pytest_remaster.egg-info/requires.txt
+src/pytest_remaster.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/test_core.py
+tests/test_plugin.py
+tests/demo/__init__.py
+tests/demo/chatbot.py
+tests/demo/test_chatbot.py
+tests/demo/cases/greet/goodbye/command
+tests/demo/cases/greet/goodbye/result_0
+tests/demo/cases/greet/goodbye/result_1
+tests/demo/cases/greet/hello/command
+tests/demo/cases/greet/hello/result_0
+tests/demo/cases/help/unknown-command/command
+tests/demo/cases/help/unknown-command/result_0
+tests/demo/cases/help/unknown-command/result_1

pytest_remaster-0.0.0/src/pytest_remaster.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytest_remaster-0.0.0/src/pytest_remaster.egg-info/entry_points.txt

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

pytest_remaster-0.0.0/src/pytest_remaster.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pytest>=7
+
+[dev]
+pre-commit
+pylint>4
+pytest-cov

pytest_remaster-0.0.0/src/pytest_remaster.egg-info/top_level.txt

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

pytest_remaster-0.0.0/tests/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ["pytester"]

pytest_remaster-0.0.0/tests/demo/cases/greet/goodbye/command

@@ -0,0 +1 @@
+goodbye Bob

pytest_remaster-0.0.0/tests/demo/cases/greet/goodbye/result_0

@@ -0,0 +1 @@
+[#general] :wave: Goodbye, Bob!

pytest_remaster-0.0.0/tests/demo/cases/greet/goodbye/result_1

@@ -0,0 +1 @@
+[#general] :door: Bob has left the chat.

pytest_remaster-0.0.0/tests/demo/cases/greet/hello/command

@@ -0,0 +1 @@
+hello Alice

pytest_remaster-0.0.0/tests/demo/cases/greet/hello/result_0

@@ -0,0 +1 @@
+[#general] :wave: Hello, Alice!

pytest_remaster-0.0.0/tests/demo/cases/help/unknown-command/command

@@ -0,0 +1 @@
+xyzzy

pytest_remaster-0.0.0/tests/demo/cases/help/unknown-command/result_0

@@ -0,0 +1 @@
+[#errors] :x: Unknown command: xyzzy

pytest_remaster-0.0.0/tests/demo/cases/help/unknown-command/result_1

@@ -0,0 +1 @@
+[#general] :info: Available commands: hello, goodbye

pytest_remaster-0.0.0/tests/demo/chatbot.py

@@ -0,0 +1,43 @@
+"""Fake Slack-like chatbot for demonstrating pytest-remaster."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ChatMessage:
+    channel: str
+    text: str
+    emoji: str | None = None
+
+    def __str__(self) -> str:
+        prefix = f"{self.emoji} " if self.emoji else ""
+        return f"[{self.channel}] {prefix}{self.text}"
+
+
+def handle_command(command: str) -> list[ChatMessage]:
+    """Process a chat command and return response messages."""
+    parts = command.split(maxsplit=1)
+    verb = parts[0] if parts else ""
+    arg = parts[1] if len(parts) > 1 else ""
+
+    if verb == "hello":
+        return [
+            ChatMessage(channel="#general", text=f"Hello, {arg}!", emoji=":wave:"),
+        ]
+    if verb == "goodbye":
+        return [
+            ChatMessage(channel="#general", text=f"Goodbye, {arg}!", emoji=":wave:"),
+            ChatMessage(
+                channel="#general", text=f"{arg} has left the chat.", emoji=":door:"
+            ),
+        ]
+    return [
+        ChatMessage(channel="#errors", text=f"Unknown command: {verb}", emoji=":x:"),
+        ChatMessage(
+            channel="#general",
+            text="Available commands: hello, goodbye",
+            emoji=":info:",
+        ),
+    ]

pytest_remaster-0.0.0/tests/demo/test_chatbot.py

@@ -0,0 +1,22 @@
+"""Demo test showing pytest-remaster with a fake chatbot."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from pytest_remaster import GoldenMaster, discover_test_cases
+from tests.demo.chatbot import handle_command
+
+CASES_DIR = Path(__file__).parent / "cases"
+
+
+@pytest.mark.parametrize(
+    "case",
+    discover_test_cases(CASES_DIR),
+    ids=[str(d.relative_to(CASES_DIR)) for d in discover_test_cases(CASES_DIR)],
+)
+def test_chatbot_response(case: Path, golden_master: GoldenMaster) -> None:
+    cmd = (case / "command").read_text().strip()
+    golden_master.check_all(lambda: handle_command(cmd), directory=case)

pytest_remaster-0.0.0/tests/test_core.py

@@ -0,0 +1,253 @@
+"""Tests for the core golden master logic."""
+
+from __future__ import annotations
+
+import pytest
+
+
+def test_check_match(pytester: pytest.Pytester) -> None:
+    """check() passes when actual matches expected."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_match(golden_master, tmp_path):
+            expected = tmp_path / "expected.txt"
+            expected.write_text("hello world\\n")
+            golden_master.check("hello world", expected)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_check_mismatch_remaster(pytester: pytest.Pytester) -> None:
+    """check() with remaster writes new content and fails."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_mismatch(golden_master, tmp_path):
+            expected = tmp_path / "expected.txt"
+            expected.write_text("old content\\n")
+            golden_master.check("new content", expected)
+        """
+    )
+    result = pytester.runpytest("--remaster")
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*updated*review and relaunch*"])
+
+
+def test_check_mismatch_no_remaster(pytester: pytest.Pytester) -> None:
+    """check() without remaster fails with diff."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_mismatch(golden_master, tmp_path):
+            expected = tmp_path / "expected.txt"
+            expected.write_text("old content\\n")
+            golden_master.check("new content", expected)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*mismatch*"])
+
+
+def test_check_missing_file_remaster(pytester: pytest.Pytester) -> None:
+    """check() with remaster creates missing file and fails."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_missing(golden_master, tmp_path):
+            expected = tmp_path / "expected.txt"
+            golden_master.check("new content", expected)
+        """
+    )
+    result = pytester.runpytest("--remaster")
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*created*review and relaunch*"])
+
+
+def test_check_missing_file_no_remaster(pytester: pytest.Pytester) -> None:
+    """check() without remaster fails when file missing."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_missing(golden_master, tmp_path):
+            expected = tmp_path / "expected.txt"
+            golden_master.check("new content", expected)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*does not exist*--remaster*"])
+
+
+def test_check_callable(pytester: pytest.Pytester) -> None:
+    """check() accepts a callable and calls it."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_callable(golden_master, tmp_path):
+            expected = tmp_path / "expected.txt"
+            expected.write_text("hello\\n")
+            golden_master.check(lambda: "hello", expected)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_check_serializer(pytester: pytest.Pytester) -> None:
+    """check() uses custom serializer."""
+    pytester.makepyfile(
+        """
+        import json
+        from pathlib import Path
+
+        def test_serializer(golden_master, tmp_path):
+            expected = tmp_path / "expected.json"
+            expected.write_text('{"key": "value"}\\n')
+            golden_master.check(
+                {"key": "value"}, expected,
+                serializer=lambda o: json.dumps(o, sort_keys=True),
+            )
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_check_all_match(pytester: pytest.Pytester) -> None:
+    """check_all() passes when all results match."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_match(golden_master, tmp_path):
+            (tmp_path / "result_0").write_text("first\\n")
+            (tmp_path / "result_1").write_text("second\\n")
+            golden_master.check_all("first", "second", directory=tmp_path)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_check_all_callable(pytester: pytest.Pytester) -> None:
+    """check_all() accepts a callable returning a list."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_callable(golden_master, tmp_path):
+            (tmp_path / "result_0").write_text("a\\n")
+            (tmp_path / "result_1").write_text("b\\n")
+            golden_master.check_all(lambda: ["a", "b"], directory=tmp_path)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_check_all_fewer_actuals_remaster(pytester: pytest.Pytester) -> None:
+    """check_all() with remaster removes extra result files."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_fewer(golden_master, tmp_path):
+            (tmp_path / "result_0").write_text("only\\n")
+            (tmp_path / "result_1").write_text("extra\\n")
+            golden_master.check_all("only", directory=tmp_path)
+        """
+    )
+    result = pytester.runpytest("--remaster")
+    # result_1 is removed, result_0 matches so no update needed
+    result.assert_outcomes(passed=1)
+
+
+def test_check_all_more_actuals_remaster(pytester: pytest.Pytester) -> None:
+    """check_all() with remaster creates new result files."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_more(golden_master, tmp_path):
+            (tmp_path / "result_0").write_text("first\\n")
+            golden_master.check_all("first", "second", directory=tmp_path)
+        """
+    )
+    result = pytester.runpytest("--remaster")
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*created*"])
+
+
+def test_check_all_count_mismatch_no_remaster(pytester: pytest.Pytester) -> None:
+    """check_all() without remaster fails on count mismatch."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+
+        def test_count(golden_master, tmp_path):
+            (tmp_path / "result_0").write_text("first\\n")
+            (tmp_path / "result_1").write_text("second\\n")
+            (tmp_path / "result_2").write_text("third\\n")
+            golden_master.check_all("first", directory=tmp_path)
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(failed=1)
+    result.stdout.fnmatch_lines(["*Expected 3 results but got 1*"])
+
+
+def test_discover_test_cases(pytester: pytest.Pytester) -> None:
+    """discover_test_cases() finds leaf directories."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+        from pytest_remaster import discover_test_cases
+
+        def test_discover(tmp_path):
+            # Create hierarchy: base/a/case1/ and base/a/case2/ and base/b/
+            (tmp_path / "a" / "case1").mkdir(parents=True)
+            (tmp_path / "a" / "case1" / "command").write_text("hello")
+            (tmp_path / "a" / "case2").mkdir(parents=True)
+            (tmp_path / "a" / "case2" / "command").write_text("bye")
+            (tmp_path / "b").mkdir()
+            (tmp_path / "b" / "command").write_text("help")
+
+            cases = discover_test_cases(tmp_path)
+            names = [c.name for c in cases]
+            assert sorted(names) == ["b", "case1", "case2"]
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_discover_test_files(pytester: pytest.Pytester) -> None:
+    """discover_test_files() finds files matching a pattern."""
+    pytester.makepyfile(
+        """
+        from pathlib import Path
+        from pytest_remaster import discover_test_files
+
+        def test_discover(tmp_path):
+            (tmp_path / "a.py").write_text("pass")
+            (tmp_path / "b.txt").write_text("hello")
+            (tmp_path / "sub").mkdir()
+            (tmp_path / "sub" / "c.py").write_text("pass")
+
+            py_files = discover_test_files(tmp_path, "*.py")
+            names = [f.name for f in py_files]
+            assert sorted(names) == ["a.py", "c.py"]
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)

pytest_remaster-0.0.0/tests/test_plugin.py

@@ -0,0 +1,95 @@
+"""Basic tests for the pytest-remaster plugin."""
+
+from __future__ import annotations
+
+import pytest
+
+
+def test_remaster_option_default(pytester: pytest.Pytester) -> None:
+    """The --remaster CLI option defaults to None (falls back to ini)."""
+    pytester.makepyfile(
+        """
+        def test_default(pytestconfig):
+            assert pytestconfig.getoption("remaster") is None
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_remaster_ini_default(pytester: pytest.Pytester) -> None:
+    """The remaster-by-default ini option defaults to True."""
+    pytester.makepyfile(
+        """
+        def test_ini(pytestconfig):
+            assert pytestconfig.getini("remaster-by-default") is True
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_remaster_flag_enables(pytester: pytest.Pytester) -> None:
+    """Passing --remaster sets the option to True."""
+    pytester.makepyfile(
+        """
+        def test_flag(pytestconfig):
+            assert pytestconfig.getoption("remaster") is True
+        """
+    )
+    result = pytester.runpytest("--remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_no_remaster_flag_disables(pytester: pytest.Pytester) -> None:
+    """Passing --no-remaster sets the option to False."""
+    pytester.makepyfile(
+        """
+        def test_flag(pytestconfig):
+            assert pytestconfig.getoption("remaster") is False
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_remaster_fixture(pytester: pytest.Pytester) -> None:
+    """The remaster fixture resolves CLI > ini correctly."""
+    pytester.makepyfile(
+        """
+        def test_fixture_default(remaster):
+            assert remaster is True
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+
+
+def test_remaster_fixture_no_remaster(pytester: pytest.Pytester) -> None:
+    """The remaster fixture returns False with --no-remaster."""
+    pytester.makepyfile(
+        """
+        def test_fixture_off(remaster):
+            assert remaster is False
+        """
+    )
+    result = pytester.runpytest("--no-remaster")
+    result.assert_outcomes(passed=1)
+
+
+def test_remaster_ini_override(pytester: pytest.Pytester) -> None:
+    """Setting remaster-by-default=false in ini changes the default."""
+    pytester.makeini(
+        """
+        [pytest]
+        remaster-by-default = false
+        """
+    )
+    pytester.makepyfile(
+        """
+        def test_fixture_ini_false(remaster):
+            assert remaster is False
+        """
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)