pytest-ditto 0.0.1__tar.gz

pytest_ditto-0.0.1/.gitignore

@@ -0,0 +1,12 @@
+.ditto
+
+.pytest_cache
+__pycache__
+*.egg-info
+
+venv*
+
+.idea/
+.vscode/
+
+dist/

pytest_ditto-0.0.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.3
+Name: pytest-ditto
+Version: 0.0.1
+Author-email: Lachlan Taylor <lachlanbtaylor@proton.me>
+Maintainer-email: Lachlan Taylor <lachlanbtaylor@proton.me>
+License-Expression: MIT
+Keywords: pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: pandas
+Requires-Dist: pyarrow
+Requires-Dist: pytest>=3.5.0
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: hatch-vcs>=0.4.0; extra == 'dev'
+Requires-Dist: hatch>=1.9.4; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pytest-ditto

pytest_ditto-0.0.1/README.md

@@ -0,0 +1 @@
+# pytest-ditto

pytest_ditto-0.0.1/ditto/__init__.py

@@ -0,0 +1,6 @@
+import pytest
+
+from ditto.snapshot import Snapshot
+from ditto._unittest import DittoTestCase
+
+record = pytest.mark.record

pytest_ditto-0.0.1/ditto/_unittest.py

@@ -0,0 +1,29 @@
+import unittest
+import inspect
+from typing import ClassVar
+from pathlib import Path
+
+from ditto.snapshot import Snapshot
+
+
+def _calling_test_path() -> Path:
+    frame = inspect.currentframe()
+    outer_frames = inspect.getouterframes(frame)
+    # 2 calls back up the stack, index 1 of the frame has the calling filepath
+    return Path(outer_frames[2][1]).parent
+
+
+class DittoTestCase(unittest.TestCase):
+
+    record: ClassVar[bool] = True
+
+    @property
+    def snapshot(self) -> Snapshot:
+        path = _calling_test_path() / ".ditto"
+        path.mkdir(exist_ok=True)
+
+        return Snapshot(
+            path=path,
+            name=".".join(self.id().split(".")[-3:]),
+            record=self.record,
+        )

pytest_ditto-0.0.1/ditto/_version.py

@@ -0,0 +1 @@
+__version__ = '0.0.1'

pytest_ditto-0.0.1/ditto/io/__init__.py

@@ -0,0 +1,37 @@
+from ditto.io.protocol import SnapshotIO
+from ditto.io._yaml import YamlIO
+from ditto.io._json import JsonIO
+from ditto.io._pickle import PickleIO
+from ditto.io._pandas_parquet import PandasParquetIO
+
+
+__all__ = [
+    "SnapshotIO",
+    "YamlIO",
+    "JsonIO",
+    "PickleIO",
+    "PandasParquetIO",
+    "register",
+    "get",
+    "default",
+]
+
+
+_NAME_IO_MAP: dict[str, type[SnapshotIO]] = {
+    "pkl": PickleIO,
+    "json": JsonIO,
+    "yaml": YamlIO,
+    "pandas_parquet": PandasParquetIO,
+}
+
+
+def register(name: str, io: type[SnapshotIO]) -> None:
+    _NAME_IO_MAP[name] = io
+
+
+def get(name: str, default: SnapshotIO = PickleIO) -> SnapshotIO:
+    return _NAME_IO_MAP.get(name, default)
+
+
+def default() -> type[SnapshotIO]:
+    return PickleIO

pytest_ditto-0.0.1/ditto/io/_json.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from typing import ClassVar, Any
+
+import json
+
+
+class JsonIO:
+    extension: ClassVar[str] = "json"
+
+    @staticmethod
+    def save(data: Any, filepath: Path) -> None:
+        with open(filepath, "w") as f:
+            json.dump(data, f)
+
+    @staticmethod
+    def load(filepath: Path) -> Any:
+        with open(filepath, "r") as f:
+            return json.load(f)

pytest_ditto-0.0.1/ditto/io/_pandas_parquet.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from typing import ClassVar
+
+import pandas as pd
+
+from ditto.io.protocol import SnapshotIO
+
+
+class PandasParquetIO(SnapshotIO):
+    extension: ClassVar[str] = "parquet"
+
+    @staticmethod
+    def save(data: pd.DataFrame, filepath: Path) -> None:
+        data.to_parquet(filepath)
+
+    @staticmethod
+    def load(filepath: Path) -> pd.DataFrame:
+        return pd.read_parquet(filepath)

pytest_ditto-0.0.1/ditto/io/_pickle.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import ClassVar, Any
+
+import pickle
+
+from ditto.io import SnapshotIO
+
+
+class PickleIO(SnapshotIO):
+    extension: ClassVar[str] = "pkl"
+
+    @staticmethod
+    def save(data: Any, filepath: Path) -> None:
+        with open(filepath, "wb") as f:
+            pickle.dump(data, f)
+
+    @staticmethod
+    def load(filepath: Path) -> Any:
+        with open(filepath, "rb") as f:
+            return pickle.load(f)

