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

package/tests/tilt-engine/test_safety_aliases.py

@@ -0,0 +1,84 @@
+"""
+Tests for safety shell aliases.
+Tests the alias configuration and functionality.
+"""
+
+import pytest
+
+
+@pytest.mark.safety
+class TestSafetyAliases:
+    """Tests for safety alias functionality."""
+    
+    def test_safe_prune_alias_works(self):
+        """
+        Scenario: Safe prune alias works
+        WHEN a user runs `docker-prune-safe` after sourcing aliases
+        THEN it SHALL execute `safe-docker-prune.sh standard`
+        """
+        alias_mapping = {
+            "docker-prune-safe": "./scripts/safe-docker-prune.sh standard",
+        }
+        
+        assert "docker-prune-safe" in alias_mapping
+        assert "safe-docker-prune.sh" in alias_mapping["docker-prune-safe"]
+        assert "standard" in alias_mapping["docker-prune-safe"]
+    
+    def test_full_prune_alias_works(self):
+        """
+        Scenario: Full prune alias works
+        WHEN a user runs `docker-prune-full` after sourcing aliases
+        THEN it SHALL execute `safe-docker-prune.sh full`
+        """
+        alias_mapping = {
+            "docker-prune-full": "./scripts/safe-docker-prune.sh full",
+        }
+        
+        assert "docker-prune-full" in alias_mapping
+        assert "safe-docker-prune.sh" in alias_mapping["docker-prune-full"]
+        assert "full" in alias_mapping["docker-prune-full"]
+    
+    def test_alias_is_idempotent(self):
+        """
+        Scenario: Alias is idempotent
+        WHEN a user sources the aliases file multiple times
+        THEN the aliases SHALL remain functional
+        AND no duplicate definitions SHALL cause errors
+        """
+        # Simulate sourcing aliases multiple times
+        aliases = {}
+        
+        # First source
+        aliases["docker-prune-safe"] = "./scripts/safe-docker-prune.sh standard"
+        
+        # Second source (should overwrite, not duplicate)
+        aliases["docker-prune-safe"] = "./scripts/safe-docker-prune.sh standard"
+        
+        # Third source
+        aliases["docker-prune-safe"] = "./scripts/safe-docker-prune.sh standard"
+        
+        # Should still work correctly
+        assert len(aliases) == 1
+        assert aliases["docker-prune-safe"] == "./scripts/safe-docker-prune.sh standard"
+    
+    def test_protected_volumes_alias_exists(self):
+        """Test that docker-protected-volumes alias exists."""
+        alias_mapping = {
+            "docker-protected-volumes": "docker volume ls | grep -E '(verdaccio|infisical)'",
+        }
+        
+        assert "docker-protected-volumes" in alias_mapping
+        assert "verdaccio" in alias_mapping["docker-protected-volumes"]
+        assert "infisical" in alias_mapping["docker-protected-volumes"]
+    
+    def test_alias_commands_are_safe(self):
+        """Test that aliased commands don't use --volumes with prune."""
+        alias_commands = [
+            "./scripts/safe-docker-prune.sh standard",
+            "./scripts/safe-docker-prune.sh full",
+        ]
+        
+        for cmd in alias_commands:
+            # Safe commands should use the script, not direct docker prune
+            assert "safe-docker-prune.sh" in cmd, "Should use safe script"
+            assert "docker system prune" not in cmd or "--volumes" not in cmd, "Should not use dangerous direct prune"

package/tests/tilt-engine/test_snapshot_diff.py

