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

package/tests/tilt-engine/test_snapshot_persistence.py

@@ -1,163 +0,0 @@
-"""
-Tests for snapshot persistence functionality.
-Tests saving and loading snapshots from the filesystem.
-"""
-
-import json
-import os
-import pytest
-from pathlib import Path
-
-
-@pytest.mark.snapshot
-class TestSnapshotPersistence:
-    """Tests for snapshot save/load operations."""
-    
-    def test_saving_snapshot_creates_file(self, temp_dir):
-        """
-        Scenario: Saving snapshot creates file
-        WHEN a snapshot is saved to `.tdk/.tdk-out/snapshots/resource-snapshot.json`
-        THEN the file SHALL exist with valid JSON containing all service data
-        """
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import save_snapshot
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            services = [
-                "services/product/a/service.json",
-                "services/product/b/service.json"
-            ]
-            save_snapshot(services)
-            
-            snapshot_file = Path(".tdk/.tdk-out/snapshots/resource-snapshot.json")
-            assert snapshot_file.exists(), "Snapshot file should be created"
-            
-            # Verify content
-            with open(snapshot_file) as f:
-                data = json.load(f)
-                assert data["count"] == 2
-                assert data["services"] == services
-                assert "timestamp" in data
-                assert "hash" in data
-        finally:
-            os.chdir(original_dir)
-    
-    def test_loading_snapshot_reads_file(self, temp_dir):
-        """
-        Scenario: Loading snapshot reads file
-        WHEN a snapshot is loaded from an existing `.tdk/.tdk-out/snapshots/resource-snapshot.json`
-        THEN it SHALL return the previously saved service data
-        """
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import save_snapshot, load_snapshot
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            # Create a snapshot first
-            services = ["services/product/test/service.json"]
-            save_snapshot(services)
-            
-            # Load it
-            snapshot = load_snapshot()
-            
-            assert snapshot["count"] == 1
-            assert snapshot["services"] == services
-            assert "timestamp" in snapshot
-        finally:
-            os.chdir(original_dir)
-    
-    def test_loading_missing_snapshot(self, temp_dir):
-        """
-        Scenario: Loading missing snapshot
-        WHEN a snapshot is loaded from a non-existent `.tdk/.tdk-out/snapshots/resource-snapshot.json`
-        THEN it SHALL return an empty list without error
-        """
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import load_snapshot
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            snapshot = load_snapshot()
-            
-            assert snapshot["count"] == 0
-            assert snapshot["services"] == []
-            assert snapshot["timestamp"] is None
-        finally:
-            os.chdir(original_dir)
-    
-    def test_saving_creates_directory_structure(self, temp_dir):
-        """Test that saving creates the .tdk/.tdk-out/snapshots directory if it doesn't exist."""
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import save_snapshot
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            services = ["services/test/service.json"]
-            save_snapshot(services)
-            
-            assert Path(".tdk/.tdk-out/snapshots").exists(), ".tdk/.tdk-out/snapshots directory should be created"
-            assert Path(".tdk/.tdk-out/snapshots").is_dir(), ".tdk/.tdk-out/snapshots should be a directory"
-        finally:
-            os.chdir(original_dir)
-    
-    def test_loading_invalid_json_returns_empty(self, temp_dir):
-        """Test that loading invalid JSON returns empty snapshot."""
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import load_snapshot
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            # Create invalid JSON file
-            Path(".tilt").mkdir(parents=True, exist_ok=True)
-            with open(".tilt/resource-snapshot.json", "w") as f:
-                f.write("not valid json {{{")
-            
-            snapshot = load_snapshot()
-            
-            assert snapshot["count"] == 0
-            assert snapshot["services"] == []
-        finally:
-            os.chdir(original_dir)
-    
-    def test_snapshot_includes_hashes(self, temp_dir):
-        """Test that saved snapshot includes content hashes."""
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import save_snapshot
-        
-        # Create a service file to hash
-        resource_dir = temp_dir / "services" / "test"
-        resource_dir.mkdir(parents=True)
-        (resource_dir / "service.json").write_text('{"name": "test"}')
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            services = ["services/test/service.json"]
-            save_snapshot(services, include_hashes=True)
-            
-            with open(".tdk/.tdk-out/snapshots/resource-snapshot.json") as f:
-                data = json.load(f)
-                
-            assert "resource_hashes" in data
-            assert "services/test/service.json" in data["resource_hashes"]
-            assert len(data["resource_hashes"]["services/test/service.json"]) == 16
-        finally:
-            os.chdir(original_dir)

