atdd 0.5.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

atdd/coder/validators/test_hierarchy_coverage.py

@@ -0,0 +1,361 @@
+"""
+Coder hierarchy coverage validation.
+
+ATDD Hierarchy Coverage Spec v0.1 - Section 4: Coder Coverage Rules
+
+Validates:
+- Feature <-> Implementation (COVERAGE-CODE-4.1)
+- Implementation <-> Tests (COVERAGE-CODE-4.2)
+
+Architecture:
+- Uses shared fixtures from atdd.coach.validators.shared_fixtures
+- Phased rollout via atdd.coach.utils.coverage_phase
+- Exception handling via .atdd/config.yaml coverage.exceptions
+"""
+
+import pytest
+from pathlib import Path
+from typing import Dict, List, Set, Tuple, Any
+
+from atdd.coach.utils.repo import find_repo_root
+from atdd.coach.utils.coverage_phase import (
+    CoveragePhase,
+    should_enforce,
+    emit_coverage_warning
+)
+
+
+# Path constants
+REPO_ROOT = find_repo_root()
+PLAN_DIR = REPO_ROOT / "plan"
+PYTHON_DIR = REPO_ROOT / "python"
+SUPABASE_DIR = REPO_ROOT / "supabase"
+WEB_DIR = REPO_ROOT / "web"
+
+
+# ============================================================================
+# HELPER FUNCTIONS
+# ============================================================================
+
+
+def find_python_implementations(wagon_slug: str, feature_slug: str) -> List[Path]:
+    """
+    Find Python implementation files for a feature.
+
+    Searches for:
+    - python/{wagon}/use_case_{feature}.py
+    - python/{wagon}/service_{feature}.py
+    - python/{wagon}/{feature}_handler.py
+    - python/{wagon}/{feature}.py
+    """
+    implementations = []
+
+    # Convert slugs to filesystem format
+    wagon_dir = wagon_slug.replace("-", "_")
+    feature_file = feature_slug.replace("-", "_")
+
+    wagon_path = PYTHON_DIR / wagon_dir
+    if not wagon_path.exists():
+        return implementations
+
+    # Check various patterns
+    patterns = [
+        f"use_case_{feature_file}.py",
+        f"service_{feature_file}.py",
+        f"{feature_file}_handler.py",
+        f"{feature_file}.py",
+    ]
+
+    for pattern in patterns:
+        impl_path = wagon_path / pattern
+        if impl_path.exists():
+            implementations.append(impl_path)
+
+    # Also search subdirectories
+    for subdir in wagon_path.iterdir():
+        if subdir.is_dir() and not subdir.name.startswith("_"):
+            for pattern in patterns:
+                impl_path = subdir / pattern
+                if impl_path.exists():
+                    implementations.append(impl_path)
+
+    return implementations
+
+
+def find_typescript_implementations(wagon_slug: str, feature_slug: str) -> List[Path]:
+    """
+    Find TypeScript implementation files for a feature.
+
+    Searches for:
+    - supabase/functions/{wagon}/{feature}/index.ts
+    - supabase/functions/{wagon}/{feature}/handler.ts
+    - supabase/functions/{wagon}/{feature}.ts
+    """
+    implementations = []
+
+    functions_dir = SUPABASE_DIR / "functions"
+    if not functions_dir.exists():
+        return implementations
+
+    # Check various structures
+    # Pattern 1: supabase/functions/{wagon}/{feature}/
+    feature_dir = functions_dir / wagon_slug / feature_slug
+    if feature_dir.exists():
+        for pattern in ["index.ts", "handler.ts"]:
+            impl_path = feature_dir / pattern
+            if impl_path.exists():
+                implementations.append(impl_path)
+
+    # Pattern 2: supabase/functions/{wagon}/{feature}.ts
+    wagon_dir = functions_dir / wagon_slug
+    if wagon_dir.exists():
+        feature_file = wagon_dir / f"{feature_slug}.ts"
+        if feature_file.exists():
+            implementations.append(feature_file)
+
+    return implementations
+
+
+def find_web_implementations(wagon_slug: str, feature_slug: str) -> List[Path]:
+    """
+    Find web/frontend implementation files for a feature.
+
+    Searches for:
+    - web/src/features/{wagon}/{feature}/
+    - web/src/components/{feature}/
+    """
+    implementations = []
+
+    # Pattern 1: web/src/features/{wagon}/{feature}/
+    features_dir = WEB_DIR / "src" / "features" / wagon_slug / feature_slug
+    if features_dir.exists():
+        for pattern in ["index.tsx", "index.ts", f"{feature_slug}.tsx"]:
+            impl_path = features_dir / pattern
+            if impl_path.exists():
+                implementations.append(impl_path)
+
+    # Pattern 2: web/src/components/{feature}/
+    components_dir = WEB_DIR / "src" / "components" / feature_slug
+    if components_dir.exists():
+        implementations.append(components_dir)
+
+    return implementations
+
+
+def has_implementation(wagon_slug: str, feature_slug: str) -> bool:
+    """
+    Check if a feature has any implementation.
+    """
+    python_impls = find_python_implementations(wagon_slug, feature_slug)
+    ts_impls = find_typescript_implementations(wagon_slug, feature_slug)
+    web_impls = find_web_implementations(wagon_slug, feature_slug)
+
+    return len(python_impls) > 0 or len(ts_impls) > 0 or len(web_impls) > 0
+
+
+def find_tests_for_implementation(impl_path: Path) -> List[Path]:
+    """
+    Find test files that might test an implementation.
+    """
+    tests = []
+
+    if not impl_path.exists():
+        return tests
+
+    # For Python implementations
+    if impl_path.suffix == ".py":
+        impl_dir = impl_path.parent
+        impl_name = impl_path.stem
+
+        # Look for test_*.py in same directory
+        for test_file in impl_dir.glob("test_*.py"):
+            if impl_name in test_file.stem:
+                tests.append(test_file)
+
+        # Look for test file with matching name
+        test_file = impl_dir / f"test_{impl_name}.py"
+        if test_file.exists() and test_file not in tests:
+            tests.append(test_file)
+
+    # For TypeScript implementations
+    elif impl_path.suffix == ".ts":
+        impl_dir = impl_path.parent
+
+        # Look for *.test.ts in same directory or test/ subdirectory
+        for test_file in impl_dir.glob("*.test.ts"):
+            tests.append(test_file)
+
+        test_dir = impl_dir / "test"
+        if test_dir.exists():
+            for test_file in test_dir.glob("*.test.ts"):
+                tests.append(test_file)
+
+    return tests
+
+
+# ============================================================================
+# COVERAGE-CODE-4.1: Feature <-> Implementation Coverage
+# ============================================================================
+
+
+@pytest.mark.coder
+def test_all_features_have_implementations(feature_files, coverage_exceptions):
+    """
+    COVERAGE-CODE-4.1: Every feature has implementation code.
+
+    Given: Feature files in plan/*/features/
+    When: Searching for corresponding implementation files
+    Then: Every feature has at least one implementation in python/, supabase/, or web/
+    """
+    allowed_features = set(coverage_exceptions.get("features_without_implementation", []))
+    violations = []
+
+    for path, feature_data in feature_files:
+        # Get wagon slug from path
+        wagon_dir = path.parent.parent.name  # plan/{wagon}/features/{feature}.yaml
+        wagon_slug = wagon_dir.replace("_", "-")
+
+        # Get feature slug
+        feature_slug = path.stem.replace("_", "-")
+        feature_urn = feature_data.get("urn", f"feature:{wagon_slug}:{feature_slug}")
+
+        # Skip draft features
+        status = feature_data.get("status", "")
+        if status == "draft":
+            continue
+
+        # Skip allowed exceptions
+        if feature_urn in allowed_features or feature_slug in allowed_features:
+            continue
+
+        # Check for implementations
+        if not has_implementation(wagon_slug, feature_slug):
+            violations.append(
+                f"{feature_urn}: no implementation found in python/, supabase/, or web/"
+            )
+
+    if violations:
+        if should_enforce(CoveragePhase.FULL_ENFORCEMENT):
+            pytest.fail(
+                f"COVERAGE-CODE-4.1: Features without implementations:\n  " +
+                "\n  ".join(violations[:20]) +
+                (f"\n  ... and {len(violations) - 20} more" if len(violations) > 20 else "") +
+                "\n\nImplement feature or add to coverage.exceptions.features_without_implementation"
+            )
+        else:
+            for violation in violations[:10]:
+                emit_coverage_warning(
+                    "COVERAGE-CODE-4.1",
+                    violation,
+                    CoveragePhase.FULL_ENFORCEMENT
+                )
+
+
+# ============================================================================
+# COVERAGE-CODE-4.2: Implementation <-> Tests Coverage
+# ============================================================================
+
+
+@pytest.mark.coder
+def test_all_implementations_have_tests(feature_files):
+    """
+    COVERAGE-CODE-4.2: Every implementation has at least one test.
+
+    Given: Feature implementations in python/, supabase/, web/
+    When: Searching for corresponding test files
+    Then: Every implementation has at least one test file
+    """
+    violations = []
+
+    for path, feature_data in feature_files:
+        # Get wagon and feature slugs
+        wagon_dir = path.parent.parent.name
+        wagon_slug = wagon_dir.replace("_", "-")
+        feature_slug = path.stem.replace("_", "-")
+
+        # Skip draft features
+        status = feature_data.get("status", "")
+        if status == "draft":
+            continue
+
+        # Find all implementations for this feature
+        all_impls = (
+            find_python_implementations(wagon_slug, feature_slug) +
+            find_typescript_implementations(wagon_slug, feature_slug)
+        )
+
+        for impl_path in all_impls:
+            tests = find_tests_for_implementation(impl_path)
+            if not tests:
+                violations.append(
+                    f"{impl_path.relative_to(REPO_ROOT)}: no tests found"
+                )
+
+    if violations:
+        if should_enforce(CoveragePhase.FULL_ENFORCEMENT):
+            pytest.fail(
+                f"COVERAGE-CODE-4.2: Implementations without tests:\n  " +
+                "\n  ".join(violations[:20]) +
+                (f"\n  ... and {len(violations) - 20} more" if len(violations) > 20 else "") +
+                "\n\nAdd tests for the implementation"
+            )
+        else:
+            for violation in violations[:10]:
+                emit_coverage_warning(
+                    "COVERAGE-CODE-4.2",
+                    violation,
+                    CoveragePhase.FULL_ENFORCEMENT
+                )
+
+
+# ============================================================================
+# COVERAGE SUMMARY
+# ============================================================================
+
+
+@pytest.mark.coder
+def test_coder_coverage_summary(feature_files):
+    """
+    COVERAGE-CODE-SUMMARY: Report coder coverage statistics.
+
+    This test always passes but reports coverage metrics for visibility.
+    """
+    total_features = len(feature_files)
+    features_with_impl = 0
+    total_implementations = 0
+    implementations_with_tests = 0
+
+    for path, feature_data in feature_files:
+        wagon_dir = path.parent.parent.name
+        wagon_slug = wagon_dir.replace("_", "-")
+        feature_slug = path.stem.replace("_", "-")
+
+        # Count implementations
+        python_impls = find_python_implementations(wagon_slug, feature_slug)
+        ts_impls = find_typescript_implementations(wagon_slug, feature_slug)
+        web_impls = find_web_implementations(wagon_slug, feature_slug)
+
+        all_impls = python_impls + ts_impls + web_impls
+        if all_impls:
+            features_with_impl += 1
+            total_implementations += len(all_impls)
+
+            # Count implementations with tests
+            for impl_path in python_impls + ts_impls:
+                if find_tests_for_implementation(impl_path):
+                    implementations_with_tests += 1
+
+    # Calculate percentages
+    feature_impl_pct = (features_with_impl / total_features * 100) if total_features > 0 else 0
+    impl_test_pct = (implementations_with_tests / total_implementations * 100) if total_implementations > 0 else 0
+
+    # Report summary
+    summary = (
+        f"\n\nCoder Coverage Summary:\n"
+        f"  Features with implementations: {features_with_impl}/{total_features} ({feature_impl_pct:.1f}%)\n"
+        f"  Total implementations: {total_implementations}\n"
+        f"  Implementations with tests: {implementations_with_tests}/{total_implementations} ({impl_test_pct:.1f}%)"
+    )
+
+    # This test always passes - it's informational
+    assert True, summary