@@ -0,0 +1,136 @@
+"""
+Tests for snapshot diff detection functionality.
+Tests the comparison between old and new snapshots.
+"""
+
+import pytest
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path("discovery").resolve()))
+from resource_snapshot import diff_snapshots
+
+
+@pytest.mark.snapshot
+class TestSnapshotDiff:
+    """Tests for snapshot diff detection."""
+    
+    def test_detects_new_services(self):
+        """
+        Scenario: Detecting new services
+        WHEN a new service.json file appears in a previously empty directory
+        THEN the diff SHALL report "added" with the new service path and metadata
+        """
+        old = {"services": [], "count": 0}
+        new = ["services/product/new/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == {"services/product/new/service.json"}
+        assert removed == set()
+        assert modified == set()
+    
+    def test_detects_removed_services(self):
+        """
+        Scenario: Detecting removed services
+        WHEN an existing service.json file is deleted
+        THEN the diff SHALL report "removed" with the removed service path
+        """
+        old = {"services": ["services/product/old/service.json"], "count": 1}
+        new = []
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == set()
+        assert removed == {"services/product/old/service.json"}
+        assert modified == set()
+    
+    def test_detects_modified_services(self, temp_dir):
+        """
+        Scenario: Detecting modified services
+        WHEN an existing service.json file changes its content (hash differs)
+        THEN the diff SHALL report "modified" with the field changes and service path
+        """
+        import os
+        original_dir = os.getcwd()
+        
+        try:
+            os.chdir(temp_dir)
+            
+            # Create a service file
+            resource_dir = temp_dir / "services" / "product" / "test"
+            resource_dir.mkdir(parents=True)
+            resource_file = resource_dir / "service.json"
+            resource_file.write_text('{"name": "test", "version": "1.0.0"}')
+            
+            # Use relative path for service
+            rel_path = "services/product/test/service.json"
+            
+            # Create old snapshot with hash of old content
+            from resource_snapshot import compute_resource_hash
+            old_hash = compute_resource_hash(rel_path)
+            old = {
+                "services": [rel_path],
+                "count": 1,
+                "resource_hashes": {rel_path: old_hash}
+            }
+            
+            # Modify the file
+            resource_file.write_text('{"name": "test", "version": "2.0.0"}')
+            new = [rel_path]
+            
+            added, removed, modified = diff_snapshots(old, new, use_hashes=True)
+            
+            assert added == set()
+            assert removed == set()
+            assert modified == {rel_path}
+        finally:
+            os.chdir(original_dir)
+    
+    def test_no_changes_detected(self):
+        """
+        Scenario: No changes detected
+        WHEN the filesystem matches the existing snapshot exactly
+        THEN the diff SHALL report an empty changeset
+        """
+        old = {
+            "services": [
+                "services/product/a/service.json",
+                "services/product/b/service.json"
+            ],
+            "count": 2,
+            "hash": "abc123"  # This hash will mismatch, but individual hashes match
+        }
+        new = [
+            "services/product/a/service.json",
+            "services/product/b/service.json"
+        ]
+        
+        # Without actual hash computation, should find no changes
+        added, removed, modified = diff_snapshots(old, new, use_hashes=False)
+        
+        assert added == set()
+        assert removed == set()
+        assert modified == set()
+    
+    def test_detects_both_added_and_removed(self):
+        """Test detecting simultaneous additions and removals."""
+        old = {"services": ["a/service.json", "b/service.json"], "count": 2}
+        new = ["b/service.json", "c/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == {"c/service.json"}
+        assert removed == {"a/service.json"}
+        assert modified == set()
+    
+    def test_empty_to_multiple_services(self):
+        """Test diff when going from empty to multiple services."""
+        old = {"services": [], "count": 0}
+        new = ["a/service.json", "b/service.json", "c/service.json"]
+        
+        added, removed, modified = diff_snapshots(old, new)
+        
+        assert added == {"a/service.json", "b/service.json", "c/service.json"}
+        assert removed == set()
+        assert modified == set()

package/tests/tilt-engine/test_snapshot_persistence.py

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

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

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

@@ -0,0 +1,108 @@
+"""Standalone TDK projects must serve api.{project}.localhost via Traefik."""
+
+from pathlib import Path
+
+import pytest
+
+pytestmark = [pytest.mark.fast, pytest.mark.generator]
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+
+
+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

package/dist/cli.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}