package/tests/tilt-engine/test_snapshot_scanning.py

@@ -1,123 +0,0 @@
-"""
-Tests for resource snapshot scanning functionality.
-Tests the filesystem scanning and service.json discovery.
-"""
-
-import json
-import os
-import pytest
-from pathlib import Path
-
-
-@pytest.mark.snapshot
-class TestSnapshotScanning:
-    """Tests for filesystem scanning functionality."""
-    
-    def test_scanning_finds_valid_resource_files(self, temp_dir, monkeypatch):
-        """
-        Scenario: Scanning finds valid resource files
-        WHEN the scanner runs against a directory containing 3 valid service.json files
-        THEN it SHALL return a list of 3 resources with correct paths and parsed metadata
-        """
-        # Create test directory structure with 3 resources
-        resources = [
-            ("services/product/identity/identity-backend", "identity-backend"),
-            ("services/product/identity/identity-frontend", "identity-frontend"),
-            ("services/product/order/order-backend", "order-backend"),
-        ]
-        
-        for resource_path, resource_name in resources:
-            resource_dir = temp_dir / resource_path
-            resource_dir.mkdir(parents=True)
-            resource_file = resource_dir / "service.json"
-            resource_file.write_text(json.dumps({
-                "name": resource_name,
-                "type": "backend" if "backend" in resource_name else "frontend",
-                "stack": resource_path.split("/")[2],
-                "port": 4001 if "backend" in resource_name else 3001
-            }))
-        
-        # Import and test
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import get_current_resources
-        
-        # Change to temp directory for scanning
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            found_resources = get_current_resources("services/product")
-            
-            assert len(found_resources) == 3, f"Expected 3 resources, found {len(found_resources)}"
-            assert all("service.json" in r for r in found_resources), "All resources should be service.json files"
-        finally:
-            os.chdir(original_dir)
-    
-    def test_scanning_ignores_non_resource_files(self, temp_dir, monkeypatch):
-        """
-        Scenario: Scanning ignores non-resource files
-        WHEN the scanner runs against a directory containing service.json and package.json and README.md
-        THEN it SHALL only return the resource defined in service.json
-        """
-        # Create directory with mixed files
-        resource_dir = temp_dir / "services" / "product" / "test"
-        resource_dir.mkdir(parents=True)
-        
-        # Create service.json
-        (resource_dir / "service.json").write_text(json.dumps({"name": "test-resource"}))
-        # Create non-resource files
-        (resource_dir / "package.json").write_text('{"name": "test"}')
-        (resource_dir / "README.md").write_text("# Test Resource")
-        (resource_dir / "config.ts").write_text("export const config = {};")
-        
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import get_current_resources
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            found_resources = get_current_resources("services/product")
-            
-            assert len(found_resources) == 1, f"Expected 1 resource, found {len(found_resources)}"
-            assert "service.json" in found_resources[0], "Should only find service.json files"
-            assert "package.json" not in found_resources[0], "Should not include package.json"
-        finally:
-            os.chdir(original_dir)
-    
-    def test_scanning_handles_nested_directories(self, temp_dir, monkeypatch):
-        """
-        Scenario: Scanning handles nested directories
-        WHEN the scanner runs against a directory with nested resources/ subdirectory containing service.json
-        THEN it SHALL find resources at any depth and return correct relative paths
-        """
-        # Create deeply nested structure
-        nested_dirs = [
-            "services/product/stack1/backend/service.json",
-            "services/product/stack1/frontend/service.json",
-            "services/product/stack2/substack/backend/service.json",
-        ]
-        
-        for path in nested_dirs:
-            full_path = temp_dir / path
-            full_path.parent.mkdir(parents=True, exist_ok=True)
-            full_path.write_text(json.dumps({"name": "test"}))
-        
-        import sys
-        sys.path.insert(0, str(Path("discovery").resolve()))
-        from resource_snapshot import get_current_resources
-        
-        original_dir = os.getcwd()
-        os.chdir(temp_dir)
-        
-        try:
-            found_resources = get_current_resources("services/product")
-            
-            assert len(found_resources) == 3, f"Expected 3 resources, found {len(found_resources)}"
-            # Verify all paths are relative and contain the full path
-            assert all("stack1" in r or "stack2" in r for r in found_resources)
-            assert all("service.json" in r for r in found_resources)
-        finally:
-            os.chdir(original_dir)