atdd/coder/validators/test_presentation_convention.py

@@ -180,16 +180,16 @@ class PresentationValidator:
 
 
     def validate_game_server_registration(self):
-        """Validate python/game.py includes all wagons with presentation."""
-        game_file = self.python_root / "game.py"
+        """Validate python/app.py includes all wagons with presentation."""
+        server_file = self.python_root / "app.py"
 
-        if not game_file.exists():
-            self.violations.append("❌ python/game.py not found - unified game server missing")
+        if not server_file.exists():
+            self.violations.append("❌ python/app.py not found - unified server missing")
             return
 
-        print(f"\nValidating unified game server: python/game.py")
+        print("\nValidating unified server: python/app.py")
 
-        content = game_file.read_text()
+        content = server_file.read_text()
 
         # Find all wagons with FastAPI controllers
         wagons_with_controllers = {}
@@ -209,7 +209,7 @@ class PresentationValidator:
                         if "fastapi" in controller_file.read_text().lower():
                             wagons_with_controllers[f"{wagon_dir.name}/{feature_dir.name}"] = controller_file
 
-        # Check if each controller is registered in game.py
+        # Check if each controller is registered in the unified server file
         for wagon_feature, controller_file in wagons_with_controllers.items():
             wagon, feature = wagon_feature.split('/')
 
