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

package/tests/tilt-engine/test_dockerignore_path_bug.py

@@ -1,82 +0,0 @@
-"""
-Regression test for the sibling-service dockerignore collision bug.
-
-manifest_resource.star computed the .dockerignore path for a resource's
-Dockerfile by taking `resource_path.rsplit('/', 1)[0]` (stripping the last
-path segment) before appending the resource's relative `dockerfile` field.
-`resource_path` is already the resource's own directory (e.g.
-"services/app/dashboard-api"), so stripping a segment lands one level up, at
-the shared STACK directory (e.g. "services/app") instead.
-
-Two sibling services in the same stack (e.g. dashboard-api and dashboard-app
-under services/app) then both write to the same shared path
-("services/app/.autogenerated/Dockerfile.app.autogenerated.dockerignore")
-with different content (backend vs frontend dockerignore rules). Since the
-two writers keep overwriting each other every Tiltfile load, the file is
-never stable, Tilt sees it change on every run, and reloads the Tiltfile
-forever - an infinite restart loop.
-
-The fix drops the `.rsplit('/', 1)[0]` so the dockerignore path always sits
-next to its own Dockerfile, matching how the Dockerfile path itself (and how
-_register_docker_build in apply_compose_resource_registration.star resolves
-a resource's `dockerfile` field) is computed.
-"""
-
-import re
-from pathlib import Path
-
-import pytest
-
-pytestmark = [pytest.mark.fast, pytest.mark.generator]
-
-
-@pytest.fixture
-def manifest_resource_path() -> Path:
-    return (
-        Path(__file__).parent.parent.parent
-        / "engine"
-        / "topologies"
-        / "tilt"
-        / "resources"
-        / "orchestrator"
-        / "generators"
-        / "manifest_resource.star"
-    )
-
-
-def test_file_exists(manifest_resource_path: Path):
-    assert manifest_resource_path.exists(), f"Not found: {manifest_resource_path}"
-
-
-def test_dockerignore_path_is_not_stripped_to_parent_directory(manifest_resource_path: Path):
-    """The buggy `resource_path.rsplit('/', 1)[0]` pattern must not reappear in code."""
-    code_lines = [
-        line
-        for line in manifest_resource_path.read_text().splitlines()
-        if not line.strip().startswith("#")
-    ]
-    code = "\n".join(code_lines)
-    assert "resource_path.rsplit(" not in code, (
-        "dockerignore path must be resolved relative to the resource's own "
-        "directory (resource_path), not a parent stripped via rsplit"
-    )
-
-
-def test_dockerignore_path_matches_dockerfile_path(manifest_resource_path: Path):
-    """Both the logged file-list builder and the actual writer must use the
-    same resource_path-relative join for the dockerignore path."""
-    content = manifest_resource_path.read_text()
-
-    matches = re.findall(
-        r'dockerfile_path = ([^\n]+)',
-        content,
-    )
-    assert matches, "Expected at least one dockerfile_path assignment"
-    for expr in matches:
-        assert expr.strip() == 'resource_path + "/" + dockerfile_rel_path', (
-            f"dockerfile_path must join resource_path directly, got: {expr}"
-        )
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

package/tests/tilt-engine/test_file_browser.py

