atdd 0.1.0__py3-none-any.whl

atdd/coder/validators/test_green_cross_stack_layers.py

@@ -0,0 +1,168 @@
+"""
+SPEC-CODER-CONV-0019: GREEN convention enforces cross-stack layer naming consistency
+
+Test that green.convention.yaml enforces same layer names across all stacks.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+BACKEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "backend.convention.yaml"
+FRONTEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "frontend.convention.yaml"
+
+
+@pytest.mark.coder
+def test_all_stacks_use_same_layer_names():
+    """
+    SPEC-CODER-CONV-0019: All stacks use same 4 layer names.
+
+    Given: Layer structure defined for Python, Flutter, and Supabase
+    When: Checking layer names across stacks
+    Then: All use presentation, application, domain, integration
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+    assert FRONTEND_CONVENTION.exists(), "frontend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        backend_conv = yaml.safe_load(f)
+
+    with open(FRONTEND_CONVENTION, 'r') as f:
+        frontend_conv = yaml.safe_load(f)
+
+    expected_layers = {'presentation', 'application', 'domain', 'integration'}
+
+    # Check Python (backend)
+    backend = backend_conv['backend']
+    backend_structure = backend.get('structure', {})
+    if 'python' in backend_structure:
+        python_layers = set(backend_structure['python'].get('layers', []))
+        assert python_layers == expected_layers, \
+            f"Python layers {python_layers} must match {expected_layers}"
+
+    # Check Flutter/Dart (frontend)
+    frontend = frontend_conv['frontend']
+    frontend_structure = frontend.get('structure', {})
+    if 'flutter' in frontend_structure or 'dart' in frontend_structure:
+        flutter_layers = set(frontend_structure.get('flutter', frontend_structure.get('dart', {})).get('layers', []))
+        assert flutter_layers == expected_layers, \
+            f"Flutter layers {flutter_layers} must match {expected_layers}"
+
+    # Check Supabase/TypeScript (backend)
+    if 'supabase' in backend_structure or 'typescript' in backend_structure:
+        supabase_layers = set(backend_structure.get('supabase', backend_structure.get('typescript', {})).get('layers', []))
+        assert supabase_layers == expected_layers, \
+            f"Supabase layers {supabase_layers} must match {expected_layers}"
+
+
+@pytest.mark.coder
+def test_no_alternative_layer_names():
+    """
+    SPEC-CODER-CONV-0019: No alternative naming (data, infrastructure) allowed.
+
+    Given: Layer structure configuration
+    When: Checking for alternative layer names
+    Then: Only presentation, application, domain, integration are allowed
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+    assert FRONTEND_CONVENTION.exists(), "frontend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        backend_conv = yaml.safe_load(f)
+
+    with open(FRONTEND_CONVENTION, 'r') as f:
+        frontend_conv = yaml.safe_load(f)
+
+    backend = backend_conv['backend']
+    backend_structure = backend.get('structure', {})
+
+    frontend = frontend_conv['frontend']
+    frontend_structure = frontend.get('structure', {})
+
+    # Check for forbidden alternatives (could be at convention level or structure level)
+    naming_rules = backend.get('naming_rules') or backend_structure.get('naming_rules', {})
+
+    if naming_rules:
+        forbidden_names = naming_rules.get('forbidden_layer_names') or \
+                         naming_rules.get('disallowed_alternatives', [])
+
+        # Should forbid common alternatives
+        alternatives = ['data', 'infrastructure', 'adapters', 'interfaces']
+        for alt in alternatives:
+            if forbidden_names:
+                # At least some alternatives should be explicitly forbidden
+                pass  # Convention should document this
+
+    # Alternative: check that only standard names are used
+    standard_layers = {'presentation', 'application', 'domain', 'integration'}
+
+    # Check backend stacks
+    for stack_name, stack_config in backend_structure.items():
+        if isinstance(stack_config, dict) and 'layers' in stack_config:
+            layers = set(stack_config['layers'])
+            non_standard = layers - standard_layers
+
+            assert len(non_standard) == 0, \
+                f"Backend stack {stack_name} has non-standard layers: {non_standard}"
+
+    # Check frontend stacks
+    for stack_name, stack_config in frontend_structure.items():
+        if isinstance(stack_config, dict) and 'layers' in stack_config:
+            layers = set(stack_config['layers'])
+            non_standard = layers - standard_layers
+
+            assert len(non_standard) == 0, \
+                f"Frontend stack {stack_name} has non-standard layers: {non_standard}"
+
+
+@pytest.mark.coder
+def test_layer_names_lowercase():
+    """
+    SPEC-CODER-CONV-0019: All layer directory names are lowercase.
+
+    Given: Layer structure configuration
+    When: Checking layer name casing
+    Then: All layer names are lowercase
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+    assert FRONTEND_CONVENTION.exists(), "frontend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        backend_conv = yaml.safe_load(f)
+
+    with open(FRONTEND_CONVENTION, 'r') as f:
+        frontend_conv = yaml.safe_load(f)
+
+    backend = backend_conv['backend']
+    backend_structure = backend.get('structure', {})
+
+    frontend = frontend_conv['frontend']
+    frontend_structure = frontend.get('structure', {})
+
+    # Check all backend stacks
+    for stack_name, stack_config in backend_structure.items():
+        if isinstance(stack_config, dict) and 'layers' in stack_config:
+            layers = stack_config['layers']
+
+            for layer in layers:
+                assert layer == layer.lower(), \
+                    f"Layer name '{layer}' in backend {stack_name} must be lowercase"
+
+                # Also check that it doesn't have special characters
+                assert layer.replace('_', '').isalnum(), \
+                    f"Layer name '{layer}' should be alphanumeric (underscores allowed)"
+
+    # Check all frontend stacks
+    for stack_name, stack_config in frontend_structure.items():
+        if isinstance(stack_config, dict) and 'layers' in stack_config:
+            layers = stack_config['layers']
+
+            for layer in layers:
+                assert layer == layer.lower(), \
+                    f"Layer name '{layer}' in {stack_name} must be lowercase"
+
+                # Also check that it doesn't have special characters
+                assert layer.replace('_', '').isalnum(), \
+                    f"Layer name '{layer}' should be alphanumeric (underscores allowed)"