@@ -217,17 +217,17 @@ class PresentationValidator:
             import_pattern = f"from {wagon}.{feature}.src.presentation.controllers"
             if import_pattern not in content:
                 self.violations.append(
-                    f"❌ game.py missing import for {wagon}/{feature} controller"
+                    f"❌ app.py missing import for {wagon}/{feature} controller"
                 )
 
             # Check for include_router
             if "include_router" in content and wagon not in content.lower():
                 self.violations.append(
-                    f"⚠️  game.py may not be registering {wagon}/{feature} routes"
+                    f"⚠️  app.py may not be registering {wagon}/{feature} routes"
                 )
 
         if not self.violations:
-            print(f"  ✓ All {len(wagons_with_controllers)} wagons registered in game.py")
+            print(f"  ✓ All {len(wagons_with_controllers)} wagons registered in app.py")
 
 
 def main():
@@ -236,7 +236,7 @@ def main():
 
     parser = argparse.ArgumentParser(description="Validate presentation layer convention")
     parser.add_argument("--check-game-server", action="store_true",
-                       help="Validate python/game.py is up to date")
+                       help="Validate python/app.py is up to date")
     args = parser.parse_args()
 
     python_root = REPO_ROOT / "python"

atdd/coder/validators/test_station_master_pattern.py