package/tests/tilt-engine/test_standalone_project_boot.py

@@ -1,61 +0,0 @@
-"""Regression tests for standalone generated-project boot.
-
-Standalone TDK projects do not ship Traefik/Verdaccio compose files. The
-Tiltfile still has to load the project-root .env and publish host ports so
-the generated API is reachable at localhost:<port>.
-"""
-
-from pathlib import Path
-
-import pytest
-
-pytestmark = [pytest.mark.fast, pytest.mark.generator]
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-
-
-def test_load_dotenv_uses_tdk_project_root():
-    source = (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "tilt"
-        / "common"
-        / "utils_env.star"
-    ).read_text()
-    assert "TDK_PROJECT_ROOT" in source
-    assert "if not project_root:" in source
-
-
-def test_tiltfile_template_passes_project_root_to_load_dotenv():
-    source = (REPO_ROOT / "cli" / "templates" / "Tiltfile.hbs").read_text()
-    assert "Utils.load_dotenv(PROJECT_ROOT)" in source
-    assert "Utils.load_dotenv()" not in source
-
-
-def test_compose_registration_applies_port_override_when_present():
-    source = (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "tilt"
-        / "resources"
-        / "orchestrator"
-        / "apply_compose_resource_registration.star"
-    ).read_text()
-    assert "docker-compose.port-override.yml" in source
-    assert "Applying port override" in source
-
-
-def test_verdaccio_dependency_requires_compose_file():
-    source = (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "tilt"
-        / "resources"
-        / "orchestrator"
-        / "apply_compose_resource_registration.star"
-    ).read_text()
-    assert "docker-compose.verdaccio.yml" in source
-    assert "infra_deps.append(PlatformDockerConstants.VERDACCIO_RESOURCE_NAME)" in source

package/tests/tilt-engine/test_standalone_traefik.py