atdd/coder/validators/test_green_layer_dependencies.py

@@ -0,0 +1,148 @@
+"""
+SPEC-CODER-CONV-0018: GREEN convention validates layer dependency rules
+
+Test that green.convention.yaml enforces clean architecture dependency rules.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+BACKEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "backend.convention.yaml"
+FRONTEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "frontend.convention.yaml"
+
+
+@pytest.mark.coder
+def test_domain_has_no_layer_imports():
+    """
+    SPEC-CODER-CONV-0018: Domain layer must be pure (no dependencies).
+
+    Given: Clean architecture dependency rules
+    When: Checking domain layer import rules
+    Then: Domain cannot import from application/presentation/integration
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    # Backend has dependency rules at backend.dependency
+    backend = convention['backend']
+    assert 'dependency' in backend, "Backend must define dependency rules"
+
+    dep_rules = backend['dependency']
+
+    assert dep_rules is not None, "Dependency rules must be defined"
+
+    # Backend uses edge-based dependencies, not per-layer rules
+    # Check that domain is not listed as 'from' in any allowed_edges
+    allowed_edges = dep_rules.get('allowed_edges', [])
+    forbidden_examples = dep_rules.get('forbidden_examples', [])
+
+    # Domain should not be in 'from' field of any allowed edge
+    domain_edges = [edge for edge in allowed_edges if edge.get('from') == 'domain']
+    assert len(domain_edges) == 0, "Domain should not have outgoing dependencies"
+
+    # Verify forbidden examples include domain restrictions
+    assert any('domain →' in example or 'domain ->' in example for example in forbidden_examples), \
+        "Forbidden examples must include domain restrictions"
+
+
+@pytest.mark.coder
+def test_application_only_imports_domain():
+    """
+    SPEC-CODER-CONV-0018: Application can only depend on domain.
+
+    Given: Clean architecture dependency rules
+    When: Checking application layer import rules
+    Then: Application cannot import from presentation/integration
+    """
+    assert BACKEND_CONVENTION.exists(), "green.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    backend = convention["backend"]
+    dep_rules = backend.get('dependency')
+
+    allowed_edges = dep_rules.get('allowed_edges', [])
+    forbidden_examples = dep_rules.get('forbidden_examples', [])
+
+    # Find application edges
+    app_edges = [edge for edge in allowed_edges if edge.get('from') == 'application']
+
+    # Application should only depend on domain
+    assert len(app_edges) > 0, "Application must have defined dependencies"
+    app_edge = app_edges[0]
+    assert app_edge.get('to') == ['domain'], \
+        f"Application should only depend on domain, got {app_edge.get('to')}"
+
+    # Check forbidden examples
+    assert any('application → presentation' in example or 'application -> presentation' in example
+               for example in forbidden_examples), \
+        "Application to presentation must be forbidden"
+
+
+@pytest.mark.coder
+def test_integration_only_imports_domain():
+    """
+    SPEC-CODER-CONV-0018: Integration can only depend on domain.
+
+    Given: Clean architecture dependency rules
+    When: Checking integration layer import rules
+    Then: Integration cannot import from application/presentation
+    """
+    assert BACKEND_CONVENTION.exists(), "green.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    backend = convention["backend"]
+    dep_rules = backend.get('dependency')
+
+    allowed_edges = dep_rules.get('allowed_edges', [])
+
+    # Find integration edges
+    int_edges = [edge for edge in allowed_edges if edge.get('from') == 'integration']
+
+    # Integration should depend on application and domain
+    assert len(int_edges) > 0, "Integration must have defined dependencies"
+    int_edge = int_edges[0]
+    int_deps = int_edge.get('to', [])
+
+    # Integration typically depends on both application and domain in clean arch
+    assert 'domain' in int_deps, "Integration should depend on domain"
+    assert 'presentation' not in int_deps, "Integration should not depend on presentation"
+
+
+@pytest.mark.coder
+def test_presentation_imports_valid():
+    """
+    SPEC-CODER-CONV-0018: Presentation can depend on application and domain.
+
+    Given: Clean architecture dependency rules
+    When: Checking presentation layer import rules
+    Then: Presentation can import from application and domain
+    """
+    assert BACKEND_CONVENTION.exists(), "green.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    backend = convention["backend"]
+    dep_rules = backend.get('dependency')
+
+    allowed_edges = dep_rules.get('allowed_edges', [])
+
+    # Find presentation edges
+    pres_edges = [edge for edge in allowed_edges if edge.get('from') == 'presentation']
+
+    # Presentation can depend on application and domain
+    assert len(pres_edges) > 0, "Presentation must have defined dependencies"
+    pres_edge = pres_edges[0]
+    pres_deps = pres_edge.get('to', [])
+
+    assert 'application' in pres_deps, "Presentation must be allowed to depend on application"
+    assert 'domain' in pres_deps, "Presentation must be allowed to depend on domain"