@@ -4,7 +4,7 @@ Station Master Pattern Validator
 Validates that wagons follow the Station Master pattern for monolith composition:
 1. composition.py accepts optional shared dependency parameters
 2. Direct adapters exist for cross-wagon data access
-3. game.py delegates to composition.py instead of duplicating wiring
+3. app.py delegates to composition.py instead of duplicating wiring
 
 Convention: atdd/coder/conventions/boundaries.convention.yaml::station_master_pattern
 """
@@ -21,6 +21,9 @@ def get_python_dir() -> Path:
     """Get the python directory path in the consumer repo."""
     return find_repo_root() / "python"
 
+def resolve_server_file() -> Path:
+    """Resolve station master entrypoint (app.py)."""
+    return get_python_dir() / "app.py"
 
 def test_composition_accepts_shared_dependencies():
     """
@@ -161,12 +164,12 @@ def test_direct_adapters_exist_for_cross_wagon_clients():
 
 def test_game_py_delegates_to_composition():
     """
-    Validate that game.py delegates wiring to wagon composition.py files
+    Validate that app.py delegates wiring to wagon composition.py files
     instead of duplicating wiring logic.
 
     Convention: boundaries.convention.yaml::station_master_pattern.station_master_responsibilities
 
-    Forbidden patterns in game.py:
+    Forbidden patterns in app.py:
         - Creating use cases that composition.py should own
         - Directly instantiating wagon clients without delegation
 
@@ -174,14 +177,13 @@ def test_game_py_delegates_to_composition():
         - from wagon.composition import wire_api_dependencies
         - wire_api_dependencies(state_repository=..., ...)
     """
