atdd 0.1.0__py3-none-any.whl

atdd/tester/validators/test_python_test_naming.py

@@ -0,0 +1,410 @@
+"""
+Test Python test files follow naming conventions.
+
+Validates:
+- Test files are named test_*.py
+- Test files are in test/ or tests/ directories (accept both singular and plural)
+- Test files have mandatory slugs (test_{wmbt}_{harness}_{nnn}_{slug}.py)
+- Test functions start with test_
+- Test classes start with Test
+
+Inspired by: .claude/utils/tester/filename.py
+But: Self-contained, no utility dependencies
+"""
+
+import pytest
+import re
+from pathlib import Path
+
+
+# Path constants
+REPO_ROOT = Path(__file__).resolve().parents[4]
+PYTHON_DIR = REPO_ROOT / "python"
+
+
+def find_test_files() -> list:
+    """
+    Find all test files in python/ directory.
+
+    Returns:
+        List of Path objects pointing to test files
+    """
+    if not PYTHON_DIR.exists():
+        return []
+
+    test_files = []
+
+    # Find test files
+    for py_file in PYTHON_DIR.rglob("*.py"):
+        # Check if in test directory or named test_*
+        if '/test/' in str(py_file) or py_file.name.startswith('test_'):
+            test_files.append(py_file)
+
+    return test_files
+
+
+def extract_test_functions(file_path: Path) -> list:
+    """
+    Extract test function names from Python file.
+
+    Args:
+        file_path: Path to test file
+
+    Returns:
+        List of function names
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception:
+        return []
+
+    # Match: def test_something(...):
+    # or: async def test_something(...):
+    functions = re.findall(r'(?:async\s+)?def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(', content)
+
+    return functions
+
+
+def extract_test_classes(file_path: Path) -> list:
+    """
+    Extract test class names from Python file.
+
+    Args:
+        file_path: Path to test file
+
+    Returns:
+        List of class names
+    """
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception:
+        return []
+
+    # Match: class TestSomething(...):
+    classes = re.findall(r'class\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*[:\(]', content)
+
+    return classes
+
+
+@pytest.mark.tester
+def test_python_test_files_named_correctly():
+    """
+    SPEC-TESTER-NAMING-0001: Python test files follow naming convention.
+
+    Convention:
+    - Test files must be named test_*.py
+    - Test files should be in test/ or tests/ directories (both accepted)
+
+    Given: Python test files
+    When: Checking file names
+    Then: All test files follow convention
+    """
+    test_files = find_test_files()
+
+    if not test_files:
+        pytest.skip("No Python test files found")
+
+    violations = []
+
+    for test_file in test_files:
+        filename = test_file.name
+
+        # Skip special pytest files
+        if filename in ['conftest.py', '__init__.py']:
+            continue
+
+        # Check naming convention
+        if not filename.startswith('test_') and not filename.endswith('_test.py'):
+            violations.append(
+                f"{test_file.relative_to(REPO_ROOT)}\\n"
+                f"  Issue: Test file should be named test_*.py\\n"
+                f"  Found: {filename}"
+            )
+
+        # Check if in test/ or tests/ directory (accept both singular and plural)
+        if '/test/' not in str(test_file) and '/tests/' not in str(test_file):
+            violations.append(
+                f"{test_file.relative_to(REPO_ROOT)}\\n"
+                f"  Issue: Test file should be in test/ or tests/ directory\\n"
+                f"  Found: Not in test/ or tests/ directory"
+            )
+
+    if violations:
+        pytest.fail(
+            f"\\n\\nFound {len(violations)} naming violations:\\n\\n" +
+            "\\n\\n".join(violations[:10]) +
+            (f"\\n\\n... and {len(violations) - 10} more" if len(violations) > 10 else "")
+        )
+
+
+@pytest.mark.tester
+def test_python_test_functions_named_correctly():
+    """
+    SPEC-TESTER-NAMING-0002: Python test functions follow naming convention.
+
+    Convention:
+    - Test functions must start with test_
+    - Test functions should use snake_case
+    - Test functions should be descriptive
+
+    Given: Python test files
+    When: Checking function names
+    Then: All test functions follow convention
+    """
+    test_files = find_test_files()
+
+    if not test_files:
+        pytest.skip("No Python test files found")
+
+    violations = []
+
+    for test_file in test_files:
+        functions = extract_test_functions(test_file)
+
+        for func_name in functions:
+            # Skip helper functions (private)
+            if func_name.startswith('_'):
+                continue
+
+            # Skip fixture functions
+            if func_name in ['setup', 'teardown', 'setup_class', 'teardown_class',
+                            'setup_method', 'teardown_method']:
+                continue
+
+            # Check if test function follows convention
+            if not func_name.startswith('test_'):
+                # Not a test function (could be helper)
+                continue
+
+            # Check snake_case (allow uppercase for WMBT codes like E003, UNIT, etc.)
+            # Pattern accepts: test_e003_unit_001_... OR test_E003_UNIT_001_...
+            if not re.match(r'^test_[a-zA-Z0-9_]+$', func_name):
+                violations.append(
+                    f"{test_file.relative_to(REPO_ROOT)}\\n"
+                    f"  Function: {func_name}\\n"
+                    f"  Issue: Test function should start with test_ and use alphanumeric_underscore pattern"
+                )
+
+            # Check if too short
+            if len(func_name) < 10:
+                violations.append(
+                    f"{test_file.relative_to(REPO_ROOT)}\\n"
+                    f"  Function: {func_name}\\n"
+                    f"  Issue: Test function name too short (should be descriptive)"
+                )
+
+    if violations:
+        pytest.fail(
+            f"\\n\\nFound {len(violations)} function naming violations:\\n\\n" +
+            "\\n\\n".join(violations[:10]) +
+            (f"\\n\\n... and {len(violations) - 10} more" if len(violations) > 10 else "")
+        )
+
+
+@pytest.mark.tester
+def test_python_test_classes_named_correctly():
+    """
+    SPEC-TESTER-NAMING-0003: Python test classes follow naming convention.
+
+    Convention:
+    - Test classes must start with Test
+    - Test classes should use PascalCase
+    - Test classes should be descriptive
+
+    Given: Python test files
+    When: Checking class names
+    Then: All test classes follow convention
+    """
+    test_files = find_test_files()
+
+    if not test_files:
+        pytest.skip("No Python test files found")
+
+    violations = []
+
+    for test_file in test_files:
+        classes = extract_test_classes(test_file)
+
+        for class_name in classes:
+            # Skip if not a test class (could be helper)
+            if not class_name.startswith('Test'):
+                continue
+
+            # Check PascalCase
+            if not re.match(r'^Test[A-Z][a-zA-Z0-9]*$', class_name):
+                violations.append(
+                    f"{test_file.relative_to(REPO_ROOT)}\\n"
+                    f"  Class: {class_name}\\n"
+                    f"  Issue: Test class should use PascalCase after 'Test'"
+                )
+
+            # Check if too short
+            if len(class_name) < 8:  # Test + at least 3 chars
+                violations.append(
+                    f"{test_file.relative_to(REPO_ROOT)}\\n"
+                    f"  Class: {class_name}\\n"
+                    f"  Issue: Test class name too short (should be descriptive)"
+                )
+
+    if violations:
+        pytest.fail(
+            f"\\n\\nFound {len(violations)} class naming violations:\\n\\n" +
+            "\\n\\n".join(violations[:10]) +
+            (f"\\n\\n... and {len(violations) - 10} more" if len(violations) > 10 else "")
+        )
+
+
+@pytest.mark.tester
+def test_python_test_files_have_mandatory_slugs():
+    """
+    SPEC-TESTER-NAMING-0004: Python test files in feature-based structure have mandatory slugs.
+
+    Convention (from filename.convention.yaml):
+    - Pattern: test_{wmbt_lower}_{harness_lower}_{nnn}_{slug_snake}.py
+    - Slug is MANDATORY (not optional)
+    - Slug derived from acceptance.identity.purpose
+    - Example: test_l001_unit_001_uuid_v7_generation_completes_within.py
+
+    Given: Python test files in python/{wagon}/{feature}/test/ directories
+    When: Checking file names
+    Then: All test files include mandatory slug component
+    """
+    test_files = find_test_files()
+
+    if not test_files:
+        pytest.skip("No Python test files found")
+
+    violations = []
+
+    # Pattern: test_{wmbt}_{harness}_{nnn}_{slug}.py
+    # WMBT: 1-4 letters (L, P, C, etc.) followed by 3 digits
+    # Harness: unit, integration, load, http, e2e, etc.
+    # NNN: 3 digits (001, 002, etc.)
+    # Slug: descriptive snake_case (MANDATORY)
+    slug_pattern = re.compile(
+        r'^test_([a-z]\d{3})_([a-z]+)_(\d{3})_([a-z][a-z0-9_]+)\.py$'
+    )
+
+    for test_file in test_files:
+        filename = test_file.name
+
+        # Skip special pytest files and wagon-level tests
+        if filename in ['conftest.py', '__init__.py', 'test_contracts.py', 'test_telemetry.py']:
+            continue
+
+        # Only check files in feature-based structure: python/{wagon}/{feature}/test/
+        test_path_str = str(test_file)
+        if '/python/' not in test_path_str or '/test/' not in test_path_str:
+            continue
+
+        # Check if in feature-based directory structure
+        parts = test_file.parts
+        try:
+            python_idx = parts.index('python')
+            # Feature-based: python/{wagon}/{feature}/test/
+            if len(parts) > python_idx + 3 and parts[python_idx + 3] == 'test':
+                # This is a feature-based test file
+                match = slug_pattern.match(filename)
+
+                if not match:
+                    # Try to parse what we have
+                    basic_pattern = re.compile(r'^test_([a-z]\d{3})_([a-z]+)_(\d{3})\.py$')
+                    basic_match = basic_pattern.match(filename)
+
+                    if basic_match:
+                        wmbt = basic_match.group(1)
+                        harness = basic_match.group(2)
+                        nnn = basic_match.group(3)
+                        violations.append(
+                            f"{test_file.relative_to(REPO_ROOT)}\n"
+                            f"  Issue: Missing mandatory slug component\n"
+                            f"  Pattern: test_{{wmbt}}_{{harness}}_{{nnn}}_{{slug}}.py\n"
+                            f"  Found: test_{wmbt}_{harness}_{nnn}.py (no slug)\n"
+                            f"  Expected: test_{wmbt}_{harness}_{nnn}_<descriptive_slug>.py\n"
+                            f"  Note: Slug must be derived from acceptance.identity.purpose"
+                        )
+                    else:
+                        violations.append(
+                            f"{test_file.relative_to(REPO_ROOT)}\n"
+                            f"  Issue: Does not match required pattern\n"
+                            f"  Pattern: test_{{wmbt}}_{{harness}}_{{nnn}}_{{slug}}.py\n"
+                            f"  Found: {filename}\n"
+                            f"  Note: All 4 components required (wmbt, harness, nnn, slug)"
+                        )
+        except (ValueError, IndexError):
+            # Not in feature-based structure, skip
+            continue
+
+    if violations:
+        pytest.fail(
+            f"\n\nFound {len(violations)} test files without mandatory slugs:\n\n" +
+            "\n\n".join(violations[:10]) +
+            (f"\n\n... and {len(violations) - 10} more" if len(violations) > 10 else "") +
+            "\n\nSlug Convention:\n" +
+            "- Slugs are MANDATORY (not optional)\n" +
+            "- Derived from acceptance.identity.purpose field\n" +
+            "- Process: Remove 'Verify', lowercase, replace spaces with underscores\n" +
+            "- Example: 'Verify UUID v7 generation completes within' → 'uuid_v7_generation_completes_within'"
+        )
+
+
+@pytest.mark.tester
+def test_python_test_files_are_in_correct_locations():
+    """
+    SPEC-TESTER-NAMING-0004: Test files are in correct locations.
+
+    Convention:
+    - Test files should be in {module}/test/ directory
+    - Test files should mirror source structure when possible
+
+    Given: Python test files
+    When: Checking locations
+    Then: Test files are in appropriate test/ directories
+    """
+    test_files = find_test_files()
+
+    if not test_files:
+        pytest.skip("No Python test files found")
+
+    violations = []
+
+    for test_file in test_files:
+        # Check if in test/ or tests/ directory (accept both)
+        if '/test/' not in str(test_file) and '/tests/' not in str(test_file):
+            violations.append(
+                f"{test_file.relative_to(REPO_ROOT)}\\n"
+                f"  Issue: Test file not in test/ or tests/ directory"
+            )
+
+        # Check if test file has corresponding source structure
+        # Example: module/test/test_foo.py should have module/src/foo.py
+        # Accept both test/ and tests/ directories
+        if ('/test/' in str(test_file) or '/tests/' in str(test_file)) and test_file.name.startswith('test_'):
+            # Get potential source file name
+            source_name = test_file.name.replace('test_', '', 1)
+            test_dir = test_file.parent
+
+            # Check for src/ sibling
+            module_root = test_dir.parent
+            src_dir = module_root / 'src'
+
+            if src_dir.exists():
+                # Look for corresponding source file
+                potential_source = src_dir / source_name
+                # Also check subdirectories (domain, application, etc.)
+                source_exists = potential_source.exists() or \
+                              any((src_dir / subdir / source_name).exists()
+                                  for subdir in ['domain', 'application', 'integration', 'presentation'])
+
+                if not source_exists and source_name != '__init__.py':
+                    # This might be okay (integration tests, etc.) so just warn
+                    pass  # Don't fail, just note
+
+    if violations:
+        pytest.fail(
+            f"\\n\\nFound {len(violations)} location violations:\\n\\n" +
+            "\\n\\n".join(violations[:10]) +
+            (f"\\n\\n... and {len(violations) - 10} more" if len(violations) > 10 else "")
+        )

atdd/tester/validators/test_red_layer_validation.py

@@ -0,0 +1,95 @@
+"""
+SPEC-TESTER-CONV-0082: RED convention rejects tests not in layer structure
+
+Test that red.convention.yaml validates tests are in correct layer directories.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+RED_CONVENTION = REPO_ROOT / "atdd" / "tester" / "conventions" / "red.convention.yaml"
+
+
+@pytest.mark.tester
+def test_rejects_non_layered_python_tests():
+    """
+    SPEC-TESTER-CONV-0082: RED convention rejects Python tests not in layer structure.
+
+    Given: Test file generated outside layer directory
+    When: Validating test structure
+    Then: Convention validation fails with error message
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+    assert structure is not None, "Convention must define test structure"
+
+    python_config = structure.get('python', {})
+
+    # Check for validation rules
+    validation = python_config.get('validation') or convention.get('validation', {})
+
+    # Should reject tests without layer directory
+    assert 'require_layer_directory' in validation or \
+           validation.get('enforce_layer_structure') == True, \
+        "Convention must enforce layer directory requirement"
+
+    # Check for error message configuration
+    assert 'error_messages' in validation or 'messages' in validation, \
+        "Convention must define error messages for violations"
+
+
+@pytest.mark.tester
+def test_rejects_non_layered_flutter_tests():
+    """
+    SPEC-TESTER-CONV-0082: RED convention rejects Flutter tests not in layer structure.
+
+    Given: Flutter test file outside layer directory
+    When: Validating test structure
+    Then: Convention validation fails
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+    flutter_config = structure.get('flutter') or structure.get('dart', {})
+
+    validation = flutter_config.get('validation') or convention.get('validation', {})
+
+    # Should reject tests without layer directory
+    assert 'require_layer_directory' in validation or \
+           validation.get('enforce_layer_structure') == True, \
+        "Convention must enforce layer directory requirement for Flutter"
+
+
+@pytest.mark.tester
+def test_rejects_non_layered_supabase_tests():
+    """
+    SPEC-TESTER-CONV-0082: RED convention rejects Supabase tests not in layer structure.
+
+    Given: Supabase test file outside layer directory
+    When: Validating test structure
+    Then: Convention validation fails
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+    supabase_config = structure.get('supabase') or structure.get('typescript', {})
+
+    validation = supabase_config.get('validation') or convention.get('validation', {})
+
+    # Should reject tests without layer directory
+    assert 'require_layer_directory' in validation or \
+           validation.get('enforce_layer_structure') == True, \
+        "Convention must enforce layer directory requirement for Supabase"

atdd/tester/validators/test_red_python_layer_structure.py

@@ -0,0 +1,87 @@
+"""
+SPEC-TESTER-CONV-0079: RED convention defines 4-layer test structure for Python
+
+Test that red.convention.yaml enforces 4-layer test structure for Python.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+RED_CONVENTION = REPO_ROOT / "atdd" / "tester" / "conventions" / "red.convention.yaml"
+
+
+@pytest.mark.tester
+def test_red_defines_python_layer_structure():
+    """
+    SPEC-TESTER-CONV-0079: RED convention defines 4-layer test structure for Python.
+
+    Given: red.convention.yaml exists
+    When: Reading Python test structure configuration
+    Then: Convention specifies test structure python/{wagon}/{feature}/tests/{layer}/
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    # Check for layer structure definition
+    assert 'layer_structure' in convention or 'test_structure' in convention, \
+        "Convention must define layer_structure or test_structure"
+
+    # Get structure config
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+
+    # Check Python-specific configuration
+    assert 'python' in structure, "Convention must define Python test 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 test path pattern
+    assert 'test_path_pattern' in python_config, "Python config must define test_path_pattern"
+    pattern = python_config['test_path_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 'tests' in pattern, "Pattern must include 'tests' directory"
+
+    # Verify it matches expected pattern
+    expected_pattern = "python/{wagon}/{feature}/tests/{layer}/"
+    assert pattern == expected_pattern or pattern.startswith("python/{wagon}/{feature}/tests/{layer}"), \
+        f"Pattern should be {expected_pattern}, got {pattern}"
+
+
+@pytest.mark.tester
+def test_red_creates_layer_directories():
+    """
+    SPEC-TESTER-CONV-0079: Test path generation creates layer directories automatically.
+
+    Given: red.convention.yaml with layer structure
+    When: Generating test paths
+    Then: Layer directories are created automatically
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+    assert structure is not None, "Convention must define test structure"
+
+    python_config = structure.get('python', {})
+
+    # Check for auto-create configuration
+    assert 'auto_create_directories' in python_config or \
+           python_config.get('behavior', {}).get('create_layer_dirs') == True, \
+        "Convention must specify that layer directories are auto-created"