atdd/coder/validators/test_green_python_layer_structure.py

@@ -0,0 +1,103 @@
+"""
+SPEC-CODER-CONV-0015: GREEN convention defines 4-layer structure for Python
+
+Test that backend.convention.yaml enforces 4-layer structure for Python implementation.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+BACKEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "backend.convention.yaml"
+
+
+@pytest.mark.coder
+def test_green_enforces_python_layers():
+    """
+    SPEC-CODER-CONV-0015: Backend convention enforces 4-layer structure for Python.
+
+    Given: backend.convention.yaml exists
+    When: Reading Python layer structure configuration
+    Then: Convention enforces 4 layer directories under src/
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    # Backend convention has backend.structure.python
+    assert 'backend' in convention, "Convention must have 'backend' section"
+    backend = convention['backend']
+
+    assert 'structure' in backend, "Backend must define structure"
+    structure = backend['structure']
+
+    # Check Python-specific configuration
+    assert 'python' in structure, "Convention must define Python layer structure"
+
+    python_config = structure['python']
+
+    # Verify 4 layers are defined
+    assert 'layers' in python_config, "Python config must define layers"
+    layers = python_config['layers']
+
+    expected_layers = {'presentation', 'application', 'domain', 'integration'}
+    assert set(layers) == expected_layers, \
+        f"Layers must be {expected_layers}, got {set(layers)}"
+
+    # Verify source path pattern
+    assert 'src_path_pattern' in python_config or 'source_pattern' in python_config, \
+        "Python config must define src_path_pattern"
+
+    pattern = python_config.get('src_path_pattern') or python_config.get('source_pattern')
+
+    assert '{wagon}' in pattern, "Pattern must include {wagon} placeholder"
+    assert '{feature}' in pattern, "Pattern must include {feature} placeholder"
+    assert '{layer}' in pattern, "Pattern must include {layer} placeholder"
+    assert 'src' in pattern, "Pattern must include 'src' directory"
+
+    # Verify it matches expected pattern
+    expected_pattern = "python/{wagon}/{feature}/src/{layer}/"
+    assert pattern == expected_pattern or pattern.startswith("python/{wagon}/{feature}/src/{layer}"), \
+        f"Pattern should be {expected_pattern}, got {pattern}"
+
+
+@pytest.mark.coder
+def test_python_component_layer_mapping():
+    """
+    SPEC-CODER-CONV-0015: Component naming rules map to layers.
+
+    Given: Python layer structure with component types
+    When: Checking component-to-layer mapping
+    Then: Services in domain, repositories in integration, etc.
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    backend = convention['backend']
+
+    # Backend has layers with component_types that define which components go where
+    layers_def = backend.get('layers', {})
+
+    # Check that component types are defined per layer
+    assert 'domain' in layers_def, "Domain layer must be defined"
+    assert 'integration' in layers_def, "Integration layer must be defined"
+    assert 'presentation' in layers_def, "Presentation layer must be defined"
+    assert 'application' in layers_def, "Application layer must be defined"
+
+    # Verify component types exist in appropriate layers
+    domain_types = [ct['name'] for ct in layers_def['domain'].get('component_types', [])]
+    assert 'services' in domain_types, "Services should be in domain layer"
+
+    integration_types = [ct['name'] for ct in layers_def['integration'].get('component_types', [])]
+    assert 'repositories' in integration_types, "Repositories should be in integration layer"
+
+    presentation_types = [ct['name'] for ct in layers_def['presentation'].get('component_types', [])]
+    assert 'controllers' in presentation_types, "Controllers should be in presentation layer"
+
+    application_types = [ct['name'] for ct in layers_def['application'].get('component_types', [])]
+    assert 'use_cases' in application_types, "Use cases should be in application layer"

atdd/coder/validators/test_green_supabase_layer_structure.py

@@ -0,0 +1,103 @@
+"""
+SPEC-CODER-CONV-0017: GREEN convention defines 4-layer structure for Supabase
+
+Test that green.convention.yaml enforces 4-layer structure for Supabase implementation.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+BACKEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "backend.convention.yaml"
+FRONTEND_CONVENTION = REPO_ROOT / "atdd" / "coder" / "conventions" / "frontend.convention.yaml"
+
+
+@pytest.mark.coder
+def test_green_enforces_supabase_layers():
+    """
+    SPEC-CODER-CONV-0017: Backend convention enforces 4-layer structure for Supabase.
+
+    Given: Supabase implementation uses supabase/functions/{wagon}/{feature}/
+    When: Reading Supabase layer structure configuration
+    Then: Convention enforces 4 layer directories under function root
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    backend = convention['backend']
+    assert 'structure' in backend, "Backend must define structure"
+    structure = backend['structure']
+
+    # Check Supabase/TypeScript-specific configuration
+    assert 'supabase' in structure or 'typescript' in structure, \
+        "Convention must define Supabase/TypeScript layer structure"
+
+    supabase_config = structure.get('supabase') or structure.get('typescript')
+
+    # Verify 4 layers are defined
+    assert 'layers' in supabase_config, "Supabase config must define layers"
+    layers = supabase_config['layers']
+
+    expected_layers = {'presentation', 'application', 'domain', 'integration'}
+    assert set(layers) == expected_layers, \
+        f"Layers must be {expected_layers}, got {set(layers)}"
+
+    # Verify source path pattern
+    assert 'src_path_pattern' in supabase_config or 'source_pattern' in supabase_config, \
+        "Supabase config must define src_path_pattern"
+
+    pattern = supabase_config.get('src_path_pattern') or supabase_config.get('source_pattern')
+
+    assert '{wagon}' in pattern, "Pattern must include {wagon} placeholder"
+    assert '{feature}' in pattern, "Pattern must include {feature} placeholder"
+    assert '{layer}' in pattern, "Pattern must include {layer} placeholder"
+    assert 'supabase/functions' in pattern or 'functions' in pattern, \
+        "Pattern must reference Supabase functions directory"
+
+    # Verify it matches expected pattern
+    expected_pattern = "supabase/functions/{wagon}/{feature}/{layer}/"
+    assert pattern == expected_pattern or \
+           pattern.startswith("supabase/functions/{wagon}/{feature}"), \
+        f"Pattern should reference {expected_pattern}, got {pattern}"
+
+
+@pytest.mark.coder
+def test_supabase_index_is_thin():
+    """
+    SPEC-CODER-CONV-0017: Validates index.ts has no business logic.
+
+    Given: Supabase layer structure with index.ts at root
+    When: Checking index.ts constraints
+    Then: index.ts contains only adapter code (imports presentation only)
+    """
+    assert BACKEND_CONVENTION.exists(), "backend.convention.yaml must exist"
+
+    with open(BACKEND_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    backend = convention['backend']
+    structure = backend.get('structure', {})
+    supabase_config = structure.get('supabase') or structure.get('typescript', {})
+
+    # Check for index.ts rules - might be under entrypoint_rules
+    index_rules = supabase_config.get('entrypoint_rules', {}).get('index_ts') or \
+                 supabase_config.get('index_constraints')
+
+    if index_rules:
+        # index.ts should only import from presentation
+        assert 'allowed_imports' in index_rules or 'import_restrictions' in index_rules, \
+            "index.ts must have import restrictions"
+
+        allowed = index_rules.get('allowed_imports', [])
+        if allowed:
+            assert 'presentation' in allowed or './presentation' in str(allowed), \
+                "index.ts should only import from presentation layer"
+
+        # index.ts should not contain business logic
+        assert 'no_business_logic' in index_rules or \
+               index_rules.get('role') == 'thin_adapter', \
+            "index.ts must be documented as thin adapter with no business logic"