atdd 0.2.1__py3-none-any.whl

atdd/coder/conventions/tests/test_component_urn_naming.py

@@ -0,0 +1,165 @@
+"""
+SPEC-CODER-CONV-0013, SPEC-CODER-CONV-0014: Component URN naming migration tests for coder
+
+Tests for migrating component URN pattern in coder conventions.
+"""
+import pytest
+import yaml
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[5]
+COMPONENT_NAMING_PATH = REPO_ROOT / "atdd/coder/conventions/component-naming.convention.yaml"
+GREEN_CONV_PATH = REPO_ROOT / "atdd/coder/conventions/green.convention.yaml"
+
+
+def test_coder_convention_uses_colon_hierarchy():
+    """
+    SPEC-CODER-CONV-0013: Update coder component-naming.convention.yaml with new URN pattern
+
+    Verify that the URN pattern uses colons for hierarchy.
+    """
+    with open(COMPONENT_NAMING_PATH) as f:
+        convention = yaml.safe_load(f)
+
+    pattern = convention.get("urn_naming", {}).get("pattern", "")
+
+    # Should use colon after wagon and feature
+    assert "component:{wagon}:{feature}" in pattern, \
+        f"Pattern should use colons for hierarchy: {pattern}"
+
+    # Should NOT use dot between wagon and feature
+    assert "component:{wagon}.{feature}" not in pattern, \
+        f"Pattern should not use dots between wagon and feature: {pattern}"
+
+
+def test_coder_artifact_examples_use_new_format():
+    """
+    SPEC-CODER-CONV-0013: All artifact derivation examples updated with new format
+
+    Verify all artifact_derivation examples use colon-based hierarchy.
+    """
+    with open(COMPONENT_NAMING_PATH) as f:
+        convention = yaml.safe_load(f)
+
+    artifact_derivation = convention.get("artifact_derivation", {})
+    # Navigate to the nested structure: rules > capability_suffix > by_artifact_type
+    rules = artifact_derivation.get("rules", {})
+    capability_suffix = rules.get("capability_suffix", {})
+    by_artifact_type = capability_suffix.get("by_artifact_type", {})
+
+    # Collect all example URNs from all artifact types
+    all_urns = []
+    for artifact_type, config in by_artifact_type.items():
+        examples = config.get("examples", [])
+        for example in examples:
+            urn = example.get("urn", "")
+            if urn:
+                all_urns.append((artifact_type, urn))
+
+    assert len(all_urns) > 0, "Should have artifact derivation examples"
+
+    for artifact_type, urn in all_urns:
+        # Check for colon format (look for pattern: component:word:word)
+        # After "component:" there should be wagon, then colon, then feature
+        parts = urn.split(":")
+        assert len(parts) >= 3, \
+            f"URN should have at least 3 colon-separated parts: {urn}"
+
+        # First part should be "component"
+        assert parts[0] == "component", f"URN should start with 'component:': {urn}"
+
+        # Should have wagon and feature separated by colon
+        # Format: component:wagon:feature.rest
+        wagon_feature = f"{parts[1]}:{parts[2].split('.')[0]}"
+        assert ":" in wagon_feature, \
+            f"{artifact_type} URN should use colon between wagon and feature: {urn}"
+
+        # Should NOT contain old format component:wagon.feature
+        assert not urn.startswith(f"component:{parts[1]}."), \
+            f"{artifact_type} URN should not use old dot format after wagon: {urn}"
+
+
+def test_coder_complete_example_updated():
+    """
+    SPEC-CODER-CONV-0013: Complete example section updated with all four component URNs
+
+    Verify the complete_example section has all URNs in new format.
+    """
+    with open(COMPONENT_NAMING_PATH) as f:
+        convention = yaml.safe_load(f)
+
+    complete_example = convention.get("complete_example", {})
+    components = complete_example.get("components", [])
+
+    assert len(components) >= 4, "Should have at least 4 component examples"
+
+    for component in components:
+        urn = component.get("urn", "")
+        name = component.get("name", "")
+
+        # All URNs should use colon format
+        parts = urn.split(":")
+        assert len(parts) >= 3, \
+            f"{name} URN should have at least 3 colon-separated parts: {urn}"
+
+        # Should be component:wagon:feature.component
+        wagon = parts[1]
+        feature_and_rest = parts[2]
+
+        # Verify no dot immediately after component: (old format)
+        assert not urn.startswith(f"component:{wagon}."), \
+            f"{name} URN should not use old format component:wagon.feature: {urn}"
+
+
+def test_green_convention_examples_updated():
+    """
+    SPEC-CODER-CONV-0014: Update coder green.convention.yaml component URN examples
+
+    Verify green convention examples use new colon hierarchy.
+    """
+    with open(GREEN_CONV_PATH) as f:
+        convention = yaml.safe_load(f)
+
+    # urn_naming is nested under green_phase
+    green_phase = convention.get("green_phase", {})
+    examples = green_phase.get("urn_naming", {}).get("examples", [])
+
+    assert len(examples) > 0, "Should have example URNs in green convention"
+
+    for example in examples:
+        urn = example.get("urn", "")
+        wagon = example.get("wagon", "")
+        feature = example.get("feature", "")
+
+        # Should use new format: component:wagon:feature
+        expected_prefix = f"component:{wagon}:{feature}"
+        assert urn.startswith(expected_prefix), \
+            f"URN should use colon hierarchy:\n  URN: {urn}\n  Expected prefix: {expected_prefix}"
+
+        # Should NOT use old format: component:wagon.feature
+        old_format = f"component:{wagon}.{feature}"
+        assert not urn.startswith(old_format), \
+            f"URN should not use old dot format: {urn}"
+
+
+def test_green_convention_pattern_correct():
+    """
+    SPEC-CODER-CONV-0014: Green convention pattern field updated correctly
+
+    Verify the pattern field in green.convention.yaml uses new format.
+    """
+    with open(GREEN_CONV_PATH) as f:
+        convention = yaml.safe_load(f)
+
+    # urn_naming is nested under green_phase
+    green_phase = convention.get("green_phase", {})
+    pattern = green_phase.get("urn_naming", {}).get("pattern", "")
+    description = green_phase.get("urn_naming", {}).get("description", "")
+
+    # Pattern should use colons for hierarchy
+    assert "component:{wagon}:{feature}" in pattern, \
+        f"Pattern should use colons: {pattern}"
+
+    # Description should mention hierarchy via colons
+    assert "hierarchy" in description.lower() or "colon" in description.lower(), \
+        f"Description should mention hierarchy or colons: {description}"

