@tdk-landscape/tdk-cli-core 1.3.53 → 1.3.55

package/tests/tilt-engine/test_agents_md_integration.py

@@ -1,378 +0,0 @@
-#!/usr/bin/env python3
-"""
-Integration test for AGENTS.md generator.
-
-This test verifies the generator works by:
-1. Mocking the Starlark environment (Utils, write_fn)
-2. Calling the generator logic with test manifests
-3. Verifying the generated AGENTS.md content
-
-Usage:
-    python3 tests/tilt-engine/test_agents_md_integration.py
-"""
-
-import re
-import sys
-from pathlib import Path
-from typing import Dict, Any, List
-
-# Add project root to path
-PROJECT_ROOT = Path(__file__).parent.parent.parent
-sys.path.insert(0, str(PROJECT_ROOT))
-
-
-class MockUtils:
-    """Mock Utils struct for testing."""
-    
-    @staticmethod
-    def get_template_header(template_type: str, generator_name: str, resource_name: str, output_hint: str) -> str:
-        return f"# GENERATED BY TDK - {template_type} for {resource_name}\n# Generator: {generator_name}\n# {output_hint}"
-
-
-class MockFileWriter:
-    """Mock write_fn that captures written files."""
-    
-    def __init__(self):
-        self.files: Dict[str, str] = {}
-    
-    def write(self, path: str, content: str) -> None:
-        """Mock write_file function."""
-        self.files[path] = content
-        print(f"  📝 Mock write: {path}")
-
-
-def extract_template_from_generator() -> str:
-    """Extract TEMPLATE_AGENTS_MD from the generator source."""
-    generator_path = PROJECT_ROOT / "engine" / "topologies" / "tilt" / "generators" / "agents_md.star"
-    content = generator_path.read_text()
-    
-    match = re.search(r'TEMPLATE_AGENTS_MD = """(.*?)"""', content, re.DOTALL)
-    if not match:
-        raise ValueError("Could not find TEMPLATE_AGENTS_MD in generator")
-    
-    return match.group(1)
-
-
-def simulate_generate_agents_md(manifest: Dict[str, Any], write_fn=None) -> str:
-    """
-    Simulate the generate_agents_md function in Python.
-    
-    This mirrors the logic in agents_md.star but in Python for testing.
-    """
-    resource_path = manifest.get('_servicePath', '')
-    app_name = manifest.get('appName', 'unknown-service')
-    app_type = manifest.get('appType', 'backend')
-    
-    # Get template
-    template = extract_template_from_generator()
-    
-    # Generate header
-    header = MockUtils.get_template_header(
-        'agents_md',
-        'AgentsMd.generate()',
-        app_name,
-        'Output: .autogenerated/AGENTS.md'
-    )
-    
-    # Format template
-    timestamp = "2026-04-28 12:00:00"  # Fixed for testing
-    content = template.format(
-        header=header,
-        resource_name=app_name,
-        app_type=app_type,
-        timestamp=timestamp,
-    )
-    
-    if write_fn:
-        output_path = f"{resource_path}/.autogenerated/AGENTS.md"
-        write_fn(output_path, content)
-    
-    return content
-
-
-def test_backend_service():
-    """Test AGENTS.md generation for a backend service."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 1: Backend Service (test-api-backend)")
-    print("=" * 70)
-    
-    manifest = {
-        "appName": "test-api-backend",
-        "appType": "backend",
-        "stack": "test",
-        "port": 4001,
-        "_servicePath": "services/product/test/test-api-backend",
-    }
-    
-    writer = MockFileWriter()
-    content = simulate_generate_agents_md(manifest, writer.write)
-    
-    # Assertions
-    assert "test-api-backend" in content, "Service name should appear"
-    assert "backend" in content, "App type should appear"
-    assert ".autogenerated/" in content, "Should reference .autogenerated folder"
-    
-    output_path = "services/product/test/test-api-backend/.autogenerated/AGENTS.md"
-    assert output_path in writer.files, f"Should write to correct path: {output_path}"
-    assert output_path.endswith("AGENTS.md"), "File should be named AGENTS.md"
-    
-    print(f"\n✅ Backend test passed!")
-    print(f"   Output path: {output_path}")
-    print(f"   Content length: {len(content)} chars")
-    
-    return True
-
-
-def test_frontend_service():
-    """Test AGENTS.md generation for a frontend service."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 2: Frontend Service (test-app-frontend)")
-    print("=" * 70)
-    
-    manifest = {
-        "appName": "test-app-frontend",
-        "appType": "frontend",
-        "stack": "test",
-        "port": 3001,
-        "backendName": "test-api-backend",
-        "_servicePath": "services/product/test/test-app-frontend",
-    }
-    
-    writer = MockFileWriter()
-    content = simulate_generate_agents_md(manifest, writer.write)
-    
-    # Assertions
-    assert "test-app-frontend" in content, "Service name should appear"
-    assert "frontend" in content, "App type should appear"
-    assert "vite.config" in content, "Should mention vite config (relevant for frontend)"
-    assert "nginx" in content, "Should mention nginx (relevant for frontend)"
-    
-    output_path = "services/product/test/test-app-frontend/.autogenerated/AGENTS.md"
-    assert output_path in writer.files, f"Should write to correct path: {output_path}"
-    
-    print(f"\n✅ Frontend test passed!")
-    print(f"   Content includes frontend-specific references")
-    
-    return True
-
-
-def test_migrator_service():
-    """Test AGENTS.md generation for a migrator service."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 3: Migrator Service (test-db-migrator)")
-    print("=" * 70)
-    
-    manifest = {
-        "appName": "test-db-migrator",
-        "appType": "migrator",
-        "stack": "test",
-        "port": 7001,
-        "_servicePath": "services/product/test/test-db-migrator",
-    }
-    
-    writer = MockFileWriter()
-    content = simulate_generate_agents_md(manifest, writer.write)
-    
-    assert "test-db-migrator" in content, "Service name should appear"
-    assert "migrator" in content or "backend" in content, "App type should appear"
-    
-    output_path = "services/product/test/test-db-migrator/.autogenerated/AGENTS.md"
-    assert output_path in writer.files, f"Should write to correct path: {output_path}"
-    
-    print(f"\n✅ Migrator test passed!")
-    
-    return True
-
-
-def test_content_structure():
-    """Test that generated content has all required sections."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 4: Content Structure Validation")
-    print("=" * 70)
-    
-    manifest = {
-        "appName": "structure-test-service",
-        "appType": "backend",
-        "_servicePath": "services/test",
-    }
-    
-    content = simulate_generate_agents_md(manifest)
-    
-    required_sections = [
-        ("---", "YAML frontmatter start"),
-        ("title:", "Title field"),
-        ("status: autogenerated", "Autogenerated status"),
-        ("# ⚠️ AUTOGENERATED FILES", "Warning header"),
-        ("## Why This Folder Exists", "Why section"),
-        ("## What Happens If You Modify Files Here", "Consequences section"),
-        ("## Where to Make Changes Instead", "Alternatives section"),
-        ("## How Regeneration Works", "Architecture section"),
-        ("## For AI Agents", "AI agent section"),
-        ("## Emergency Override", "Emergency section"),
-        ("service.json", "References service.json"),
-        ("package.json", "References package.json"),
-        ("NEVER", "Critical NEVER instruction"),
-        ("ALWAYS", "Best practice ALWAYS instruction"),
-        ("Generator Metadata", "Metadata section"),
-    ]
-    
-    all_passed = True
-    for pattern, description in required_sections:
-        if pattern in content:
-            print(f"  ✅ {description}")
-        else:
-            print(f"  ❌ {description} - missing: '{pattern}'")
-            all_passed = False
-    
-    # Verify list of generated files
-    generated_files = [
-        "vite.config", "tsconfig", "Dockerfile", "nginx",
-        ".env", "bunfig", ".npmrc", "docker-compose",
-        "playwright", "prisma"
-    ]
-    
-    for file_type in generated_files:
-        if file_type in content:
-            print(f"  ✅ Mentions {file_type}")
-        else:
-            print(f"  ⚠️  Missing mention of {file_type}")
-    
-    return all_passed
-
-
-def test_ai_agent_instructions():
-    """Test that AI agent instructions are clear and present."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 5: AI Agent Instructions")
-    print("=" * 70)
-    
-    manifest = {
-        "appName": "ai-test-service",
-        "appType": "backend",
-        "_servicePath": "services/ai/test",
-    }
-    
-    content = simulate_generate_agents_md(manifest)
-    
-    # Check for AI-specific instructions
-    ai_checks = [
-        ("write()", "References write() function"),
-        ("edit()", "References edit() function"),
-        ("skill(", "References skill() function"),
-        ("CRITICAL INSTRUCTIONS", "Has critical instructions section"),
-        ("❌", "Has X emoji for wrong way"),
-        ("✅", "Has checkmark emoji for right way"),
-    ]
-    
-    all_passed = True
-    for pattern, description in ai_checks:
-        if pattern in content:
-            print(f"  ✅ {description}")
-        else:
-            print(f"  ❌ {description} - missing: '{pattern}'")
-            all_passed = False
-    
-    return all_passed
-
-
-def test_no_write_fn():
-    """Test that generator works without write_fn (returns content only)."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 6: Generator Without write_fn")
-    print("=" * 70)
-    
-    manifest = {
-        "appName": "no-write-service",
-        "appType": "backend",
-        "_servicePath": "services/test",
-    }
-    
-    # Call without write_fn
-    content = simulate_generate_agents_md(manifest, write_fn=None)
-    
-    assert content is not None, "Should return content"
-    assert len(content) > 1000, "Content should be substantial"
-    assert "no-write-service" in content, "Should include service name"
-    
-    print("  ✅ Returns content without writing when write_fn=None")
-    
-    return True
-
-
-def test_all_services():
-    """Test generation for all service types."""
-    print("\n" + "=" * 70)
-    print("🧪 TEST 7: All Service Types")
-    print("=" * 70)
-    
-    resource_types = ["backend", "frontend", "migrator", "library", "sdk"]
-    
-    for svc_type in resource_types:
-        manifest = {
-            "appName": f"test-{svc_type}",
-            "appType": svc_type,
-            "_servicePath": f"services/test/{svc_type}",
-        }
-        
-        writer = MockFileWriter()
-        content = simulate_generate_agents_md(manifest, writer.write)
-        
-        assert svc_type in content, f"Should include appType: {svc_type}"
-        assert f"test-{svc_type}" in content, f"Should include service name"
-        print(f"  ✅ {svc_type} service works")
-    
-    return True
-
-
-def run_all_tests():
-    """Run all integration tests."""
-    print("\n" + "=" * 70)
-    print("🚀 AGENTS.MD GENERATOR INTEGRATION TESTS")
-    print("=" * 70)
-    
-    tests = [
-        ("Backend Service", test_backend_service),
-        ("Frontend Service", test_frontend_service),
-        ("Migrator Service", test_migrator_service),
-        ("Content Structure", test_content_structure),
-        ("AI Agent Instructions", test_ai_agent_instructions),
-        ("No Write Function", test_no_write_fn),
-        ("All Service Types", test_all_services),
-    ]
-    
-    results = []
-    for name, test_func in tests:
-        try:
-            passed = test_func()
-            results.append((name, passed))
-        except Exception as e:
-            print(f"\n💥 ERROR in {name}: {e}")
-            import traceback
-            traceback.print_exc()
-            results.append((name, False))
-    
-    # Summary
-    print("\n" + "=" * 70)
-    print("📊 TEST SUMMARY")
-    print("=" * 70)
-    
-    passed_count = sum(1 for _, p in results if p)
-    total_count = len(results)
-    
-    for name, passed in results:
-        status = "✅ PASS" if passed else "❌ FAIL"
-        print(f"  {status}: {name}")
-    
-    print(f"\n  Total: {passed_count}/{total_count} tests passed")
-    
-    if passed_count == total_count:
-        print("\n🎉 All tests passed!")
-        return 0
-    else:
-        print(f"\n⚠️  {total_count - passed_count} test(s) failed")
-        return 1
-
-
-if __name__ == "__main__":
-    exit_code = run_all_tests()
-    sys.exit(exit_code)