pytest_ditto-0.0.1/ditto/io/_yaml.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from typing import ClassVar, Any
+
+import yaml
+
+
+class YamlIO:
+    extension: ClassVar[str] = "yaml"
+
+    @staticmethod
+    def save(data: Any, filepath: Path) -> None:
+        with open(filepath, "w") as f:
+            yaml.dump(data, f, Dumper=yaml.SafeDumper)
+
+    @staticmethod
+    def load(filepath: Path) -> Any:
+        with open(filepath, "r") as f:
+            return yaml.load(f, Loader=yaml.SafeLoader)

pytest_ditto-0.0.1/ditto/io/protocol.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+from typing import ClassVar, Any, Protocol
+
+
+# TODO: maybe use abstract base class instead
+class SnapshotIO(Protocol):
+    extension: ClassVar[str]
+
+    @staticmethod
+    def save(data: Any, filepath: Path) -> None: ...
+
+    @staticmethod
+    def load(filepath: Path) -> Any: ...

pytest_ditto-0.0.1/ditto/plugin.py

@@ -0,0 +1,71 @@
+from typing import Any
+
+import pytest
+
+from ditto.snapshot import Snapshot
+from ditto import io
+
+
+@pytest.fixture(scope="function")
+def snapshot(request) -> Snapshot:
+
+    io_name = None
+    parameters = {}
+    for mark in request.node.iter_markers(name="record"):
+        if mark.args:
+            if io_name is not None:
+                pytest.fail("Only one 'record' mark is allowed.")
+            io_name = mark.args[0]
+
+        if mark.kwargs:
+            parameters.update(mark.kwargs)
+
+    io_name = io_name if io_name is not None else "pkl"
+
+    # TODO: do i like this?
+    # if io_name is None:
+    #     pytest.fail("'record' is a required mark when using the 'snapshot' fixture.")
+
+    path = request.path.parent / ".ditto"
+    path.mkdir(exist_ok=True)
+
+    # Get the snapshot identifier from the 'record' mark parameters (via kwargs) if it
+    # exists; otherwise, use the test function name.
+    identifier = parameters.get("identifier", request.node.name)
+
+    return Snapshot(
+        path=path,
+        name=identifier,
+        # record=True,
+        io=io.get(io_name, default=io.PickleIO),
+    )
+
+
+def pytest_configure(config):
+    # register an additional marker
+    config.addinivalue_line("markers", "record(io): snapshot values")
+
+
+# def pytest_runtest_setup(item):
+#     # envnames = [mark.args[0] for mark in item.iter_markers(name="env")]
+#     # if envnames:
+#     #     if item.config.getoption("-E") not in envnames:
+#     #         pytest.skip("test requires env in {!r}".format(envnames))
+#     #
+#     for mark in item.iter_markers(name="record"):
+#         msg =f"recording: args={mark.args}; kwargs={mark.kwargs}"
+#
+#         path = item.path.parent / ".ditto"
+#         name = mark.kwargs.get("identifier", mark.name)
+#         identifier = mark.kwargs.get("identifier")
+#         io_name = next(iter(mark.args))
+#
+#         snapshot = Snapshot(
+#             path=path,
+#             name=name,
+#             record=False,
+#             io=io.get(io_name, default=io.PickleIO),
+#             identifier=identifier,
+#         )
+#         if not snapshot.filepath(identifier=identifier).exists():
+#             pytest.skip(msg)