@@ -1,160 +0,0 @@
-"""Standalone TDK projects must serve api.{project}.localhost via Traefik."""
-
-import json
-import shutil
-import subprocess
-from pathlib import Path
-
-import pytest
-
-pytestmark = [pytest.mark.fast, pytest.mark.generator]
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-COMPOSE_DIR = REPO_ROOT / "engine" / "topologies" / "platform" / "docker" / "compose"
-RESULT_MARKER = "Error in fail: RESULT"
-
-
-def _run_starlark(tmp_path: Path, body: str) -> dict:
-    tiltfile = tmp_path / "Tiltfile"
-    tiltfile.write_text(body.replace("@COMPOSE", str(COMPOSE_DIR)) + "\nfail('RESULT' + encode_json(r))\n")
-    proc = subprocess.run(
-        ["tilt", "alpha", "tiltfile-result", "-f", str(tiltfile)],
-        capture_output=True,
-        text=True,
-        timeout=180,
-    )
-    output = proc.stdout + proc.stderr
-    assert RESULT_MARKER in output, output[-3000:]
-    return json.loads(output.split(RESULT_MARKER, 1)[1].strip())
-
-
-def test_standalone_traefik_compose_generator_exists():
-    source = (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "platform"
-        / "docker"
-        / "compose"
-        / "traefik_standalone.star"
-    ).read_text()
-    assert "generate_standalone_traefik_compose" in source
-    assert "entrypoints.web.address=:80" in source
-
-
-def test_infra_loader_falls_back_to_standalone_traefik():
-    source = (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "tilt"
-        / "resources"
-        / "infra-loader.star"
-    ).read_text()
-    assert "_load_standalone_traefik" in source
-    assert "using standalone Traefik" in source
-
-
-def test_project_router_uses_cli_api_path():
-    source = (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "platform"
-        / "docker"
-        / "networking"
-        / "traefik_helpers.star"
-    ).read_text()
-    assert "def cli_api_path(" in source
-    assert "tdk up" in source
-
-
-def test_tiltfile_keeps_traefik_in_focus_mode():
-    source = (REPO_ROOT / "cli" / "templates" / "Tiltfile.hbs").read_text()
-    assert "'traefik'" in source
-    assert "init-networks" in source
-
-
-def _infra_loader_source() -> str:
-    return (
-        REPO_ROOT
-        / "engine"
-        / "topologies"
-        / "tilt"
-        / "resources"
-        / "infra-loader.star"
-    ).read_text()
-
-
-def test_standalone_traefik_stops_conflicting_container_before_compose_up():
-    """Two standalone TDK projects both generate Traefik with hardcoded host
-    ports 80/8080 (so api.{project}.localhost works without a port suffix), so
-    only one can bind port 80 at a time. `tdk up` on a new project must take
-    over the port from a stale Traefik left running by a previous project
-    rather than letting `docker compose up` die deep inside Tilt with a
-    cryptic "port is already allocated" networking error.
-    """
-    source = _infra_loader_source()
-    assert "_stop_conflicting_traefik" in source
-
-    # The takeover must run before docker_compose() is invoked for the
-    # standalone Traefik compose, not after. Search from the function body
-    # (not its definition line, which also contains the substring
-    # "..._traefik()").
-    load_standalone_def = source.index("def _load_standalone_traefik(")
-    stop_call = source.index("_stop_conflicting_traefik()", load_standalone_def)
-    docker_compose_call = source.index("_docker_compose(compose_file, env_file)", load_standalone_def)
-    assert load_standalone_def < stop_call < docker_compose_call
-
-
-def test_traefik_conflict_takeover_stops_other_project_and_logs_it():
-    source = _infra_loader_source()
-    stop_start = source.index("def _stop_conflicting_traefik():")
-    stop_body = source[stop_start:source.index("def _load_standalone_traefik(")]
-
-    # Detects other containers publishing the ports this project's Traefik needs.
-    assert "docker ps" in stop_body
-    assert "publish=80" in stop_body
-    assert "publish=8080" in stop_body
-
-    # Must not stop this project's own (already-running) Traefik.
-    assert "PlatformDockerConstants.PROJECT_NAME" in stop_body
-    assert "own_container" in stop_body
-
-    # Actually stops the other project's container and logs what was stopped,
-    # instead of just erroring out.
-    assert "docker stop" in stop_body
-    assert "print(" in stop_body
-
-
-@pytest.mark.skipif(shutil.which("tilt") is None, reason="tilt CLI not installed")
-def test_standalone_compose_enables_file_provider_and_wake_gateway(tmp_path):
-    """openspec/changes/prioritized-cold-start (D4): a `sablier.deferStart`
-    resource's static route needs Traefik's file provider enabled and a wake
-    gateway running, even in a landscape with no such resource yet (harmless:
-    an empty dynamic directory yields zero extra routes)."""
-    r = _run_starlark(
-        tmp_path,
-        "load('@COMPOSE/traefik_standalone.star', 'generate_standalone_traefik_compose')\n"
-        "r = {'yaml': generate_standalone_traefik_compose()}\n",
-    )
-    yaml_text = r["yaml"]
-    assert "--providers.file.directory=/etc/traefik/dynamic" in yaml_text
-    assert "--providers.file.watch=true" in yaml_text
-    assert "/etc/traefik/dynamic:ro" in yaml_text
-    assert "wake-gateway:" in yaml_text
-    assert "/root/.tilt-dev:ro" in yaml_text
-
-
-@pytest.mark.skipif(shutil.which("tilt") is None, reason="tilt CLI not installed")
-def test_wake_gateway_mounts_project_root_at_its_own_absolute_path(tmp_path):
-    """The gateway runs `docker compose up --no-build` with the same compose
-    files Tilt uses; relative paths inside them resolve client-side, so the
-    project must exist at the same absolute path in the gateway container."""
-    r = _run_starlark(
-        tmp_path,
-        "os.environ['TDK_PROJECT_ROOT'] = '/Users/dev/tdk-erp-system/.tdk/.tdk-out/../..'\n"
-        "load('@COMPOSE/traefik_standalone.star', 'generate_standalone_traefik_compose')\n"
-        "r = {'yaml': generate_standalone_traefik_compose()}\n",
-    )
-    assert "- /Users/dev/tdk-erp-system:/Users/dev/tdk-erp-system:ro" in r["yaml"]