-    python_dir = get_python_dir()
-    game_py = python_dir / "game.py"
+    server_file = resolve_server_file()
 
-    if not game_py.exists():
-        print("game.py not found - skipping Station Master delegation check")
+    if not server_file.exists():
+        print("app.py not found - skipping Station Master delegation check")
         return
 
-    source = game_py.read_text()
+    source = server_file.read_text()
 
     # Check for composition imports
     imports_composition = "from play_match.orchestrate_match.composition import wire_api_dependencies" in source
@@ -190,7 +192,7 @@ def test_game_py_delegates_to_composition():
     calls_wire_api = "wire_api_dependencies(" in source
 
     # Check for forbidden patterns (duplicated wiring)
-    # These are patterns that should be in composition.py, not game.py
+    # These are patterns that should be in composition.py, not app.py
     forbidden_patterns = [
         ("PlayMatchUseCase(", "PlayMatchUseCase should be created in composition.py"),
         ("CommitStateClient(mode=", "CommitStateClient mode should be set in composition.py"),
@@ -204,7 +206,7 @@ def test_game_py_delegates_to_composition():
 
     # Report results
     print("\n" + "=" * 70)
-    print("  Station Master Pattern: game.py Delegation")
+    print("  Station Master Pattern: app.py Delegation")
     print("=" * 70)
 
     print(f"\nDelegation to composition.py:")
@@ -212,19 +214,19 @@ def test_game_py_delegates_to_composition():
     print(f"  {'✓' if calls_wire_api else '❌'} Calls wire_api_dependencies()")
 
     if violations:
-        print(f"\n❌ Violations found in game.py:")
+        print("\n❌ Violations found in app.py:")
         for pattern, message in violations:
             print(f"  ❌ {message}")
             print(f"     Found: {pattern}")
 
     # This is a real validation
     assert imports_composition or not calls_wire_api, \
-        "game.py should import wire_api_dependencies from composition.py"
+        "app.py should import wire_api_dependencies from composition.py"
 
     assert len(violations) == 0, \
-        f"game.py has {len(violations)} Station Master pattern violations"
+        f"app.py has {len(violations)} Station Master pattern violations"
 
-    print("\n✓ game.py follows Station Master pattern")
+    print("\n✓ app.py follows Station Master pattern")
 
 
 def main():

atdd/coder/validators/test_train_infrastructure.py

@@ -11,7 +11,7 @@ Enforces:
 - Wagons implement run_train() for train mode
 - Contract validator is real (not mock)
 - E2E tests use production TrainRunner
-- Station Master pattern in game.py
+- Station Master pattern in app.py
 
 Train First-Class Spec v0.6 additions:
 - SPEC-TRAIN-VAL-0031: Backend runner paths
@@ -45,7 +45,7 @@ from atdd.coach.utils.config import get_train_config
 REPO_ROOT = find_repo_root()
 TRAINS_DIR = REPO_ROOT / "python" / "trains"
 WAGONS_DIR = REPO_ROOT / "python"
-GAME_PY = REPO_ROOT / "python" / "game.py"
+APP_PY = REPO_ROOT / "python" / "app.py"
 E2E_CONFTEST = REPO_ROOT / "e2e" / "conftest.py"
 CONTRACT_VALIDATOR = REPO_ROOT / "e2e" / "shared" / "fixtures" / "contract_validator.py"
 
@@ -110,6 +110,11 @@ def extract_imports_from_file(file_path: Path) -> Set[str]:
     return imports
 
 
+def resolve_server_file() -> Path:
+    """Resolve station master entrypoint (app.py)."""
+    return APP_PY
+
+
 # ============================================================================
 # TRAIN INFRASTRUCTURE TESTS
 # ============================================================================
@@ -247,45 +252,48 @@ def test_wagons_implement_run_train():
 
 
 # ============================================================================
-# STATION MASTER TESTS (game.py)
+# STATION MASTER TESTS (app.py)
 # ============================================================================
 
 def test_game_py_imports_train_runner():
-    """game.py must import TrainRunner (Station Master pattern)."""
-    assert GAME_PY.exists(), f"game.py not found: {GAME_PY}"
+    """app.py must import TrainRunner (Station Master pattern)."""
+    server_file = resolve_server_file()
+    assert server_file.exists(), f"app.py not found: {server_file}"
 
-    imports = extract_imports_from_file(GAME_PY)
+    imports = extract_imports_from_file(server_file)
 
     has_train_import = any("trains.runner import TrainRunner" in imp for imp in imports)
 
     assert has_train_import, (
-        "game.py must import TrainRunner\n"
+        "app.py must import TrainRunner\n"
         "Expected: from trains.runner import TrainRunner\n"
         "See: atdd/coder/conventions/train.convention.yaml::station_master"
     )
 
 
 def test_game_py_has_journey_map():
-    """game.py must have JOURNEY_MAP routing actions to trains."""
-    with open(GAME_PY, 'r', encoding='utf-8') as f:
+    """app.py must have JOURNEY_MAP routing actions to trains."""
+    server_file = resolve_server_file()
+    with open(server_file, 'r', encoding='utf-8') as f:
         content = f.read()
 
     assert "JOURNEY_MAP" in content, (
-        "game.py must define JOURNEY_MAP dictionary\n"
+        "app.py must define JOURNEY_MAP dictionary\n"
         "Expected: JOURNEY_MAP = {'action': 'train_id', ...}\n"
         "See: atdd/coder/conventions/train.convention.yaml::station_master"
     )
 
 
 def test_game_py_has_train_execution_endpoint():
-    """game.py must have /trains/execute endpoint."""
-    with open(GAME_PY, 'r', encoding='utf-8') as f:
+    """app.py must have /trains/execute endpoint."""
+    server_file = resolve_server_file()
+    with open(server_file, 'r', encoding='utf-8') as f:
         content = f.read()
 
     has_endpoint = '"/trains/execute"' in content or "'/trains/execute'" in content
 
     assert has_endpoint, (
-        "game.py must have /trains/execute endpoint\n"
+        "app.py must have /trains/execute endpoint\n"
         "Expected: @app.post('/trains/execute')\n"
         "See: atdd/coder/conventions/train.convention.yaml::station_master"
     )
@@ -407,7 +415,7 @@ def test_train_convention_documents_key_patterns():
     - composition_hierarchy (with train level)
     - wagon_train_mode (run_train signature)
     - cargo_pattern (artifact flow)
-    - station_master (game.py pattern)
+    - station_master (app.py pattern)
     - testing_pattern (E2E tests)
     """
     with open(TRAIN_CONVENTION, 'r', encoding='utf-8') as f:

atdd/coder/validators/test_wagon_boundaries.py

@@ -78,8 +78,8 @@ def find_implementation_files() -> List[Path]:
         # Skip __pycache__
         if '__pycache__' in str(py_file):
             continue
-        # Skip wagon.py, composition.py, and game.py (wagon/app-level orchestration)
-        if py_file.name in ['wagon.py', 'composition.py', 'game.py']:
+        # Skip wagon.py, composition.py, and app entrypoint (wagon/app-level orchestration)
+        if py_file.name in ['wagon.py', 'composition.py', 'app.py']:
             continue
         # Skip shared/ directory (theme/train-level orchestration - can import across wagons)
         if '/shared/' in str(py_file):