wayfinder-paths 0.1.7__py3-none-any.whl

wayfinder_paths/tests/test_test_coverage.py

@@ -0,0 +1,212 @@
+"""Test to ensure all adapters and strategies have corresponding test files."""
+
+from pathlib import Path
+
+import pytest
+
+
+def test_all_adapters_have_tests():
+    """Verify that all adapters have a test_adapter.py file."""
+    adapters_dir = Path(__file__).parent.parent / "adapters"
+
+    if not adapters_dir.exists():
+        pytest.skip("Adapters directory not found")
+
+    missing_tests = []
+
+    # Find all adapter directories (directories containing adapter.py)
+    for adapter_dir in adapters_dir.iterdir():
+        if not adapter_dir.is_dir() or adapter_dir.name.startswith("_"):
+            continue
+
+        adapter_py = adapter_dir / "adapter.py"
+        test_adapter_py = adapter_dir / "test_adapter.py"
+
+        # If adapter.py exists, test_adapter_py must exist
+        if adapter_py.exists() and not test_adapter_py.exists():
+            missing_tests.append(adapter_dir.name)
+
+    if missing_tests:
+        pytest.fail(
+            f"The following adapters are missing test files:\n"
+            f"{', '.join(missing_tests)}\n"
+            f"Please create test_adapter.py for each adapter."
+        )
+
+
+def test_all_strategies_have_tests():
+    """Verify that all strategies have a test_strategy.py file."""
+    strategies_dir = Path(__file__).parent.parent / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    missing_tests = []
+
+    # Find all strategy directories (directories containing strategy.py)
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        strategy_py = strategy_dir / "strategy.py"
+        test_strategy_py = strategy_dir / "test_strategy.py"
+
+        # If strategy.py exists, test_strategy.py must exist
+        if strategy_py.exists() and not test_strategy_py.exists():
+            missing_tests.append(strategy_dir.name)
+
+    if missing_tests:
+        pytest.fail(
+            f"The following strategies are missing test files:\n"
+            f"{', '.join(missing_tests)}\n"
+            f"Please create test_strategy.py for each strategy."
+        )
+
+
+def test_all_strategies_have_examples_json():
+    """Verify that all strategies have an examples.json file (REQUIRED)."""
+    strategies_dir = Path(__file__).parent.parent / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    missing_examples = []
+
+    # Find all strategy directories (directories containing strategy.py)
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        strategy_py = strategy_dir / "strategy.py"
+        examples_json = strategy_dir / "examples.json"
+
+        # If strategy.py exists, examples.json must exist
+        if strategy_py.exists() and not examples_json.exists():
+            missing_examples.append(strategy_dir.name)
+
+    if missing_examples:
+        pytest.fail(
+            f"The following strategies are missing examples.json files:\n"
+            f"{', '.join(missing_examples)}\n"
+            f"examples.json is REQUIRED for all strategies.\n"
+            f"See TESTING.md for the required structure."
+        )
+
+
+def test_strategy_tests_use_examples_json():
+    """Verify that strategy test files load examples.json using the shared utility."""
+    strategies_dir = Path(__file__).parent.parent / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    violations = []
+
+    # Find all strategy test files
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        test_file = strategy_dir / "test_strategy.py"
+        if not test_file.exists():
+            continue
+
+        # Read the test file content
+        try:
+            content = test_file.read_text()
+
+            # Check if it imports load_strategy_examples from tests.test_utils
+            # (wayfinder_paths/ is added to path by conftest.py or inline)
+            has_import = (
+                "from tests.test_utils import load_strategy_examples" in content
+                or "from wayfinder_paths.tests.test_utils import load_strategy_examples"
+                in content  # alternative
+                or "import tests.test_utils" in content
+                or "import wayfinder_paths.tests.test_utils" in content  # alternative
+                or (
+                    "tests.test_utils" in content
+                    and "load_strategy_examples" in content
+                )  # fallback importlib pattern
+            )
+
+            # Check if it calls load_strategy_examples
+            has_usage = "load_strategy_examples" in content
+
+            # If it doesn't use the shared utility, check for alternative patterns
+            if not (has_import and has_usage):
+                # Check for hardcoded examples.json loading (old pattern)
+                has_hardcoded = (
+                    'Path(__file__).parent / "examples.json"' in content
+                    or "examples.json" in content
+                ) and "load_strategy_examples" not in content
+
+                if has_hardcoded:
+                    violations.append(
+                        f"{strategy_dir.name}: Uses hardcoded examples.json loading "
+                        f"instead of load_strategy_examples() from tests.test_utils"
+                    )
+                elif has_usage and not has_import:
+                    violations.append(
+                        f"{strategy_dir.name}: Uses load_strategy_examples but missing import"
+                    )
+                elif not has_usage:
+                    violations.append(
+                        f"{strategy_dir.name}: Test file does not appear to load examples.json"
+                    )
+        except Exception as e:
+            violations.append(f"{strategy_dir.name}: Error reading test file: {e}")
+
+    if violations:
+        pytest.fail(
+            f"The following strategy tests need to use load_strategy_examples():\n"
+            f"{chr(10).join(violations)}\n"
+            f"All strategy tests MUST use load_strategy_examples() from tests.test_utils.\n"
+            f"See TESTING.md for examples."
+        )
+
+
+def test_strategy_examples_have_smoke():
+    """Verify that all strategy examples.json files have a 'smoke' entry."""
+    strategies_dir = Path(__file__).parent.parent / "strategies"
+
+    if not strategies_dir.exists():
+        pytest.skip("Strategies directory not found")
+
+    import json
+
+    missing_smoke = []
+
+    # Find all strategy directories
+    for strategy_dir in strategies_dir.iterdir():
+        if not strategy_dir.is_dir() or strategy_dir.name.startswith("_"):
+            continue
+
+        strategy_py = strategy_dir / "strategy.py"
+        examples_json = strategy_dir / "examples.json"
+
+        # Only check strategies that exist
+        if not strategy_py.exists():
+            continue
+
+        if not examples_json.exists():
+            # This will be caught by test_all_strategies_have_examples_json
+            continue
+
+        try:
+            with open(examples_json) as f:
+                examples = json.load(f)
+
+            if "smoke" not in examples:
+                missing_smoke.append(strategy_dir.name)
+        except json.JSONDecodeError:
+            missing_smoke.append(f"{strategy_dir.name} (invalid JSON)")
+        except Exception as e:
+            missing_smoke.append(f"{strategy_dir.name} (error: {e})")
+
+    if missing_smoke:
+        pytest.fail(
+            f"The following strategies' examples.json are missing 'smoke' entry:\n"
+            f"{', '.join(missing_smoke)}\n"
+            f"All strategies MUST have a 'smoke' example in examples.json.\n"
+            f"See TESTING.md for the required structure."
+        )