atdd/coder/conventions/tests/test_thinness_recipe.py

@@ -0,0 +1,286 @@
+"""
+Tests for thinness recipe.
+
+Tests SPEC-CODER-UTL-0153 to 042, 053, 056, 057, 058
+ATDD: These tests define expected behavior of thinness recipe BEFORE implementation.
+"""
+import pytest
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+
+
+# Recipe loader utilities
+def load_recipe(recipe_name: str) -> Dict[str, Any]:
+    """
+    Load recipe YAML file.
+
+    SPEC-CODER-UTL-0153: Load thinness 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-0154: Detect when thinness recipe applies
+    """
+    recipe = load_recipe(recipe_name)
+
+    if recipe_name == "thinness":
+        # thinness applies when thinness check fails
+        return smells.get("thinness", {}).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-0155, 041, 042: 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", ""),
+        "next_action": "verify_tests" if step == 1 else ("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-0168: Map handler smell to thinness recipe
+    """
+    # Priority 1: Handler smell → thinness
+    if smells.get("thinness", {}).get("passed", True) is False:
+        return {"recipe": "thinness", "priority": 1}
+
+    # Priority 2: Complexity smell → specification
+    if smells.get("complexity", {}).get("passed", True) is False:
+        return {"recipe": "specification", "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 == "thinness":
+        # Final verification: thinness.check() should pass
+        verification["checks"].append({
+            "check": "thinness.check()",
+            "expected": "passed=true"
+        })
+
+    return verification
+
+
+# TESTS
+
+class TestThinHandlerRecipeLoading:
+    """Test SPEC-CODER-UTL-0153: Load thinness recipe"""
+
+    def test_load_recipe(self):
+        """Should load thinness recipe YAML"""
+        recipe = load_recipe("thinness")
+
+        assert recipe is not None
+        assert recipe["recipe"] == "thinness"
+        assert recipe["pattern"] == "Thin Handler + Use Case"
+        assert "steps" in recipe
+        assert len(recipe["steps"]) == 3
+
+
+class TestThinHandlerRecipeApplies:
+    """Test SPEC-CODER-UTL-0154: Detect when thinness recipe applies"""
+
+    def test_recipe_applies(self):
+        """Should return true when thinness check fails"""
+        smells = {
+            "thinness": {
+                "passed": False,
+                "smells": [
+                    {"line": 10, "reason": "Business logic in handler"}
+                ]
+            }
+        }
+
+        result = check_recipe_applies("thinness", smells)
+
+        assert result is True
+
+    def test_recipe_not_applies(self):
+        """Should return false when thinness check passes"""
+        smells = {
+            "thinness": {
+                "passed": True,
+                "smells": []
+            }
+        }
+
+        result = check_recipe_applies("thinness", smells)
+
+        assert result is False
+
+
+class TestThinHandlerRecipeSteps:
+    """Test SPEC-CODER-UTL-0155, 041, 042: Execute recipe steps"""
+
+    def test_execute_step_1(self):
+        """Should execute step 1: create use case"""
+        context = {"file_path": "presentation/handlers/order.py"}
+
+        result = execute_recipe_step("thinness", 1, context)
+
+        assert result["success"] is True
+        assert "use case" in result["what"].lower()
+        assert "application/" in result["where"]
+        assert result["next_action"] == "verify_tests"
+
+    def test_execute_step_2(self):
+        """Should execute step 2: define port"""
+        context = {"usecase_created": True}
+
+        result = execute_recipe_step("thinness", 2, context)
+
+        assert result["success"] is True
+        assert "port" in result["what"].lower()
+        assert "application/ports/" in result["where"]
+        assert result["next_action"] == "continue"
+
+    def test_execute_step_3(self):
+        """Should execute step 3: thin the handler"""
+        context = {"usecase_created": True, "port_defined": True}
+
+        result = execute_recipe_step("thinness", 3, context)
+
+        assert result["success"] is True
+        assert "thin" in result["what"].lower() or "handler" in result["what"].lower()
+        assert result["next_action"] == "verify_final"
+
+
+class TestThinHandlerRecipeSelection:
+    """Test SPEC-CODER-UTL-0168: Map handler smell to thinness recipe"""
+
+    def test_select_from_smell(self):
+        """Should select thinness recipe when handler smell detected"""
+        smells = {
+            "thinness": {
+                "passed": False,
+                "smells": [{"line": 10, "reason": "Business logic"}]
+            }
+        }
+
+        result = select_recipe(smells)
+
+        assert result["recipe"] == "thinness"
+        assert result["priority"] == 1
+
+
+class TestThinHandlerRecipeVerification:
+    """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 thinness check"""
+        results = {"all_steps_completed": True}
+
+        verification = verify_recipe_final("thinness", results)
+
+        assert verification["success"] is True
+        assert len(verification["checks"]) > 0
+        assert any("thinness" in check["check"] for check in verification["checks"])
+
+
+class TestThinHandlerRecipeIntegration:
+    """Integration tests for full recipe workflow"""
+
+    def test_full_recipe_workflow(self):
+        """Should execute full recipe from detection to verification"""
+        # 1. Detect smell
+        smells = {"thinness": {"passed": False, "smells": [{"line": 10, "reason": "Business logic"}]}}
+
+        # 2. Select recipe
+        selected = select_recipe(smells)
+        assert selected["recipe"] == "thinness"
+
+        # 3. Load recipe
+        recipe = load_recipe("thinness")
+        assert recipe is not None
+
+        # 4. Execute steps
+        context = {}
+        for step in range(1, 4):
+            result = execute_recipe_step("thinness", 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("thinness", {"all_steps": True})
+        assert verification["success"] is True

atdd/coder/conventions/thinness.recipe.yaml

@@ -0,0 +1,82 @@
+recipe: thinness
+pattern: "Thin Handler + Use Case"
+category: presentation_application
+source: "Clean Architecture (Robert C. Martin)"
+utils: "thinness.py"
+
+applies_when:
+  - "Handler contains business logic"
+
+steps:
+  - step: 1
+    what: "Create use case in application layer"
+    where: "application/{feature}_usecase.py"
+    template: |
+      class {Action}UseCase:
+          """Execute {action} business logic."""
+
+          def __init__(self, repo: {Resource}Repository):
+              self.repo = repo
+
+          def execute(self, input: {Action}Input) -> {Resource}:
+              # Business logic here
+              result = {Resource}.create(input)
+              self.repo.save(result)
+              return result
+
+    verify:
+      - run: pytest -xvs tests/application/test_{feature}_usecase.py
+        expect: GREEN
+
+  - step: 2
+    what: "Define port interface (if not exists)"
+    where: "application/ports/{resource}_repository.py"
+    template: |
+      class {Resource}Repository:
+          """Port interface for {resource} persistence."""
+
+          def save(self, entity: {Resource}) -> None:
+              raise NotImplementedError
+
+          def find_by_id(self, id: {Resource}Id) -> {Resource}:
+              raise NotImplementedError
+
+  - step: 3
+    what: "Thin the handler (parse → call → format)"
+    where: "presentation/handlers/{feature}_handler.py"
+    before: |
+      # Fat handler with business logic
+      async def handle_create_order(req: Request) -> Response:
+          order_data = req.body
+          # Validation logic
+          if not order_data.get('customer_id'):
+              return Response(400, "Missing customer")
+          # Business logic (BAD - should be in use case)
+          total = sum(item['price'] * item['qty'] for item in order_data['items'])
+          discount = total * 0.1 if total > 100 else 0
+          final_total = total - discount
+          # Persistence (BAD - should be behind port)
+          db.execute("INSERT INTO orders ...")
+          return Response(201, {"id": order_id})
+
+    after: |
+      # Thin handler
+      async def handle_create_order(req: Request) -> Response:
+          # Parse
+          input = CreateOrderDTO.parse(req.body)
+
+          # Call use case
+          order = create_order_usecase.execute(input)
+
+          # Format
+          return Response(201, CreateOrderDTO.from_domain(order))
+
+    verify:
+      - run: pytest -xvs tests/presentation/test_{feature}_handler.py
+        expect: GREEN
+
+final_verify:
+  - "Handler has NO business logic (only parse/call/format)"
+  - "Use case orchestrates domain + ports"
+  - "All tests GREEN"
+  - "Coverage maintained or improved"