@@ -1,193 +0,0 @@
-"""
-Tests for file browser component.
-Tests the file listing, navigation, and security features.
-"""
-
-import pytest
-import os
-from pathlib import Path
-from unittest.mock import Mock, patch
-
-
-@pytest.mark.ide
-class TestFileBrowser:
-    """Tests for file browser functionality."""
-    
-    def test_root_directory_listing(self, temp_dir):
-        """
-        Scenario: Root directory listing
-        WHEN a user requests `GET /` from the file browser
-        THEN it SHALL return HTML with the root directory listing
-        AND it SHALL include directories and files with icons (📁, 📄)
-        """
-        # Create test structure
-        (temp_dir / "services").mkdir()
-        (temp_dir / "README.md").write_text("# Project")
-        (temp_dir / "package.json").write_text('{"name": "test"}')
-        
-        # Simulate file browser response
-        entries = self._get_directory_listing(temp_dir, temp_dir)
-        
-        # Verify structure
-        assert len(entries) >= 2, "Should list directories and files"
-        
-        # Check for icons
-        dir_entry = next((e for e in entries if e["name"] == "services"), None)
-        assert dir_entry is not None, "Should list services directory"
-        assert "📁" in dir_entry.get("icon", ""), "Directories should have folder icon"
-    
-    def test_subdirectory_navigation(self, temp_dir):
-        """
-        Scenario: Subdirectory navigation
-        WHEN a user requests `GET /?path=.tdk/.tdk-out` from the file browser
-        THEN it SHALL return HTML with the subdirectory listing
-        AND breadcrumb links SHALL allow navigation to parent directories
-        """
-        # Create nested structure
-        nested_dir = temp_dir / ".tdk" / ".tdk-out" / "snapshots"
-        nested_dir.mkdir(parents=True)
-        (nested_dir / "file.txt").write_text("content")
-        
-        # Simulate navigation
-        entries = self._get_directory_listing(nested_dir, temp_dir)
-        
-        assert len(entries) == 1, "Should list the file in subdirectory"
-        assert entries[0]["name"] == "file.txt"
-        
-        # Verify breadcrumb paths
-        breadcrumbs = self._get_breadcrumbs(nested_dir, temp_dir)
-        assert len(breadcrumbs) > 0, "Should have breadcrumbs"
-        assert breadcrumbs[0]["name"] == "root", "First breadcrumb should be root"
-    
-    def test_file_metadata_display(self, temp_dir):
-        """
-        Scenario: File metadata display
-        WHEN a directory listing includes a file
-        THEN it SHALL display file size in human-readable format
-        AND it SHALL display modification time in readable format
-        """
-        # Create test file
-        test_file = temp_dir / "test.txt"
-        test_file.write_text("Hello, World!" * 100)  # ~1.3KB
-        
-        import time
-        mtime = time.time()
-        os.utime(test_file, (mtime, mtime))
-        
-        # Get metadata
-        metadata = self._get_file_metadata(test_file)
-        
-        assert "size" in metadata
-        assert "size_formatted" in metadata
-        assert "mtime" in metadata
-        assert "mtime_formatted" in metadata
-        
-        # Check size formatting (should be human-readable)
-        assert "B" in metadata["size_formatted"] or "KB" in metadata["size_formatted"]
-    
-    def test_path_traversal_protection(self, temp_dir):
-        """
-        Scenario: Path traversal protection
-        WHEN a user requests `GET /?path=../../../etc/passwd` from the file browser
-        THEN it SHALL return `403 Forbidden`
-        AND it SHALL NOT expose files outside the project root
-        """
-        # Try to access outside project root
-        malicious_path = "../../../etc/passwd"
-        
-        # Verify path would escape project root
-        from pathlib import Path
-        resolved = (temp_dir / malicious_path).resolve()
-        
-        is_within_root = str(resolved).startswith(str(temp_dir.resolve()))
-        
-        assert not is_within_root, "Path traversal attempt should be detected"
-        
-        # Security check: should reject paths outside root
-        is_safe = self._is_safe_path(malicious_path, temp_dir)
-        assert not is_safe, "Path outside root should be rejected"
-    
-    def test_file_size_limit(self, temp_dir):
-        """
-        Scenario: File size limit
-        WHEN a user attempts to access a file larger than 1MB
-        THEN it SHALL return `413 Payload Too Large`
-        AND it SHALL include a helpful error message
-        """
-        # Create large file (1.5MB)
-        large_file = temp_dir / "large.bin"
-        large_file.write_bytes(b"0" * (1024 * 1024 + 512 * 1024))  # 1.5MB
-        
-        file_size = large_file.stat().st_size
-        max_size = 1024 * 1024  # 1MB
-        
-        assert file_size > max_size, "Test file should be larger than limit"
-        
-        # Check size limit
-        is_within_limit = file_size <= max_size
-        assert not is_within_limit, "File should exceed size limit"
-    
-    def _get_directory_listing(self, path: Path, root: Path) -> list:
-        """Helper to simulate directory listing."""
-        if not path.exists():
-            return []
-        
-        entries = []
-        for item in sorted(path.iterdir()):
-            entry = {
-                "name": item.name,
-                "is_dir": item.is_dir(),
-                "icon": "📁" if item.is_dir() else "📄"
-            }
-            entries.append(entry)
-        return entries
-    
-    def _get_breadcrumbs(self, path: Path, root: Path) -> list:
-        """Helper to generate breadcrumbs."""
-        breadcrumbs = [{"name": "root", "path": "."}]
-        
-        rel_path = path.relative_to(root)
-        current = root
-        
-        for part in rel_path.parts:
-            current = current / part
-            breadcrumbs.append({"name": part, "path": str(current.relative_to(root))})
-        
-        return breadcrumbs
-    
-    def _get_file_metadata(self, path: Path) -> dict:
-        """Helper to get file metadata."""
-        stat = path.stat()
-        size = stat.st_size
-        
-        # Format size
-        if size < 1024:
-            size_formatted = f"{size} B"
-        elif size < 1024 * 1024:
-            size_formatted = f"{size / 1024:.1f} KB"
-        else:
-            size_formatted = f"{size / (1024 * 1024):.1f} MB"
-        
-        import time
-        from datetime import datetime
-        
-        mtime = stat.st_mtime
-        mtime_formatted = datetime.fromtimestamp(mtime).strftime("%Y-%m-%d %H:%M:%S")
-        
-        return {
-            "size": size,
-            "size_formatted": size_formatted,
-            "mtime": mtime,
-            "mtime_formatted": mtime_formatted
-        }
-    
-    def _is_safe_path(self, path_str: str, root: Path) -> bool:
-        """Check if path is safe (within project root)."""
-        try:
-            requested_path = (root / path_str).resolve()
-            root_resolved = root.resolve()
-            
-            # Check if resolved path is within root
-            return str(requested_path).startswith(str(root_resolved))
-        except (ValueError, RuntimeError):
-            return False