wayfinder_paths/tests/test_utils.py

@@ -0,0 +1,64 @@
+"""Shared utilities for testing strategies and adapters."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def load_strategy_examples(strategy_test_file: Path) -> dict[str, Any]:
+    """Load examples.json for a strategy test file.
+
+    This is REQUIRED for all strategy tests. The examples.json file serves
+    as both documentation and test data, ensuring tests stay in sync with examples.
+
+    Args:
+        strategy_test_file: Path to the test_strategy.py file
+
+    Returns:
+        Dictionary containing examples from examples.json
+
+    Raises:
+        FileNotFoundError: If examples.json does not exist
+        json.JSONDecodeError: If examples.json is invalid JSON
+    """
+    examples_path = strategy_test_file.parent / "examples.json"
+
+    if not examples_path.exists():
+        raise FileNotFoundError(
+            f"examples.json is REQUIRED for strategy tests. "
+            f"Create it at: {examples_path}\n"
+            f"See TESTING.md for the required structure."
+        )
+
+    with open(examples_path) as f:
+        return json.load(f)
+
+
+def get_canonical_examples(examples: dict[str, Any]) -> dict[str, Any]:
+    """Extract canonical usage examples from examples.json.
+
+    Canonical usage is defined as the primary, documented usage patterns
+    that demonstrate how the strategy should be used. This includes:
+    - 'smoke' example: The basic lifecycle test (deposit → update → status → withdraw)
+    - Any examples without 'expect' fields (positive usage patterns)
+
+    Args:
+        examples: The full examples.json dictionary
+
+    Returns:
+        Dictionary of canonical examples keyed by their example name
+    """
+    canonical = {}
+
+    # 'smoke' is always canonical
+    if "smoke" in examples:
+        canonical["smoke"] = examples["smoke"]
+
+    # Any example without 'expect' is considered canonical usage
+    for name, example_data in examples.items():
+        if name == "smoke":
+            continue  # Already added
+        if isinstance(example_data, dict) and "expect" not in example_data:
+            canonical[name] = example_data
+
+    return canonical

wayfinder_paths-0.1.7.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Wayfinder
+
+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.