pytest_ditto-0.0.1/ditto/snapshot.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+from typing import Any
+import pytest
+
+from ditto import io
+
+
+class Snapshot:
+
+    data: Any | None
+
+    def __init__(
+        self,
+        path: Path,
+        name: str,
+        record: bool = False,
+        io: io.SnapshotIO = io.PickleIO,
+        identifier: str | None = None,
+    ) -> None:
+        self.path = path
+        self.name = name
+        self.record = record
+        self.io = io if io is not None else io.default()
+        self.identifier = identifier
+        self.data = None
+
+    def filepath(self, identifier: str | None = None) -> Path:
+        identifier = identifier if identifier is not None else ""
+        identifier = f"{self.name}@{identifier}" if identifier else self.name
+        return self.path / f"{identifier}.{self.io.extension}"
+
+    def _save(self, data: Any, identifier: str | None = None) -> None:
+        identifier = identifier if identifier is not None else ""
+        self.io.save(data, self.filepath(identifier))
+
+    def _load(self, identifier: str | None = None) -> Any:
+        identifier = identifier if identifier is not None else ""
+        return self.io.load(self.filepath(identifier))
+
+    def __call__(self, data: Any, identifier: str | None = None) -> Any:
+        # If the snapshot data exists, and we are not recording, load the data from the
+        # snapshot file; otherwise, save the data to the snapshot file.
+
+        # TODO: At the moment there is no way to re-record snapshots. The approach is to
+        #  manually delete the snapshot files and re-run the tests. Using another mark,
+        #  e.g., 'record' might be a good way to do this?
+        if self.filepath(identifier).exists():
+            self.data = self._load(identifier)
+
+        else:
+            self._save(data, identifier)
+            self.data = data
+
+            _msg = (
+                f"\nNo snapshot found: {identifier=}"
+                f"\nRecoding new snapshot to {self.filepath(identifier)!r}. "
+                "\nRun again to test with recorded snapshot."
+            )
+
+            # FIXME: For tests that contain multiple snapshots, when initially recording
+            #  the snapshot files, this call to pytest.skip results in the test exiting
+            #  early and the remaining snapshots to remain unsaved. This means we need
+            #  to run the test N times to get all snapshot files saved, where N is the
+            #  number of snapshot calls in the test.
+            pytest.skip(_msg)
+
+        return self.data
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__.lower()}({self.data.__repr__()})"
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__.lower()}({self.data.__str__()})"

pytest_ditto-0.0.1/pyproject.toml

@@ -0,0 +1,166 @@
+[project]
+name = "pytest-ditto"
+dynamic = [
+    "version",
+]
+description = ""
+keywords = ["pytest"]
+authors = [{ name = "Lachlan Taylor", email = "lachlanbtaylor@proton.me" }]
+maintainers = [{ name = "Lachlan Taylor", email = "lachlanbtaylor@proton.me" }]
+requires-python = ">=3.10"
+license = "MIT"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Software Development :: Testing",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "pytest>=3.5.0",
+    "pyyaml",
+    "pandas",
+    "pyarrow",
+]
+[project.optional-dependencies]
+dev = [
+    "pre-commit",
+    "hatch>=1.9.4",
+    "hatch-vcs>=0.4.0",
+]
+
+[project.entry-points.pytest11]
+recording = "ditto.plugin"
+
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+
+[tool.hatch.build]
+hooks.vcs.version-file = "ditto/_version.py"
+hooks.vcs.template = "__version__ = {version!r}"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ditto"]
+strict-naming = false
+
+[tool.hatch.build.targets.sdist]
+packages = ["ditto"]
+strict-naming = false
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.envs.default]
+python = "3.10"
+dependencies = [
+  "pytest",
+]
+
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+
+[[tool.hatch.envs.all.matrix]]
+python = ["3.10", "3.11", "3.12"]
+
+
+[tool.pytest.ini_options]
+testpaths = "tests"
+filterwarnings = [
+    # "error",
+    "ignore::UserWarning",
+    # note the use of single quote below to denote "raw" strings in TOML
+    'ignore::DeprecationWarning',
+]
+
+
+[tool.black]
+line-length = 88
+target-version = ['py38', 'py39', 'py310', 'py311', 'py312']
+exclude = '''
+# A regex preceded with ^/ will apply only to files and directories
+# in the root of the project.
+^/(
+  (
+      \.eggs
+    | \.git
+    | \.pytest_cache
+    | \.vscode
+    | \.mypy_cache
+    | __pycache__
+    | _cache
+    | app_data
+    | logs
+    | venv
+    | build
+    | dist
+  )/
+)
+'''
+
+[tool.coverage.run]
+branch = true
+source = ["ditto"]
+
+[tool.coverage.report]
+show_missing = true
+fail_under = 80
+
+[tool.ruff]
+line-length = 88  # same as Black.
+target-version = "py310"
+
+[tool.ruff.lint]
+# Enable the following rule sets:
+# pycodestyle (`E`) https://docs.astral.sh/ruff/rules/#pyflakes-f
+# Pyflakes (`F`) https://docs.astral.sh/ruff/rules/#pyflakes-f
+# flake8-bugbear (B) https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
+# flake8-simplify (SIM) https://docs.astral.sh/ruff/rules/#flake8-simplify-sim
+# flake8-quotes (Q) https://docs.astral.sh/ruff/rules/#flake8-quotes-q
+select = ["E", "F", "C90", "B", "SIM"]
+extend-select = ["Q"]
+ignore = []
+# F401 - imported but unused
+# F841 - local variable assigned but never used
+# SIM300 - Yoda conditions are discouraged
+extend-ignore = ["F401", "F841", "SIM300"]
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+fixable = ["A", "B", "C", "D", "E", "F"]
+unfixable = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+
+mccabe.max-complexity = 5