pytest-expected-json 0.1.0__py3-none-any.whl

pytest_expected_json/__init__.py

@@ -0,0 +1,15 @@
+"""Pytest expected data fixture for loading test data from JSON files."""
+
+from pytest_expected_json.fixture import (
+    ExpectedJsonConfig,
+    create_expected_json_config_fixture,
+    expected_data,
+    expected_json_config,
+)
+
+__all__ = [
+    "ExpectedJsonConfig",
+    "create_expected_json_config_fixture",
+    "expected_data",
+    "expected_json_config",
+]

pytest_expected_json/fixture.py

@@ -0,0 +1,102 @@
+"""Pytest fixture for loading expected test data from JSON files."""
+
+import json
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal, cast
+
+import pytest
+
+JsonType = dict[str, Any] | list[Any] | str | int | float | bool | None
+FixtureScope = Literal["function", "class", "module", "package", "session"]
+
+
+@dataclass
+class ExpectedJsonConfig:
+    """Configuration for the expected_data fixture."""
+
+    assets_dir: Path = Path("assets")
+
+
+def create_expected_json_config_fixture(
+    config: ExpectedJsonConfig | None = None, *, scope: FixtureScope = "session"
+) -> Callable[[], ExpectedJsonConfig]:
+    """
+    Create a fixture that returns config used by the expected_data fixture.
+
+    Override this fixture in a project to provide custom configuration.
+    """
+
+    def fixture() -> ExpectedJsonConfig:
+        """Provide configuration consumed by the expected_data fixture."""
+        return config or ExpectedJsonConfig()
+
+    decorated_fixture = pytest.fixture(scope=cast(Any, scope))(fixture)
+    return cast(Callable[[], ExpectedJsonConfig], decorated_fixture)
+
+
+expected_json_config = create_expected_json_config_fixture()
+
+
+@pytest.fixture()
+def expected_data(
+    request: pytest.FixtureRequest, expected_json_config: ExpectedJsonConfig
+) -> JsonType:
+    """
+    Load the expected data from a JSON file based on the test location and name.
+
+    The fixture automatically constructs a filename from the test module
+    and function name. If a parametrized test is used, the parameter
+    is appended to the filename.
+
+    File naming convention:
+        {module_name}__{test_name}__{original_name}[@{param}].json
+
+    Example:
+        For test `test_health.py::test_get_health`, the fixture looks for:
+        tests/assets/saved/tests_app__test_health__test_get_health.json
+
+    Args:
+        request: Pytest request object containing test information.
+        expected_json_config: Fixture-provided configuration for asset lookup
+            and fallback behavior.
+
+    Returns:
+        Parsed JSON data from the file, or the configured default value
+            if file not found.
+
+    """
+    config = expected_json_config
+
+    # Build filename from node id path, flattening path segments with "__".
+    node_id_path = request.node.nodeid.split("::", 1)[0]
+    if not node_id_path.endswith(".py"):
+        return {}
+
+    module_path = node_id_path[:-3]
+    path_parts = [part for part in module_path.split("/") if part]
+    if path_parts and path_parts[0] == "tests":
+        path_parts = path_parts[1:]
+
+    if not path_parts:
+        return {}
+
+    test_name = request.node.originalname
+    file_name = "__".join([*path_parts, test_name])
+
+    # Add parametrize id if present
+    if hasattr(request, "param"):
+        file_name += f"::{request.param}"
+
+    # Get the tests directory
+    file_path = request.config.rootpath / config.assets_dir / f"{file_name}.json"
+
+    try:
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        with file_path.open(encoding="utf-8") as f:
+            return cast(JsonType, json.load(f))
+    except (FileNotFoundError, FileExistsError):
+        return {}

pytest_expected_json/plugin.py

@@ -0,0 +1,5 @@
+"""Pytest plugin entry point for expected JSON fixtures."""
+
+from pytest_expected_json.fixture import expected_data, expected_json_config
+
+__all__ = ["expected_data", "expected_json_config"]

pytest_expected_json-0.1.0.dist-info/METADATA

