pytest-results 0.1.0__py3-none-any.whl

pytest_results/__init__.py

@@ -0,0 +1,13 @@
+from ._core.assert_results_match import AssertResultsMatch, AssertResultsMatchType
+from ._core.dumpers.abc import Dumper, JSONDumper
+from ._core.storages.abc import Storage
+from ._core.storages.local import LocalStorage
+
+__all__ = (
+    "AssertResultsMatch",
+    "AssertResultsMatchType",
+    "Dumper",
+    "JSONDumper",
+    "Storage",
+    "LocalStorage",
+)

pytest_results/_core/assert_results_match.py

@@ -0,0 +1,77 @@
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from functools import singledispatch
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+import pytest
+
+from pytest_results._core.dumpers.abc import Dumper
+from pytest_results._core.dumpers.json import SimpleJSONDumper
+from pytest_results._core.storages.abc import Storage
+from pytest_results.exceptions import ResultsMismatchError
+
+type AssertResultsMatchType = _AssertResultsMatch[Any]
+
+
+@runtime_checkable
+class _AssertResultsMatch[T](Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def __call__(self, current_result: T, /, file_suffix: str = ...) -> None:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class AssertResultsMatch[T](_AssertResultsMatch[T]):
+    request: pytest.FixtureRequest
+    storage: Storage
+    dumper: Dumper[T] | None = field(default=None)
+
+    def __call__(self, current_result: T, /, file_suffix: str = "") -> None:
+        dumper = self.dumper or select_dumper_from(current_result)
+        storage = self.storage
+
+        current_bytes = dumper.dump(current_result)
+        relative_filepath = self.__get_relative_result_filepath(
+            dumper.file_format,
+            file_suffix,
+        )
+        filepath = storage.get_absolute_path(relative_filepath)
+        previous_bytes = storage.read(filepath)
+
+        try:
+            assert current_bytes == previous_bytes
+
+        except AssertionError as exc:
+            temporary_filepath = storage.get_temporary_path(relative_filepath)
+            storage.write(temporary_filepath, current_bytes)
+            raise ResultsMismatchError(temporary_filepath, filepath, storage) from exc
+
+    def __get_relative_result_filepath(self, file_format: str, suffix: str) -> Path:
+        request = self.request
+        segments = request.module.__name__.split(".")
+
+        if cls := request.cls:
+            segments.append(cls.__name__)
+
+        segments.append(f"{request.function.__name__}{suffix}.{file_format}")
+        return Path(*segments)
+
+
+@singledispatch
+def select_dumper_from(value: Any) -> Dumper[Any]:
+    return SimpleJSONDumper()
+
+
+try:
+    from pydantic import BaseModel
+except ImportError:  # pragma: no cover
+    ...
+else:
+    from pytest_results._core.dumpers.pydantic import PydanticJSONDumper
+
+    @select_dumper_from.register
+    def _(value: BaseModel) -> Dumper[BaseModel]:
+        return PydanticJSONDumper()

pytest_results/_core/dumpers/abc.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Dumper[T](Protocol):
+    __slots__ = ()
+
+    file_format: str
+
+    @abstractmethod
+    def dump(self, value: T) -> bytes:
+        raise NotImplementedError
+
+
+class JSONDumper[T](Dumper[T], ABC):
+    __slots__ = ()
+
+    file_format: str = "json"

pytest_results/_core/dumpers/json.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+import orjson
+
+from pytest_results._core.dumpers.abc import JSONDumper
+
+
+class SimpleJSONDumper(JSONDumper[Any]):
+    __slots__ = ()
+
+    def dump(self, value: Any) -> bytes:
+        return orjson.dumps(value, default=str, option=orjson.OPT_INDENT_2)

pytest_results/_core/dumpers/pydantic.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+from pytest_results._core.dumpers.abc import JSONDumper
+
+
+class PydanticJSONDumper(JSONDumper[BaseModel]):
+    __slots__ = ()
+
+    def dump(self, value: BaseModel) -> bytes:
+        return value.model_dump_json(indent=2).encode()

pytest_results/_core/storages/abc.py

@@ -0,0 +1,32 @@
+from abc import abstractmethod
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Storage(Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def copy(self, filepath: Path, destination: Path) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def exists(self, path: Path) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_absolute_path(self, relative_path: Path) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_temporary_path(self, relative_path: Path) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def read(self, filepath: Path) -> bytes:
+        raise NotImplementedError
+
+    @abstractmethod
+    def write(self, filepath: Path, result: bytes = ...) -> None:
+        raise NotImplementedError

pytest_results/_core/storages/local.py

@@ -0,0 +1,43 @@
+import os
+import shutil
+from contextlib import suppress
+from dataclasses import dataclass
+from pathlib import Path
+
+from pytest_results._core.storages.abc import Storage
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class LocalStorage(Storage):
+    dir: Path
+    temporary_dir: Path
+
+    def copy(self, filepath: Path, destination: Path) -> None:
+        shutil.copyfile(filepath, destination)
+
+    def exists(self, path: Path) -> bool:
+        return path.exists()
+
+    def get_absolute_path(self, relative_path: Path) -> Path:
+        return self.__get_absolute_path(relative_path, self.dir)
+
+    def get_temporary_path(self, relative_path: Path) -> Path:
+        return self.__get_absolute_path(relative_path, self.temporary_dir)
+
+    def read(self, filepath: Path) -> bytes:
+        with suppress(FileNotFoundError):
+            with open(filepath, "rb") as reader:
+                return reader.read()
+
+        return b""
+
+    def write(self, filepath: Path, result: bytes = b"") -> None:
+        os.makedirs(filepath.parent, exist_ok=True)
+
+        with open(filepath, "wb") as writer:
+            writer.write(result)
+
+    @staticmethod
+    def __get_absolute_path(filepath: Path, directory: Path) -> Path:
+        assert not filepath.is_absolute()
+        return directory / filepath

pytest_results/contrib/pytest/plugin.py

@@ -0,0 +1,127 @@
+import warnings
+from collections.abc import Generator, Iterator, Mapping
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import ClassVar
+
+from pytest import Config, FixtureRequest, Function, Parser, fixture, hookimpl
+
+from pytest_results import AssertResultsMatch, AssertResultsMatchType, LocalStorage
+from pytest_results.exceptions import ResultsMismatchError
+
+__all__ = ()
+
+
+def pytest_addoption(parser: Parser) -> None:
+    group = parser.getgroup("pytest-results")
+
+    group.addoption(
+        "--accept-all-diff",
+        dest="accept_all_diff",
+        action="store_true",
+        help="Parameter for accepting new differences between results.",
+        default=False,
+    )
+
+    diff_help = "Command line to open an interactive comparison. Example: `code -d -w {current} {previous}`."
+    group.addoption(
+        "--diff",
+        dest="diff",
+        metavar="COMMAND_LINE",
+        help=diff_help,
+        default=None,
+    )
+    parser.addini(
+        "diff",
+        type="string",
+        help=diff_help,
+        default=None,
+    )
+
+    ide_help = "The IDE to open for interactive comparison."
+    group.addoption(
+        "--ide",
+        dest="ide",
+        metavar="IDE",
+        help=ide_help,
+        default=None,
+    )
+    parser.addini(
+        "ide",
+        type="string",
+        help=ide_help,
+        default=None,
+    )
+
+
+@hookimpl(wrapper=True)
+def pytest_pyfunc_call(
+    pyfuncitem: Function,
+) -> Generator[None, object | None, object | None]:
+    try:
+        result = yield
+    except ResultsMismatchError as mismatch:
+        config = PytestResultsConfig(pyfuncitem.config)
+
+        if config.accept_all_diff:
+            mismatch.accept_diff()
+            return None
+
+        if command := config.diff_command:
+            mismatch.show_diff(command)
+
+        raise mismatch
+
+    return result
+
+
+@fixture(scope="session")
+def _pytest_results_tmpdir() -> Iterator[Path]:
+    with TemporaryDirectory(prefix="pytest-temporary-results@") as tmpdir:
+        yield Path(tmpdir)
+
+
+@fixture(scope="function")
+def assert_results_match(
+    request: FixtureRequest,
+    _pytest_results_tmpdir: Path,
+) -> AssertResultsMatchType:
+    results_dir = request.config.rootpath / "__pytest_results__"
+    storage = LocalStorage(results_dir, _pytest_results_tmpdir)
+    return AssertResultsMatch(request, storage)
+
+
+class PytestResultsConfig:
+    __slots__ = ("__config",)
+
+    __diff_commands: ClassVar[Mapping[str, str]] = {
+        "cursor": "cursor -d -r -w {current} {previous}",
+        "pycharm": "pycharm diff {current} {previous}",
+        "vscode": "code -d -r -w {current} {previous}",
+    }
+
+    def __init__(self, pytest_config: Config) -> None:
+        self.__config = pytest_config
+
+    @property
+    def accept_all_diff(self) -> bool:
+        return self.__config.getoption("accept_all_diff")
+
+    @property
+    def diff_command(self) -> str | None:
+        if diff := self.__get_option_or_ini("diff"):
+            return diff
+
+        if ide := self.__get_option_or_ini("ide"):
+            lowercase_ide = ide.lower()
+
+            try:
+                return self.__diff_commands[lowercase_ide]
+            except KeyError:
+                warnings.warn(f"pytest-results doesn't yet support the `{ide}` IDE.")
+
+        return None
+
+    def __get_option_or_ini[T](self, key: str) -> T | None:
+        config = self.__config
+        return config.getoption(key, default=config.getini(key))

pytest_results/exceptions.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pytest_results import Storage
+
+__all__ = ("PytestResultsError", "ResultsMismatchError")
+
+
+class PytestResultsError(Exception): ...
+
+
+@dataclass(slots=True)
+class ResultsMismatchError(AssertionError, PytestResultsError):
+    current_filepath: Path
+    previous_filepath: Path
+    storage: Storage = field(repr=False)
+
+    def __str__(self) -> str:
+        return self.__to_string(self.current_filepath, self.previous_filepath)
+
+    def accept_diff(self) -> None:
+        self.__ensure_file_exists(self.previous_filepath)
+        self.storage.copy(self.current_filepath, self.previous_filepath)
+
+    def show_diff(self, command: str) -> None:
+        self.__ensure_file_exists(self.previous_filepath)
+        command = command.format(
+            current=self.current_filepath,
+            previous=self.previous_filepath,
+        )
+        os.system(command)
+        time.sleep(1)
+
+    def __ensure_file_exists(self, filepath: Path) -> None:
+        if self.storage.exists(filepath):
+            return
+
+        self.storage.write(filepath)
+
+    @staticmethod
+    def __to_string(current: object, previous: object) -> str:
+        return f"Results mismatch\n・Current: `{current}`\n・Previous: `{previous}`"

pytest_results-0.1.0.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: pytest-results
+Version: 0.1.0
+Summary: Easily spot regressions in your tests.
+Project-URL: Repository, https://github.com/100nm/pytest-results
+Author: remimd
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.12
+Requires-Dist: orjson
+Requires-Dist: pytest
+Description-Content-Type: text/markdown
+
+# pytest-results
+
+[![CI](https://github.com/100nm/pytest-results/actions/workflows/ci.yml/badge.svg)](https://github.com/100nm/pytest-results)
+[![PyPI](https://img.shields.io/pypi/v/pytest-results.svg?color=blue)](https://pypi.org/project/pytest-results/)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+Easily spot regressions in your tests.
+
+The package lets you write non-regression tests.
+
+## Installation
+
+⚠️ _Requires Python 3.12 or higher_
+
+```bash
+pip install pytest-results
+```
+
+## Quick start
+
+First, retrieve the Pytest fixture `assert_results_match` in your test:
+
+```python
+def test_function(assert_results_match):
+    result = {"hello": "world"}
+    assert_results_match(result)
+```
+
+All results are stored in JSON files at the root of your project in the
+`__pytest_results__` folder.
+
+In case of regression, to open the interactive comparison, add the `--ide` parameter
+to Pytest with the name of your IDE:
+
+```bash
+pytest --ide vscode
+```
+
+_At present, the IDEs supported are `cursor`, `pycharm` and `vscode`._
+
+## Resources
+
+* [**assert_results_match fixture**](https://github.com/100nm/pytest-results/tree/prod/documentation/assert-results-match-fixture.md)
+* [**Configuration**](https://github.com/100nm/pytest-results/tree/prod/documentation/configuration.md)

pytest_results-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+pytest_results/__init__.py,sha256=7RPavMSYUhkvn5_4k0PWJFRILCuwTr5pEY3dZAi2PAg,358
+pytest_results/exceptions.py,sha256=78vjEIk_gWF2fl5_oH0lLEgjssO1lsmT6i-PDGuRxCc,1394
+pytest_results/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_results/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_results/_core/assert_results_match.py,sha256=UvQspBtdE9yHFPk6vKxnoyhytJTEbz3TfjC7KCYhtmc,2466
+pytest_results/_core/dumpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_results/_core/dumpers/abc.py,sha256=dMy1waEDsTyN9tkcZ-PDNDv6seyrdm3RFnok2a1diY0,355
+pytest_results/_core/dumpers/json.py,sha256=9cg2QQlGeHGrPgVHkRR9mksu9u9Orr2WAnfBG9ZlIlo,275
+pytest_results/_core/dumpers/pydantic.py,sha256=mvdma7H6IKy7aod8IomzAQy2OWn2_MxUL724_qTl9l0,262
+pytest_results/_core/storages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_results/_core/storages/abc.py,sha256=Cl1yDa9ySJe2okFyRLlu4UmaUytT8izmAzpxMKx0bYs,839
+pytest_results/_core/storages/local.py,sha256=9R47caGzlNhT3G73k_7BGjD8ooEG5H-5-JxN_4Hbc5A,1306
+pytest_results/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_results/contrib/pytest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_results/contrib/pytest/plugin.py,sha256=BAQkgrNMVBnrPyBftz9eJkfw2zETDPg8ju8bOyUaydI,3455
+pytest_results-0.1.0.dist-info/METADATA,sha256=RLeNSVgFnNA_kXpv4ZMGS4mfKoTt0MWUCXnS5ijVWzM,2235
+pytest_results-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pytest_results-0.1.0.dist-info/entry_points.txt,sha256=iOHso0eGj305_uM2hcsLwSKhrJKEytoIlso7Qaoey20,65
+pytest_results-0.1.0.dist-info/RECORD,,

pytest_results-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pytest_results-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+pytest-results = pytest_results.contrib.pytest.plugin