package/tests/tilt-engine/test_frontend_basepath_manifest.py

@@ -1,27 +0,0 @@
-import json
-from pathlib import Path
-
-
-ROOT = Path(__file__).resolve().parents[2]
-EXAMPLE_ROOT = ROOT.parent / "tdk-restaurant-example"
-
-
-def test_frontend_service_manifests_define_explicit_base_paths():
-    expected = {
-        "reservation-app": "/reservation-app",
-        "floor-app": "/floor-app",
-    }
-
-    for app_name, expected_base_path in expected.items():
-        service_path = (
-            EXAMPLE_ROOT
-            / "services"
-            / ("guest" if app_name == "reservation-app" else "operations")
-            / app_name
-            / "service.json"
-        )
-        payload = json.loads(service_path.read_text())
-
-        assert payload["basePath"] == expected_base_path, (
-            f"{app_name} should generate the app route as {expected_base_path} instead of the stack default"
-        )

package/tests/tilt-engine/test_health_dependencies.py

@@ -1,130 +0,0 @@
-"""
-Tests for health dependency checks.
-Tests that services report correct health status for their dependencies.
-"""
-
-import pytest
-from datetime import datetime, timezone
-
-
-@pytest.mark.health
-class TestHealthDependencies:
-    """Tests for dependency health checking."""
-    
-    def test_database_health_check_success(self):
-        """
-        Scenario: Database health check
-        WHEN a service has a database dependency configured with `createDatabaseHealthCheck`
-        AND the database is accessible
-        THEN `/health/ready` SHALL return `status: "ready"` with `database: "healthy"`
-        """
-        # Simulate successful database check
-        db_check_result = {"healthy": True, "latency_ms": 5}
-        
-        health_response = {
-            "status": "ready",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "dependencies": {
-                "database": "healthy" if db_check_result["healthy"] else "unhealthy"
-            }
-        }
-        
-        assert health_response["status"] == "ready"
-        assert health_response["dependencies"]["database"] == "healthy"
-    
-    def test_database_health_check_failure(self):
-        """
-        Scenario: Database health check failure
-        WHEN a service has a database dependency but the database is unreachable
-        THEN `/health/ready` SHALL return `status: "not_ready"` with `database: "unhealthy"`
-        AND the response SHALL include error details
-        """
-        # Simulate failed database check
-        db_check_result = {"healthy": False, "error": "Connection refused"}
-        
-        health_response = {
-            "status": "not_ready",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "dependencies": {
-                "database": "unhealthy",
-                "database_error": db_check_result["error"]
-            }
-        }
-        
-        assert health_response["status"] == "not_ready"
-        assert health_response["dependencies"]["database"] == "unhealthy"
-        assert "database_error" in health_response["dependencies"]
-    
-    def test_multiple_dependency_statuses(self):
-        """
-        Scenario: Multiple dependencies
-        WHEN a service has database and cache dependencies
-        AND database is healthy but cache is unhealthy
-        THEN `/health/ready` SHALL return `status: "not_ready"`
-        AND the response SHALL include status for each dependency
-        """
-        # Simulate mixed dependency health
-        dependencies = {
-            "database": {"healthy": True, "latency_ms": 5},
-            "cache": {"healthy": False, "error": "Timeout"},
-            "nats": {"healthy": True, "latency_ms": 2}
-        }
-        
-        # Service is not ready if any dependency is unhealthy
-        all_healthy = all(d["healthy"] for d in dependencies.values())
-        
-        health_response = {
-            "status": "ready" if all_healthy else "not_ready",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "dependencies": {
-                name: "healthy" if data["healthy"] else "unhealthy"
-                for name, data in dependencies.items()
-            }
-        }
-        
-        assert health_response["status"] == "not_ready"
-        assert health_response["dependencies"]["database"] == "healthy"
-        assert health_response["dependencies"]["cache"] == "unhealthy"
-        assert health_response["dependencies"]["nats"] == "healthy"
-    
-    def test_all_dependencies_healthy(self):
-        """Test when all dependencies are healthy."""
-        dependencies = {
-            "database": {"healthy": True},
-            "cache": {"healthy": True},
-            "nats": {"healthy": True}
-        }
-        
-        all_healthy = all(d["healthy"] for d in dependencies.values())
-        
-        assert all_healthy, "All dependencies should be healthy"
-        
-        health_response = {
-            "status": "ready",
-            "dependencies": {
-                name: "healthy" for name in dependencies.keys()
-            }
-        }
-        
-        assert health_response["status"] == "ready"
-    
-    def test_dependency_latency_reporting(self):
-        """Test that dependency health checks include latency."""
-        dependencies = {
-            "database": {"healthy": True, "latency_ms": 5},
-            "cache": {"healthy": True, "latency_ms": 2}
-        }
-        
-        health_response = {
-            "status": "ready",
-            "dependencies": {
-                name: {
-                    "status": "healthy" if data["healthy"] else "unhealthy",
-                    "latency_ms": data.get("latency_ms", 0)
-                }
-                for name, data in dependencies.items()
-            }
-        }
-        
-        assert health_response["dependencies"]["database"]["latency_ms"] == 5
-        assert health_response["dependencies"]["cache"]["latency_ms"] == 2