@@ -0,0 +1,204 @@
+Metadata-Version: 2.4
+Name: pytest-expected-json
+Version: 0.1.0
+Summary: A reusable pytest fixture for loading expected test data from JSON files
+Author: Maxime MARTIN
+License: MIT
+Keywords: fixture,json,pytest,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.11
+Requires-Dist: pytest>=7.0
+Description-Content-Type: text/markdown
+
+# pytest-expected-json
+
+A reusable pytest fixture for loading expected test data from JSON files.
+
+## Features
+
+- 📋 Automatic file path resolution based on test location and name
+- 🔧 Configurable assets directory and default return values
+- 🎯 Support for parametrized tests
+- 📦 Easy integration as a pytest plugin
+- ✅ Type hints included
+
+## Installation
+
+### From local directory
+
+```bash
+pip install -e /path/to/pytest-expected-json
+```
+
+### From another project
+
+Once published, install via:
+
+```bash
+pip install pytest-expected-json
+```
+
+## Usage
+
+### Basic Setup
+
+The fixture automatically registers as a pytest plugin. Add it to your dependencies in `pyproject.toml`:
+
+```toml
+dependencies = [
+    "pytest-expected-json>=0.1.0",
+]
+```
+
+### Using the Fixture
+
+In your test files, use the `expected_data` fixture:
+
+```python
+import pytest
+
+def test_get_user(expected_data):
+    """Test with expected data."""
+    # expected_data will automatically load from:
+    # tests/assets/saved/tests_app__test_users__test_get_user.json
+    result = get_user(1)
+    assert result == expected_data
+```
+
+### File Naming Convention
+
+The fixture automatically constructs filenames based on the test location:
+
+```
+{module_name}__{test_file}__{test_name}[@{param}].json
+```
+
+**Example:**
+- Test file: `tests/tests_app/test_users.py`
+- Test function: `test_get_user`
+- Expected file: `tests/assets/saved/tests_app__test_users__test_get_user.json`
+
+### Parametrized Tests
+
+For parametrized tests, the parameter is appended to the filename:
+
+```python
+@pytest.mark.parametrize("expected_data", ["case1", "case2"], indirect=True)
+def test_with_params(expected_data):
+    # Loads: tests/assets/saved/tests_app__test_users__test_with_params@case1.json
+    # Loads: tests/assets/saved/tests_app__test_users__test_with_params@case2.json
+    pass
+```
+
+### Configuration
+
+You can configure the fixture behavior in your test conftest:
+
+```python
+from pytest_expected_data.fixture import set_assets_dir, set_default_return
+
+# Change the assets directory (default: "tests/assets/saved")
+set_assets_dir("fixtures/expected_data")
+
+# Change default return value when file not found (default: {})
+set_default_return([])
+```
+
+Or in `pytest.ini`:
+
+```ini
+[pytest]
+# Configuration via environment or conftest
+```
+
+## Directory Structure
+
+Create your test expected data files:
+
+```
+tests/
+├── assets/
+│   └── saved/
+│       ├── tests_app__test_users__test_get_user.json
+│       ├── tests_app__test_users__test_list_users.json
+│       └── tests_health__test_health__test_health_check.json
+├── tests_app/
+│   └── test_users.py
+├── tests_health/
+│   └── test_health.py
+└── conftest.py
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+cd pytest-expected-json
+pip install -e ".[dev]"
+```
+
+### Run Tests
+
+```bash
+pytest
+```
+
+### Run Tests with Coverage
+
+```bash
+pytest --cov=src/pytest_expected_data --cov-report=html
+```
+
+### Code Quality
+
+```bash
+# Format code
+black src tests
+
+# Lint code
+ruff check src tests
+```
+
+## API Reference
+
+### `expected_data(request: pytest.FixtureRequest) -> JsonType`
+
+Pytest fixture that loads expected test data from a JSON file.
+
+**Parameters:**
+- `request`: Pytest fixture request object
+
+**Returns:**
+- Parsed JSON data (dict, list, str, int, float, bool, or None)
+- Default empty dict `{}` if file not found (configurable)
+
+**Raises:**
+- `FileNotFoundError`: If JSON file doesn't exist (caught and returns default)
+- `json.JSONDecodeError`: If JSON is invalid (caught and returns default)
+
+### `set_assets_dir(assets_dir: str) -> None`
+
+Configure the directory where expected data JSON files are stored.
+
+**Parameters:**
+- `assets_dir`: Relative path from the tests directory (default: `"tests/assets/saved"`)
+
+### `set_default_return(default_value: JsonType) -> None`
+
+Configure the default return value when expected data file is not found.
+
+**Parameters:**
+- `default_value`: Any JSON-serializable value (default: `{}`)
+
+## License
+
+MIT

pytest_expected_json-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pytest_expected_json/__init__.py,sha256=h8_mdPyHVus6nuWejU1DubRlVWFT5MfMNRvxLaFCqDY,363
+pytest_expected_json/fixture.py,sha256=LdOD_gdpbyME3Q-w_xy0vOg3kmjZo8EyoJzXmqwTp4U,3239
+pytest_expected_json/plugin.py,sha256=2t4fcjZ0DprgzxTnKgPiXQI9KCwJcY7CXpyFV5upif4,191
+pytest_expected_json/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_expected_json-0.1.0.dist-info/METADATA,sha256=8n7WDmtiaDGZ4cpSxeWbRUGGz7JzE5I34nnLdgqt1Q8,4780
+pytest_expected_json-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pytest_expected_json-0.1.0.dist-info/entry_points.txt,sha256=kLtf5qx310n0fzyj0ouYMAVwF-dT70uLkY-dfyAjmH0,62
+pytest_expected_json-0.1.0.dist-info/RECORD,,

pytest_expected_json-0.1.0.dist-info/WHEEL

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

pytest_expected_json-0.1.0.dist-info/entry_points.txt

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