atdd 0.2.1__py3-none-any.whl

atdd/coder/conventions/tests/test_complexity_recipe.py

@@ -0,0 +1,289 @@
+"""
+Tests for complexity recipe.
+
+Tests SPEC-CODER-UTL-0158 to 047, 054, 056, 057, 058
+ATDD: These tests define expected behavior of complexity recipe BEFORE implementation.
+"""
+import pytest
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+
+
+# Recipe loader utilities (shared with thinness tests)
+def load_recipe(recipe_name: str) -> Dict[str, Any]:
+    """
+    Load recipe YAML file.
+
+    SPEC-CODER-UTL-0158: Load complexity recipe
+    """
+    recipe_path = Path(__file__).resolve().parents[1] / f"{recipe_name}.recipe.yaml"
+
+    if not recipe_path.exists():
+        raise FileNotFoundError(f"Recipe not found: {recipe_path}")
+
+    with open(recipe_path, 'r') as f:
+        return yaml.safe_load(f)
+
+
+def check_recipe_applies(recipe_name: str, smells: Dict[str, Any]) -> bool:
+    """
+    Check if recipe applies based on smell detection results.
+
+    SPEC-CODER-UTL-0159: Detect when complexity recipe applies
+    """
+    recipe = load_recipe(recipe_name)
+
+    if recipe_name == "complexity":
+        # complexity applies when complexity check fails
+        return smells.get("complexity", {}).get("passed", True) is False
+
+    return False
+
+
+def execute_recipe_step(recipe_name: str, step: int, context: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute a recipe step.
+
+    SPEC-CODER-UTL-0160, 046, 047: Execute steps 1, 2, 3
+    """
+    recipe = load_recipe(recipe_name)
+    steps = recipe.get("steps", [])
+
+    if step < 1 or step > len(steps):
+        return {"success": False, "error": f"Invalid step: {step}"}
+
+    step_def = steps[step - 1]
+
+    # Return step guidance
+    return {
+        "success": True,
+        "step": step,
+        "what": step_def.get("what", ""),
+        "where": step_def.get("where", ""),
+        "template": step_def.get("template", ""),
+        "example": step_def.get("example", ""),
+        "next_action": "continue" if step < len(steps) else "verify_final"
+    }
+
+
+def select_recipe(smells: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Select recipe based on smell detection.
+
+    SPEC-CODER-UTL-0169: Map complexity smell to complexity recipe
+    """
+    # Priority 1: Handler smell → thinness
+    if smells.get("thinness", {}).get("passed", True) is False:
+        return {"recipe": "thinness", "priority": 1}
+
+    # Priority 2: Complexity smell → complexity
+    if smells.get("complexity", {}).get("passed", True) is False:
+        return {"recipe": "complexity", "priority": 2}
+
+    # Priority 3: Missing adapter → adapter
+    if smells.get("missing_adapter", False):
+        return {"recipe": "adapter", "priority": 3}
+
+    return {"recipe": None, "priority": 0}
+
+
+def verify_recipe_step(step_result: Dict[str, Any], test_status: str) -> bool:
+    """
+    Verify recipe step maintains GREEN tests.
+
+    SPEC-CODER-UTL-0171: Verify recipe step maintains GREEN tests
+    SPEC-CODER-UTL-0173: Rollback on step failure
+    """
+    if test_status == "GREEN":
+        return True
+
+    # RED tests trigger rollback
+    if test_status == "RED":
+        # This would call rollback_refactor_step() in real usage
+        return False
+
+    return False
+
+
+def verify_recipe_final(recipe_name: str, results: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Verify final state after all recipe steps.
+
+    SPEC-CODER-UTL-0172: Verify final state after all recipe steps
+    """
+    verification = {"success": True, "checks": []}
+
+    if recipe_name == "complexity":
+        # Final verification: complexity.check() should pass
+        verification["checks"].append({
+            "check": "complexity.check()",
+            "expected": "passed=true"
+        })
+        verification["complexity_reduced"] = True
+
+    return verification
+
+
+# TESTS
+
+class TestSpecificationRecipeLoading:
+    """Test SPEC-CODER-UTL-0158: Load complexity recipe"""
+
+    def test_load_recipe(self):
+        """Should load complexity recipe YAML"""
+        recipe = load_recipe("complexity")
+
+        assert recipe is not None
+        assert recipe["recipe"] == "complexity"
+        assert recipe["pattern"] == "Complexity Reduction (Split/Extract)"
+        assert "steps" in recipe
+        assert len(recipe["steps"]) == 3
+
+
+class TestSpecificationRecipeApplies:
+    """Test SPEC-CODER-UTL-0159: Detect when complexity recipe applies"""
+
+    def test_recipe_applies(self):
+        """Should return true when complexity check fails"""
+        smells = {
+            "complexity": {
+                "passed": False,
+                "violations": [
+                    {"function": "calculateDiscount", "complexity": 12, "line": 45}
+                ]
+            }
+        }
+
+        result = check_recipe_applies("complexity", smells)
+
+        assert result is True
+
+    def test_recipe_not_applies(self):
+        """Should return false when complexity check passes"""
+        smells = {
+            "complexity": {
+                "passed": True,
+                "violations": []
+            }
+        }
+
+        result = check_recipe_applies("complexity", smells)
+
+        assert result is False
+
+
+class TestSpecificationRecipeSteps:
+    """Test SPEC-CODER-UTL-0160, 046, 047: Execute recipe steps"""
+
+    def test_execute_step_1(self):
+        """Should execute step 1: create base complexity"""
+        context = {"file_path": "domain/order.py"}
+
+        result = execute_recipe_step("complexity", 1, context)
+
+        assert result["success"] is True
+        assert "complexity" in result["what"].lower() or "base" in result["what"].lower()
+        assert "domain/complexity/" in result["where"]
+        assert "is_satisfied_by" in result["template"] or result["example"]
+
+    def test_execute_step_2(self):
+        """Should execute step 2: extract complexitys"""
+        context = {"base_created": True}
+
+        result = execute_recipe_step("complexity", 2, context)
+
+        assert result["success"] is True
+        assert "extract" in result["what"].lower() or "boolean" in result["what"].lower()
+        assert "domain/complexity/" in result["where"]
+
+    def test_execute_step_3(self):
+        """Should execute step 3: compose complexitys"""
+        context = {"base_created": True, "specs_extracted": True}
+
+        result = execute_recipe_step("complexity", 3, context)
+
+        assert result["success"] is True
+        assert "compose" in result["what"].lower() or "and_" in result["template"] or "or_" in result["template"]
+        assert result["next_action"] == "verify_final"
+
+
+class TestSpecificationRecipeSelection:
+    """Test SPEC-CODER-UTL-0169: Map complexity smell to complexity recipe"""
+
+    def test_select_from_smell(self):
+        """Should select complexity recipe when complexity smell detected"""
+        smells = {
+            "complexity": {
+                "passed": False,
+                "violations": [{"function": "process", "complexity": 15}]
+            }
+        }
+
+        result = select_recipe(smells)
+
+        assert result["recipe"] == "complexity"
+        assert result["priority"] == 2
+
+
+class TestSpecificationRecipeVerification:
+    """Test SPEC-CODER-UTL-0171, 057, 058: Recipe verification"""
+
+    def test_verify_step_green(self):
+        """Should return true when tests are GREEN"""
+        step_result = {"success": True, "step": 1}
+
+        result = verify_recipe_step(step_result, "GREEN")
+
+        assert result is True
+
+    def test_rollback_on_failure(self):
+        """Should return false and trigger rollback when tests are RED"""
+        step_result = {"success": True, "step": 1}
+
+        result = verify_recipe_step(step_result, "RED")
+
+        assert result is False
+
+    def test_verify_final(self):
+        """Should verify final state with complexity check"""
+        results = {"all_steps_completed": True}
+
+        verification = verify_recipe_final("complexity", results)
+
+        assert verification["success"] is True
+        assert verification["complexity_reduced"] is True
+        assert len(verification["checks"]) > 0
+        assert any("complexity" in check["check"] for check in verification["checks"])
+
+
+class TestSpecificationRecipeIntegration:
+    """Integration tests for full recipe workflow"""
+
+    def test_full_recipe_workflow(self):
+        """Should execute full recipe from detection to verification"""
+        # 1. Detect smell
+        smells = {"complexity": {"passed": False, "violations": [{"function": "foo", "complexity": 12}]}}
+
+        # 2. Select recipe
+        selected = select_recipe(smells)
+        assert selected["recipe"] == "complexity"
+
+        # 3. Load recipe
+        recipe = load_recipe("complexity")
+        assert recipe is not None
+
+        # 4. Execute steps
+        context = {}
+        for step in range(1, 4):
+            result = execute_recipe_step("complexity", step, context)
+            assert result["success"] is True
+
+            # Verify step
+            verified = verify_recipe_step(result, "GREEN")
+            assert verified is True
+
+        # 5. Final verification
+        verification = verify_recipe_final("complexity", {"all_steps": True})
+        assert verification["success"] is True
+        assert verification["complexity_reduced"] is True

atdd/coder/conventions/tests/test_component_taxonomy.py

@@ -0,0 +1,278 @@
+"""
+Tests for component taxonomy adoption in conventions.
+
+Tests SPEC-CODER-CONV-0006 through SPEC-CODER-CONV-0011
+ATDD: Validates that conventions use generic component types with examples.
+"""
+import pytest
+import yaml
+from pathlib import Path
+from typing import Dict, Any, List
+
+
+# Utility functions for loading YAML files
+def load_yaml(file_path: Path) -> Dict[str, Any]:
+    """Load and parse a YAML file."""
+    with open(file_path, 'r') as f:
+        return yaml.safe_load(f)
+
+
+def get_project_root() -> Path:
+    """Get the project root directory."""
+    # From tests/ directory, go up 4 levels: tests -> conventions -> coder -> atdd -> root
+    return Path(__file__).parent.parent.parent.parent.parent
+
+
+def load_convention_backend() -> Dict[str, Any]:
+    """Load the backend convention."""
+    conventions_dir = Path(__file__).parent.parent
+    path = conventions_dir / "backend.convention.yaml"
+    return load_yaml(path)
+
+
+def load_convention_frontend() -> Dict[str, Any]:
+    """Load the frontend convention."""
+    conventions_dir = Path(__file__).parent.parent
+    path = conventions_dir / "frontend.convention.yaml"
+    return load_yaml(path)
+
+
+def get_component_type_names(layer_data: Dict[str, Any]) -> List[str]:
+    """Extract component type names from a layer."""
+    component_types = layer_data.get("component_types", [])
+    return [ct["name"] for ct in component_types]
+
+
+# Expected generic component types for validation
+BACKEND_GENERIC_TYPES = {
+    "presentation": ["controllers", "routes", "serializers", "validators", "middleware", "guards", "views"],
+    "application": ["use_cases", "handlers", "ports", "dtos", "policies", "workflows"],
+    "domain": ["entities", "value_objects", "aggregates", "services", "specifications", "events", "exceptions"],
+    "integration": ["repositories", "clients", "caches", "engines", "formatters", "notifiers", "queues", "stores", "mappers", "schedulers", "monitors"]
+}
+
+FRONTEND_GENERIC_TYPES = {
+    "presentation": ["views", "components", "containers", "controllers", "routes", "layouts", "styles", "animations", "forms", "hooks", "directives", "filters"],
+    "application": ["use_cases", "ports", "policies", "dtos"],
+    "domain": ["entities", "value_objects", "services", "specifications", "exceptions"],
+    "integration": ["repositories", "clients", "stores", "serializers", "mappers", "interceptors", "caches", "synchronizers", "monitors", "validators", "workers", "connectors"]
+}
+
+
+class TestBackendConventionAdoptsTaxonomy:
+    """Test SPEC-CODER-CONV-0006: Backend convention uses generic component types"""
+
+    def test_backend_convention_adopts_taxonomy_types(self):
+        """Should have generic component types with examples for all 4 layers"""
+        convention = load_convention_backend()
+        backend = convention.get("backend", {})
+        layers = backend.get("layers", {})
+
+        for layer_name, expected_types in BACKEND_GENERIC_TYPES.items():
+            layer = layers.get(layer_name, {})
+            actual_types = get_component_type_names(layer)
+
+            # Verify all generic types are present
+            for expected_type in expected_types:
+                assert expected_type in actual_types, \
+                    f"{layer_name} layer missing generic type '{expected_type}'"
+
+            # Verify each component type has required fields
+            component_types = layer.get("component_types", [])
+            for ct in component_types:
+                assert "name" in ct, f"Component type missing 'name' field"
+                assert "description" in ct, f"Component type {ct.get('name')} missing 'description'"
+                assert "suffix" in ct, f"Component type {ct.get('name')} missing 'suffix'"
+                assert "examples" in ct, f"Component type {ct.get('name')} missing 'examples'"
+                assert len(ct["examples"]) > 0, f"Component type {ct.get('name')} has empty examples"
+
+
+class TestFrontendConventionAdoptsTaxonomy:
+    """Test SPEC-CODER-CONV-0007: Frontend convention uses generic component types"""
+
+    def test_frontend_convention_adopts_taxonomy_types(self):
+        """Should have generic component types with examples for all 4 layers"""
+        convention = load_convention_frontend()
+        frontend = convention.get("frontend", {})
+        layers = frontend.get("layers", {})
+
+        for layer_name, expected_types in FRONTEND_GENERIC_TYPES.items():
+            layer = layers.get(layer_name, {})
+            actual_types = get_component_type_names(layer)
+
+            # Verify all generic types are present
+            for expected_type in expected_types:
+                assert expected_type in actual_types, \
+                    f"{layer_name} layer missing generic type '{expected_type}'"
+
+            # Verify each component type has required fields
+            component_types = layer.get("component_types", [])
+            for ct in component_types:
+                assert "name" in ct, f"Component type missing 'name' field"
+                assert "description" in ct, f"Component type {ct.get('name')} missing 'description'"
+                assert "suffix" in ct, f"Component type {ct.get('name')} missing 'suffix'"
+                assert "examples" in ct, f"Component type {ct.get('name')} missing 'examples'"
+                assert len(ct["examples"]) > 0, f"Component type {ct.get('name')} has empty examples"
+
+
+class TestBackendPreservesDependencyRules:
+    """Test SPEC-CODER-CONV-0008: Backend convention preserves dependency rules and CI enforcement"""
+
+    def test_backend_preserves_dependency_rules(self):
+        """Should preserve dependency.allowed_edges, forbidden_examples, and ci_enforcement sections"""
+        convention = load_convention_backend()
+        backend = convention.get("backend", {})
+
+        # Verify dependency section exists
+        dependency = backend.get("dependency", {})
+        assert dependency is not None, "Backend dependency section missing"
+
+        # Verify allowed_edges preserved
+        allowed_edges = dependency.get("allowed_edges", [])
+        assert len(allowed_edges) > 0, "Backend allowed_edges empty or missing"
+
+        # Check specific expected edges
+        edge_from_values = [edge.get("from") for edge in allowed_edges]
+        assert "presentation" in edge_from_values, "Missing presentation edge"
+        assert "application" in edge_from_values, "Missing application edge"
+        assert "integration" in edge_from_values, "Missing integration edge"
+
+        # Verify forbidden_examples preserved
+        forbidden_examples = dependency.get("forbidden_examples", [])
+        assert len(forbidden_examples) > 0, "Backend forbidden_examples empty or missing"
+
+        # Verify ci_enforcement section exists
+        ci_enforcement = backend.get("ci_enforcement", {})
+        assert ci_enforcement is not None, "Backend ci_enforcement section missing"
+
+        # Verify ci_enforcement has required subsections
+        checks = ci_enforcement.get("checks", [])
+        assert len(checks) > 0, "Backend ci_enforcement.checks empty or missing"
+
+        tools = ci_enforcement.get("tools", [])
+        assert len(tools) > 0, "Backend ci_enforcement.tools empty or missing"
+
+        failure_policy = ci_enforcement.get("failure_policy")
+        assert failure_policy is not None, "Backend ci_enforcement.failure_policy missing"
+
+
+class TestFrontendPreservesDependencyRules:
+    """Test SPEC-CODER-CONV-0009: Frontend convention preserves dependency rules and CI enforcement"""
+
+    def test_frontend_preserves_dependency_rules(self):
+        """Should preserve dependency.allowed_edges, forbidden_examples, and ci_enforcement sections"""
+        convention = load_convention_frontend()
+        frontend = convention.get("frontend", {})
+
+        # Verify dependency section exists
+        dependency = frontend.get("dependency", {})
+        assert dependency is not None, "Frontend dependency section missing"
+
+        # Verify allowed_edges preserved
+        allowed_edges = dependency.get("allowed_edges", [])
+        assert len(allowed_edges) > 0, "Frontend allowed_edges empty or missing"
+
+        # Check specific expected edges
+        edge_from_values = [edge.get("from") for edge in allowed_edges]
+        assert "presentation" in edge_from_values, "Missing presentation edge"
+        assert "application" in edge_from_values, "Missing application edge"
+        assert "integration" in edge_from_values, "Missing integration edge"
+
+        # Verify forbidden_examples preserved
+        forbidden_examples = dependency.get("forbidden_examples", [])
+        assert len(forbidden_examples) > 0, "Frontend forbidden_examples empty or missing"
+
+        # Verify ci_enforcement section exists
+        ci_enforcement = frontend.get("ci_enforcement", {})
+        assert ci_enforcement is not None, "Frontend ci_enforcement section missing"
+
+        # Verify ci_enforcement has required subsections
+        checks = ci_enforcement.get("checks", [])
+        assert len(checks) > 0, "Frontend ci_enforcement.checks empty or missing"
+
+        tools = ci_enforcement.get("tools", [])
+        assert len(tools) > 0, "Frontend ci_enforcement.tools empty or missing"
+
+        failure_policy = ci_enforcement.get("failure_policy")
+        assert failure_policy is not None, "Frontend ci_enforcement.failure_policy missing"
+
+
+class TestTaxonomyUsesGenericNames:
+    """Test SPEC-CODER-CONV-0010: Component types have generic names with example arrays"""
+
+    def test_taxonomy_uses_generic_names_with_examples(self):
+        """Should verify conventions use generic names with examples arrays"""
+        backend_convention = load_convention_backend()
+        frontend_convention = load_convention_frontend()
+
+        # Test backend convention
+        backend = backend_convention.get("backend", {})
+        layers = backend.get("layers", {})
+        integration_layer = layers.get("integration", {})
+        component_types = integration_layer.get("component_types", [])
+
+        # Verify generic component types exist with examples
+        generic_types = ["repositories", "engines", "formatters", "clients", "caches"]
+        found_types = {ct["name"] for ct in component_types}
+
+        for generic_type in generic_types:
+            assert generic_type in found_types, f"Generic type '{generic_type}' not found in backend convention"
+
+            # Find the component type and verify it has examples
+            ct = next((ct for ct in component_types if ct["name"] == generic_type), None)
+            assert ct is not None, f"Component type {generic_type} not found"
+            assert "examples" in ct, f"Component type {generic_type} missing examples array"
+            assert len(ct["examples"]) > 0, f"Component type {generic_type} has empty examples array"
+            assert "description" in ct, f"Component type {generic_type} missing description"
+
+        # Test frontend convention
+        frontend = frontend_convention.get("frontend", {})
+        layers = frontend.get("layers", {})
+        presentation_layer = layers.get("presentation", {})
+        component_types = presentation_layer.get("component_types", [])
+
+        # Verify generic component types exist with examples
+        generic_types = ["views", "components", "controllers"]
+        found_types = {ct["name"] for ct in component_types}
+
+        for generic_type in generic_types:
+            assert generic_type in found_types, f"Generic type '{generic_type}' not found in frontend convention"
+
+            # Find the component type and verify it has examples
+            ct = next((ct for ct in component_types if ct["name"] == generic_type), None)
+            assert ct is not None, f"Component type {generic_type} not found"
+            assert "examples" in ct, f"Component type {generic_type} missing examples array"
+            assert len(ct["examples"]) > 0, f"Component type {generic_type} has empty examples array"
+            assert "description" in ct, f"Component type {generic_type} missing description"
+
+
+class TestConventionsExcludeUrnAndOrganization:
+    """Test SPEC-CODER-CONV-0011: Conventions exclude URN and organization sections"""
+
+    def test_conventions_exclude_urn_and_organization(self):
+        """Should verify conventions don't have urn_pattern, urn_examples, organization, or framework_adaptations"""
+        backend_convention = load_convention_backend()
+        frontend_convention = load_convention_frontend()
+
+        # Test backend convention
+        assert "urn_pattern" not in backend_convention, "Backend convention should not have urn_pattern"
+        assert "urn_examples" not in backend_convention, "Backend convention should not have urn_examples"
+        assert "organization" not in backend_convention, "Backend convention should not have organization section"
+        assert "framework_adaptations" not in backend_convention, "Backend convention should not have framework_adaptations"
+
+        # Test frontend convention
+        assert "urn_pattern" not in frontend_convention, "Frontend convention should not have urn_pattern"
+        assert "urn_examples" not in frontend_convention, "Frontend convention should not have urn_examples"
+        assert "organization" not in frontend_convention, "Frontend convention should not have organization section"
+        assert "framework_adaptations" not in frontend_convention, "Frontend convention should not have framework_adaptations"
+
+        # Verify conventions only have expected top-level keys
+        expected_backend_keys = {"version", "name", "description", "backend"}
+        actual_backend_keys = set(backend_convention.keys())
+        assert actual_backend_keys == expected_backend_keys, \
+            f"Backend convention has unexpected keys: {actual_backend_keys - expected_backend_keys}"
+
+        expected_frontend_keys = {"version", "name", "description", "frontend"}
+        actual_frontend_keys = set(frontend_convention.keys())
+        assert actual_frontend_keys == expected_frontend_keys, \
+            f"Frontend convention has unexpected keys: {actual_frontend_keys - expected_frontend_keys}"