atdd/tester/validators/test_red_supabase_layer_structure.py

@@ -0,0 +1,90 @@
+"""
+SPEC-TESTER-CONV-0081: RED convention defines 4-layer test structure for Supabase
+
+Test that red.convention.yaml enforces 4-layer test structure for Supabase.
+"""
+
+import pytest
+from pathlib import Path
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+RED_CONVENTION = REPO_ROOT / "atdd" / "tester" / "conventions" / "red.convention.yaml"
+
+
+@pytest.mark.tester
+def test_red_defines_supabase_layer_structure():
+    """
+    SPEC-TESTER-CONV-0081: RED convention defines 4-layer test structure for Supabase.
+
+    Given: Supabase structure is supabase/functions/{wagon}/{feature}/
+    When: Reading Supabase test structure configuration
+    Then: Convention specifies test structure supabase/functions/{wagon}/{feature}/tests/{layer}/
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+    assert structure is not None, "Convention must define test structure"
+
+    # Check Supabase/TypeScript-specific configuration
+    assert 'supabase' in structure or 'typescript' in structure, \
+        "Convention must define Supabase/TypeScript test 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 test path pattern
+    assert 'test_path_pattern' in supabase_config, "Supabase config must define test_path_pattern"
+    pattern = supabase_config['test_path_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 'tests' in pattern, "Pattern must include 'tests' directory"
+    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}/tests/{layer}/"
+    assert pattern == expected_pattern or \
+           pattern.startswith("supabase/functions/{wagon}/{feature}/tests/{layer}"), \
+        f"Pattern should be {expected_pattern}, got {pattern}"
+
+
+@pytest.mark.tester
+def test_http_tests_in_presentation():
+    """
+    SPEC-TESTER-CONV-0081: HTTP handler tests go in presentation layer.
+
+    Given: Supabase layer structure
+    When: Determining layer for HTTP handler tests
+    Then: HTTP tests are placed in presentation layer
+    """
+    assert RED_CONVENTION.exists(), "red.convention.yaml must exist"
+
+    with open(RED_CONVENTION, 'r') as f:
+        convention = yaml.safe_load(f)
+
+    structure = convention.get('layer_structure') or convention.get('test_structure')
+    supabase_config = structure.get('supabase') or structure.get('typescript', {})
+
+    # Check for layer mapping rules
+    layer_mapping = supabase_config.get('layer_mapping') or supabase_config.get('test_type_layers')
+
+    if layer_mapping:
+        # HTTP/controller tests should map to presentation
+        assert layer_mapping.get('http') == 'presentation' or \
+               layer_mapping.get('controller') == 'presentation' or \
+               'http' in layer_mapping.get('presentation', []), \
+            "HTTP handler tests must be in presentation layer"