package/tests/tilt-engine/test_health_endpoints.py

@@ -1,118 +0,0 @@
-"""
-Tests for health endpoint response structure.
-Tests the /health, /health/live, and /health/ready endpoints.
-"""
-
-import pytest
-from datetime import datetime, timezone
-
-
-@pytest.mark.health
-class TestHealthEndpoints:
-    """Tests for health check endpoint structure."""
-    
-    def test_overall_health_endpoint_structure(self, mock_health_response):
-        """
-        Scenario: Overall health endpoint
-        WHEN a service with health checks receives a request to `GET /health`
-        THEN it SHALL return JSON with fields: `status`, `service`, `version`, `timestamp`, `uptime`, `dependencies`
-        AND `status` SHALL be one of: `healthy`, `unhealthy`, `degraded`
-        """
-        required_fields = ["status", "service", "version", "timestamp", "uptime", "dependencies"]
-        
-        for field in required_fields:
-            assert field in mock_health_response, f"Response missing required field: {field}"
-        
-        assert mock_health_response["status"] in ["healthy", "unhealthy", "degraded"]
-    
-    def test_liveness_probe_endpoint(self):
-        """
-        Scenario: Liveness probe endpoint
-        WHEN a service receives a request to `GET /health/live`
-        THEN it SHALL return JSON with `status: "alive"` or `status: "dead"`
-        AND `timestamp` SHALL be ISO8601 format
-        """
-        liveness_response = {
-            "status": "alive",
-            "timestamp": datetime.now(timezone.utc).isoformat()
-        }
-        
-        assert "status" in liveness_response
-        assert liveness_response["status"] in ["alive", "dead"]
-        assert "timestamp" in liveness_response
-        
-        # Verify ISO8601 format (contains T and timezone info)
-        timestamp = liveness_response["timestamp"]
-        assert "T" in timestamp, "Timestamp should be ISO8601 format"
-    
-    def test_readiness_probe_endpoint(self):
-        """
-        Scenario: Readiness probe endpoint
-        WHEN a service receives a request to `GET /health/ready`
-        THEN it SHALL return JSON with `status: "ready"` or `status: "not_ready"`
-        AND if `not_ready`, it SHALL include `dependencies` object with failing dependency names
-        """
-        # Test ready state
-        ready_response = {
-            "status": "ready",
-            "timestamp": datetime.now(timezone.utc).isoformat()
-        }
-        
-        assert ready_response["status"] in ["ready", "not_ready"]
-        
-        # Test not_ready state with dependencies
-        not_ready_response = {
-            "status": "not_ready",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "dependencies": {
-                "database": "unhealthy",
-                "cache": "healthy"
-            }
-        }
-        
-        assert not_ready_response["status"] == "not_ready"
-        assert "dependencies" in not_ready_response
-        assert "database" in not_ready_response["dependencies"]
-    
-    def test_health_status_values(self):
-        """Test that health status values are from allowed set."""
-        valid_statuses = ["healthy", "unhealthy", "degraded", "ready", "not_ready", "alive", "dead"]
-        
-        test_responses = [
-            {"status": "healthy"},
-            {"status": "unhealthy"},
-            {"status": "degraded"},
-            {"status": "ready"},
-        ]
-        
-        for response in test_responses:
-            assert response["status"] in valid_statuses, f"Invalid status: {response['status']}"
-    
-    def test_health_response_includes_version(self):
-        """Test that health response includes service version."""
-        response = {
-            "status": "healthy",
-            "service": "test-service",
-            "version": "1.0.0",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "uptime": 3600,
-            "dependencies": {}
-        }
-        
-        assert "version" in response
-        assert response["version"] == "1.0.0"
-    
-    def test_health_response_includes_uptime(self):
-        """Test that health response includes uptime in seconds."""
-        response = {
-            "status": "healthy",
-            "service": "test-service",
-            "version": "1.0.0",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "uptime": 3600,
-            "dependencies": {}
-        }
-        
-        assert "uptime" in response
-        assert isinstance(response["uptime"], (int, float))
-        assert response["uptime"] >= 0

