@tdk-landscape/tdk-cli-core 1.3.45 → 1.3.49

package/tests/tilt-engine/test_agents_md_integration.py

@@ -0,0 +1,378 @@
+#!/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

@@ -0,0 +1,181 @@
+"""
+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

@@ -0,0 +1,142 @@
+"""
+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)