package/tests/tilt-engine/test_cache_operations.py

@@ -1,181 +0,0 @@
-"""
-Tests for registry cache operations.
-Tests the CRUD operations for the service registry cache.
-"""
-
-import pytest
-
-
-@pytest.mark.cache
-class TestCacheOperations:
-    """Tests for registry cache CRUD operations."""
-    
-    def test_add_new_resource_to_cache(self, resource_registry_cache):
-        """
-        Scenario: Add new service to cache
-        WHEN `CacheOps.add_resource_to_cache()` is called with a valid service object
-        THEN the service SHALL be stored in `_DISCOVERY_CACHE`
-        AND it SHALL be retrievable by path via `CacheOps.get_resource_by_path_from_cache()`
-        """
-        cache = resource_registry_cache
-        service = {
-            "name": "test-service",
-            "path": "services/product/test/test-service"
-        }
-        
-        # Add to cache
-        self._add_to_cache(cache, service["path"], service)
-        
-        # Verify retrievable
-        retrieved = self._get_from_cache(cache, service["path"])
-        assert retrieved is not None
-        assert retrieved["name"] == "test-service"
-    
-    def test_add_resource_with_metadata(self, resource_registry_cache):
-        """
-        Scenario: Add service with metadata
-        WHEN adding a service with fields `name`, `type`, `path`, `domain`, `port`
-        THEN all fields SHALL be preserved in the cache
-        AND retrieval SHALL return the exact same data
-        """
-        cache = resource_registry_cache
-        service = {
-            "name": "identity-backend",
-            "type": "backend",
-            "path": "services/product/identity/identity-backend",
-            "stack": "identity",
-            "port": 4001
-        }
-        
-        self._add_to_cache(cache, service["path"], service)
-        retrieved = self._get_from_cache(cache, service["path"])
-        
-        assert retrieved["name"] == "identity-backend"
-        assert retrieved["type"] == "backend"
-        assert retrieved["stack"] == "identity"
-        assert retrieved["port"] == 4001
-    
-    def test_prevent_duplicate_adds(self, resource_registry_cache):
-        """
-        Scenario: Prevent duplicate adds
-        WHEN attempting to add a service with a path already in cache
-        THEN the new service data SHALL overwrite the old data (update semantics)
-        AND the cache SHALL contain only one entry for that path
-        """
-        cache = resource_registry_cache
-        path = "services/product/test/service"
-        
-        # Add initial version
-        self._add_to_cache(cache, path, {"name": "v1", "port": 4000})
-        
-        # Add updated version (should overwrite)
-        self._add_to_cache(cache, path, {"name": "v2", "port": 4001})
-        
-        # Retrieve and verify
-        retrieved = self._get_from_cache(cache, path)
-        assert retrieved["name"] == "v2"
-        assert retrieved["port"] == 4001
-    
-    def test_remove_existing_service(self, resource_registry_cache):
-        """
-        Scenario: Remove existing service
-        WHEN `CacheOps.remove_resource_from_cache()` is called with a path in cache
-        THEN the service SHALL be removed from `_DISCOVERY_CACHE`
-        AND subsequent `CacheOps.has_resource_in_cache()` SHALL return `False`
-        """
-        cache = resource_registry_cache
-        path = "services/product/test/service"
-        
-        # Add and verify
-        self._add_to_cache(cache, path, {"name": "test"})
-        assert self._has_in_cache(cache, path)
-        
-        # Remove
-        self._remove_from_cache(cache, path)
-        
-        # Verify removed
-        assert not self._has_in_cache(cache, path)
-    
-    def test_remove_non_existent_service(self, resource_registry_cache):
-        """
-        Scenario: Remove non-existent service
-        WHEN attempting to remove a path not in cache
-        THEN it SHALL complete without error (idempotent)
-        AND other cache entries SHALL remain unaffected
-        """
-        cache = resource_registry_cache
-        
-        # Add a service
-        self._add_to_cache(cache, "path1", {"name": "service1"})
-        
-        # Try to remove non-existent path
-        self._remove_from_cache(cache, "nonexistent")  # Should not raise
-        
-        # Verify other entries unaffected
-        assert self._has_in_cache(cache, "path1")
-    
-    def test_check_resource_existence(self, resource_registry_cache):
-        """
-        Scenario: Check service existence
-        WHEN `CacheOps.has_resource_in_cache()` is called with a cached path
-        THEN it SHALL return `True`
-        """
-        cache = resource_registry_cache
-        path = "services/product/test/service"
-        
-        self._add_to_cache(cache, path, {"name": "test"})
-        
-        assert self._has_in_cache(cache, path)
-    
-    def test_check_non_existent_service(self, resource_registry_cache):
-        """
-        Scenario: Check non-existent service
-        WHEN `CacheOps.has_resource_in_cache()` is called with an unknown path
-        THEN it SHALL return `False`
-        """
-        cache = resource_registry_cache
-        
-        assert not self._has_in_cache(cache, "nonexistent")
-    
-    def test_get_resource_by_path(self, resource_registry_cache):
-        """
-        Scenario: Get service by path
-        WHEN `CacheOps.get_resource_by_path_from_cache()` is called with a cached path
-        THEN it SHALL return the full service object
-        """
-        cache = resource_registry_cache
-        service = {"name": "test", "type": "backend"}
-        path = "services/product/test/service"
-        
-        self._add_to_cache(cache, path, service)
-        retrieved = self._get_from_cache(cache, path)
-        
-        assert retrieved == service
-    
-    def test_get_non_existent_resource_returns_none(self, resource_registry_cache):
-        """
-        Scenario: Get non-existent service
-        WHEN `CacheOps.get_resource_by_path_from_cache()` is called with an unknown path
-        THEN it SHALL return `None` (not raise an exception)
-        """
-        cache = resource_registry_cache
-        
-        result = self._get_from_cache(cache, "nonexistent")
-        
-        assert result is None
-    
-    # Helper methods to simulate cache operations
-    def _add_to_cache(self, cache, path, service):
-        if "resource_path_map" not in cache:
-            cache["resource_path_map"] = {}
-        cache["resource_path_map"][path] = service
-    
-    def _get_from_cache(self, cache, path):
-        return cache.get("resource_path_map", {}).get(path)
-    
-    def _remove_from_cache(self, cache, path):
-        if path in cache.get("resource_path_map", {}):
-            del cache["resource_path_map"][path]
-    
-    def _has_in_cache(self, cache, path):
-        return path in cache.get("resource_path_map", {})

