atdd 0.1.0__py3-none-any.whl

atdd/tester/validators/test_migration_criteria.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""
+Test migration criteria decision algorithm.
+
+SPEC-TESTER-CONV-0034 through SPEC-TESTER-CONV-0043
+
+Validates the contract_needs_migration() function correctly applies
+all decision rules in the proper order.
+"""
+
+import json
+import pytest
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+# pytest pythonpath = . handles imports from repo root
+
+from atdd.coach.commands.migration import contract_needs_migration
+
+
+def create_test_contract(properties: dict, metadata: dict = None, description: str = "", aspect: str = "test") -> Path:
+    """Create a temporary contract file for testing."""
+    contract = {
+        "$id": f"urn:contract:test:domain:{aspect}",
+        "properties": properties,
+        "description": description
+    }
+
+    if metadata:
+        contract["x-artifact-metadata"] = metadata
+
+    # Create temp file with proper naming: {aspect}.schema.json
+    temp = NamedTemporaryFile(mode='w', suffix=f'{aspect}.schema.json', delete=False)
+    json.dump(contract, temp, indent=2)
+    temp.close()
+
+    return Path(temp.name)
+
+
+# SPEC-TESTER-CONV-0034
+def test_entity_with_id_requires_migration():
+    """Entity with id field requires migration."""
+    contract_path = create_test_contract(
+        properties={
+            "id": {"type": "string", "pattern": "^[0-9a-f]{8}"},
+            "player_id": {"type": "string"},
+            "status": {"type": "string"}
+        },
+        aspect="session"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == True
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0035
+def test_event_signals_no_migration():
+    """Event signals (past tense, no id) do not require migration."""
+    # Test multiple event patterns
+    event_aspects = ["exhausted", "succeeded", "failed", "registered", "terminated"]
+
+    for aspect in event_aspects:
+        contract_path = create_test_contract(
+            properties={
+                "timestamp": {"type": "string", "format": "date-time"},
+                "player_id": {"type": "string"}
+            },
+            aspect=aspect
+        )
+
+        try:
+            assert contract_needs_migration(contract_path) == False, f"{aspect} should not require migration"
+        finally:
+            contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0036
+def test_empty_contracts_no_migration():
+    """Empty contracts (pure signals) do not require migration."""
+    contract_path = create_test_contract(
+        properties={},
+        aspect="exhausted"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0037
+def test_value_objects_no_migration():
+    """Value objects without id do not require migration."""
+    # Test uuid value object
+    contract_path = create_test_contract(
+        properties={
+            "value": {"type": "string", "pattern": "^[0-9a-f]{8}"}
+        },
+        aspect="uuid"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+    # Test evaluation-score value object
+    contract_path = create_test_contract(
+        properties={
+            "score": {"type": "number"},
+            "confidence": {"type": "number"}
+        },
+        aspect="evaluation-score"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0038
+def test_internal_contracts_no_migration():
+    """Internal contracts (transient DTOs) do not require migration."""
+    contract_path = create_test_contract(
+        properties={
+            "player_id": {"type": "string"},
+            "data": {"type": "object"}
+        },
+        metadata={"to": "internal"},
+        aspect="dto"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0039
+def test_explicit_persistent_flag():
+    """Explicit persistence.strategy: jsonb overrides all heuristics."""
+    # Event pattern BUT persistence.strategy: jsonb → needs migration
+    contract_path = create_test_contract(
+        properties={
+            "timestamp": {"type": "string"}
+        },
+        metadata={"persistence": {"strategy": "jsonb"}},
+        aspect="completed"  # Event pattern
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == True
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0040
+def test_explicit_non_persistent_flag():
+    """Explicit persistence.strategy: none prevents migration."""
+    # Has id BUT persistence.strategy: none → no migration
+    contract_path = create_test_contract(
+        properties={
+            "id": {"type": "string"},
+            "data": {"type": "object"}
+        },
+        metadata={"persistence": {"strategy": "none"}},
+        aspect="entity"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0041
+def test_id_overrides_event_pattern():
+    """Entity with id overrides event naming pattern."""
+    # Aspect is "paused" (event pattern) BUT has id → needs migration
+    contract_path = create_test_contract(
+        properties={
+            "id": {"type": "string"},
+            "session_id": {"type": "string"},
+            "paused_at": {"type": "string", "format": "date-time"}
+        },
+        aspect="paused"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == True
+    finally:
+        contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0042
+def test_computed_aggregates_no_migration():
+    """Computed aggregates without id do not require migration."""
+    computed_keywords = ["computed", "calculated", "derived", "aggregated"]
+
+    for keyword in computed_keywords:
+        contract_path = create_test_contract(
+            properties={
+                "total": {"type": "number"},
+                "count": {"type": "integer"}
+            },
+            description=f"This is a {keyword} result",
+            aspect="stats"
+        )
+
+        try:
+            assert contract_needs_migration(contract_path) == False, f"{keyword} should not require migration"
+        finally:
+            contract_path.unlink()
+
+
+# SPEC-TESTER-CONV-0043
+def test_conservative_default_external():
+    """Conservative default: external contracts with properties need migration."""
+    contract_path = create_test_contract(
+        properties={
+            "player_id": {"type": "string"},
+            "score": {"type": "number"}
+        },
+        metadata={"to": "external"},
+        aspect="profile"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == True
+    finally:
+        contract_path.unlink()
+
+
+def test_decision_algorithm_order():
+    """Test that decision rules are evaluated in correct order."""
+    # Rule 1 (explicit persistence.strategy) beats Rule 5 (has id)
+    contract_path = create_test_contract(
+        properties={"id": {"type": "string"}},
+        metadata={"persistence": {"strategy": "none"}},
+        aspect="entity"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+    # Rule 5 (has id) beats Rule 3 (event pattern)
+    contract_path = create_test_contract(
+        properties={"id": {"type": "string"}},
+        aspect="paused"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == True
+    finally:
+        contract_path.unlink()
+
+    # Rule 2 (empty) beats everything except Rule 1
+    contract_path = create_test_contract(
+        properties={},
+        metadata={"to": "external"},
+        aspect="signal"
+    )
+
+    try:
+        assert contract_needs_migration(contract_path) == False
+    finally:
+        contract_path.unlink()
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

atdd/tester/validators/test_migration_generation.py

@@ -0,0 +1,116 @@
+"""
+Platform tests: Migration generation from contracts.
+
+SPEC-TESTER-CONV-0030: Generate migration template from contract schema
+SPEC-TESTER-CONV-0033: Map JSON Schema types to PostgreSQL types
+"""
+import pytest
+import json
+import tempfile
+from pathlib import Path
+
+# Path constants
+REPO_ROOT = Path(__file__).resolve().parents[4]
+CONTRACTS_DIR = REPO_ROOT / "contracts"
+
+
+@pytest.mark.platform
+def test_generate_migration_from_contract():
+    """
+    SPEC-TESTER-CONV-0030: Generate migration template from contract schema
+
+    Given: Contract schema at contracts/match/dilemma/current.schema.json
+    When: Running migration generator
+    Then: Migration file created with correct structure
+          Contains CREATE TABLE statement
+          Includes TODO markers for review
+    """
+    # This test will pass once the generator is implemented
+    # For now, it documents the expected behavior
+    pytest.skip("Migration generator not yet implemented - RED test placeholder")
+
+
+@pytest.mark.platform
+def test_table_naming_convention():
+    """
+    SPEC-TESTER-CONV-0030: Table naming follows convention
+
+    Given: Contract at contracts/{theme}/{domain}/{aspect}.schema.json
+    When: Generating migration
+    Then: Table name is {theme}_{domain}_{aspect}
+          Uses snake_case
+          Matches PostgreSQL naming rules
+    """
+    # Example test data
+    test_cases = [
+        {
+            "path": "contracts/match/dilemma/current.schema.json",
+            "expected_table": "match_dilemma_current"
+        },
+        {
+            "path": "contracts/commons/ux/foundations.schema.json",
+            "expected_table": "commons_ux_foundations"
+        },
+        {
+            "path": "contracts/mechanic/timebank/remaining.schema.json",
+            "expected_table": "mechanic_timebank_remaining"
+        }
+    ]
+
+    for case in test_cases:
+        path = Path(case["path"])
+        parts = path.parts
+
+        theme = parts[1]   # contracts/{theme}/...
+        domain = parts[2]  # contracts/{theme}/{domain}/...
+        aspect = path.stem.replace(".schema", "")
+
+        actual_table = f"{theme}_{domain}_{aspect}"
+
+        assert actual_table == case["expected_table"], \
+            f"Table name mismatch for {case['path']}: expected {case['expected_table']}, got {actual_table}"
+
+
+@pytest.mark.platform
+def test_json_to_postgres_type_mapping():
+    """
+    SPEC-TESTER-CONV-0033: Map JSON Schema types to PostgreSQL types
+
+    Given: Contract properties with various JSON Schema types
+    When: Mapping to PostgreSQL types
+    Then: Correct type mapping applied
+          string → TEXT
+          string with UUID pattern → UUID
+          string with date-time format → TIMESTAMPTZ
+          integer → INTEGER
+          number → NUMERIC
+          boolean → BOOLEAN
+          object → JSONB (with TODO)
+          array → JSONB (with TODO)
+    """
+    # This will be implemented by the migration generator utility
+    # Testing the type mapping logic
+
+    type_mappings = {
+        # Primitives
+        ("string", None, None): "TEXT",
+        ("string", "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", None): "UUID",
+        ("string", None, "date-time"): "TIMESTAMPTZ",
+        ("string", None, "date"): "DATE",
+        ("string", None, "email"): "TEXT",
+        ("string", None, "uri"): "TEXT",
+        ("integer", None, None): "INTEGER",
+        ("number", None, None): "NUMERIC",
+        ("boolean", None, None): "BOOLEAN",
+
+        # Complex (require review)
+        ("object", None, None): "JSONB",
+        ("array", None, None): "JSONB",
+    }
+
+    # Verify mapping exists for common types
+    for (json_type, pattern, format_type), expected_pg_type in type_mappings.items():
+        # This will call the actual mapper once implemented
+        # For now, just verify the expected mappings are defined
+        assert expected_pg_type in ["TEXT", "UUID", "TIMESTAMPTZ", "DATE", "INTEGER", "NUMERIC", "BOOLEAN", "JSONB"], \
+            f"Invalid PostgreSQL type: {expected_pg_type}"