package/tests/tilt-engine/test_health_tilt_ui.py

@@ -1,85 +0,0 @@
-"""
-Tests for health status in Tilt UI.
-Tests the mapping from health responses to Tilt UI indicators.
-"""
-
-import pytest
-
-
-@pytest.mark.health
-class TestHealthTiltUI:
-    """Tests for Tilt UI health status display."""
-    
-    def test_ready_resource_shows_green(self, mock_tilt_ui_status):
-        """
-        Scenario: Ready service shows green
-        WHEN `/health/ready` returns `200 OK` with `status: "ready"`
-        THEN the Tilt UI SHALL display the resource as **Ready** (green indicator)
-        """
-        # Simulate a ready health check response
-        health_response = {"status": "ready"}
-        http_status = 200
-        
-        # Determine Tilt UI status
-        if http_status == 200 and health_response.get("status") == "ready":
-            tilt_status = mock_tilt_ui_status["ready"]
-        
-        assert tilt_status["indicator"] == "green"
-        assert tilt_status["status"] == "Ready"
-    
-    def test_starting_resource_shows_yellow(self, mock_tilt_ui_status):
-        """
-        Scenario: Starting service shows yellow
-        WHEN `/health/ready` returns `503 Service Unavailable` but `/health/live` returns `200`
-        THEN the Tilt UI SHALL display the resource as **Starting** (yellow indicator)
-        """
-        # Simulate starting state (live but not ready)
-        live_response = {"status": "alive"}
-        ready_response = {"status": "not_ready"}
-        live_http_status = 200
-        ready_http_status = 503
-        
-        # Determine Tilt UI status
-        if (live_http_status == 200 and live_response.get("status") == "alive" and
-            ready_http_status == 503):
-            tilt_status = mock_tilt_ui_status["starting"]
-        
-        assert tilt_status["indicator"] == "yellow"
-        assert tilt_status["status"] == "Starting"
-    
-    def test_error_resource_shows_red(self, mock_tilt_ui_status):
-        """
-        Scenario: Error service shows red
-        WHEN `/health/live` fails or returns non-200
-        THEN the Tilt UI SHALL display the resource as **Error** (red indicator)
-        """
-        # Simulate error state (live failing)
-        live_http_status = 500
-        
-        # Determine Tilt UI status
-        if live_http_status != 200:
-            tilt_status = mock_tilt_ui_status["error"]
-        
-        assert tilt_status["indicator"] == "red"
-        assert tilt_status["status"] == "Error"
-    
-    def test_health_status_mapping(self):
-        """Test the complete health status to Tilt UI mapping."""
-        test_cases = [
-            # (live_status, ready_status, live_http, ready_http, expected_indicator, expected_status)
-            ("alive", "ready", 200, 200, "green", "Ready"),
-            ("alive", "not_ready", 200, 503, "yellow", "Starting"),
-            ("dead", "ready", 500, 200, "red", "Error"),
-            ("dead", "not_ready", 500, 503, "red", "Error"),
-        ]
-        
-        for live_status, ready_status, live_http, ready_http, expected_indicator, expected_status in test_cases:
-            if live_http != 200:
-                actual_indicator, actual_status = "red", "Error"
-            elif ready_http != 200:
-                actual_indicator, actual_status = "yellow", "Starting"
-            else:
-                actual_indicator, actual_status = "green", "Ready"
-            
-            assert actual_indicator == expected_indicator, f"Failed for case: {live_status}, {ready_status}"
-            assert actual_status == expected_status, f"Failed for case: {live_status}, {ready_status}"