package/tests/tilt-engine/test_cache_persistence.py

@@ -1,142 +0,0 @@
-"""
-Tests for registry cache persistence.
-Tests saving and loading the cache from the filesystem.
-"""
-
-import json
-import pytest
-from pathlib import Path
-
-
-@pytest.mark.cache
-class TestCachePersistence:
-    """Tests for cache persistence operations."""
-    
-    def test_save_cache_to_file(self, temp_dir, resource_registry_cache):
-        """
-        Scenario: Save cache to file
-        WHEN the cache is saved to a JSON file
-        THEN the file SHALL exist with valid JSON
-        AND it SHALL contain all cached services
-        """
-        cache_file = temp_dir / "discovery-cache.json"
-        
-        # Add services to cache
-        cache = resource_registry_cache
-        cache["resource_path_map"] = {
-            "path1": {"name": "service1"},
-            "path2": {"name": "service2"}
-        }
-        
-        # Save to file
-        self._save_cache(cache, cache_file)
-        
-        # Verify file exists
-        assert cache_file.exists()
-        
-        # Verify content
-        with open(cache_file) as f:
-            data = json.load(f)
-        
-        assert "resource_path_map" in data
-        assert len(data["resource_path_map"]) == 2
-    
-    def test_load_cache_from_file(self, temp_dir, resource_registry_cache):
-        """
-        Scenario: Load cache from file
-        WHEN loading cache from a previously saved JSON file
-        THEN `_DISCOVERY_CACHE` SHALL be populated with the saved services
-        AND all query operations SHALL work on the loaded data
-        """
-        cache_file = temp_dir / "discovery-cache.json"
-        
-        # Create saved cache file
-        saved_data = {
-            "resource_path_map": {
-                "path1": {"name": "service1", "type": "backend"},
-                "path2": {"name": "service2", "type": "frontend"}
-            }
-        }
-        with open(cache_file, "w") as f:
-            json.dump(saved_data, f)
-        
-        # Load cache
-        cache = resource_registry_cache
-        self._load_cache(cache, cache_file)
-        
-        # Verify loaded
-        assert "path1" in cache["resource_path_map"]
-        assert cache["resource_path_map"]["path1"]["name"] == "service1"
-        assert cache["resource_path_map"]["path2"]["type"] == "frontend"
-    
-    def test_cache_survives_process_restart(self, temp_dir, resource_registry_cache):
-        """
-        Scenario: Cache survives process restart
-        WHEN the Tilt process restarts
-        AND the cache file exists
-        THEN the cache SHALL be reloaded automatically
-        AND no services SHALL need re-discovery
-        """
-        cache_file = temp_dir / "discovery-cache.json"
-        
-        # Simulate first run - save cache
-        cache1 = resource_registry_cache
-        cache1["resource_path_map"] = {
-            "services/test/service1": {"name": "service1"},
-            "services/test/service2": {"name": "service2"}
-        }
-        self._save_cache(cache1, cache_file)
-        
-        # Simulate restart - new cache object, load from file
-        cache2 = {"initialized": False, "resource_path_map": {}}
-        self._load_cache(cache2, cache_file)
-        
-        # Verify cache survived
-        assert "services/test/service1" in cache2["resource_path_map"]
-        assert "services/test/service2" in cache2["resource_path_map"]
-        assert cache2["resource_path_map"]["services/test/service1"]["name"] == "service1"
-    
-    def test_save_and_load_empty_cache(self, temp_dir):
-        """Test saving and loading an empty cache."""
-        cache_file = temp_dir / "empty-cache.json"
-        
-        empty_cache = {"resource_path_map": {}}
-        self._save_cache(empty_cache, cache_file)
-        
-        loaded_cache = {"resource_path_map": {}}
-        self._load_cache(loaded_cache, cache_file)
-        
-        assert len(loaded_cache["resource_path_map"]) == 0
-    
-    def test_cache_file_format(self, temp_dir):
-        """Test that cache file has expected format."""
-        cache_file = temp_dir / "cache.json"
-        
-        cache = {
-            "initialized": True,
-            "resource_path_map": {
-                "path": {"name": "test"}
-            }
-        }
-        self._save_cache(cache, cache_file)
-        
-        with open(cache_file) as f:
-            content = f.read()
-        
-        # Should be valid JSON
-        data = json.loads(content)
-        assert "resource_path_map" in data
-    
-    # Helper methods
-    def _save_cache(self, cache, path):
-        with open(path, "w") as f:
-            json.dump(cache, f, indent=2)
-    
-    def _load_cache(self, cache, path):
-        if not path.exists():
-            return
-        
-        with open(path) as f:
-            data = json.load(f)
-        
-        cache.update(data)