@tdk-landscape/tdk-cli-core 1.3.44 → 1.3.48

package/tests/tilt-engine/test_config_inspector.py

@@ -0,0 +1,162 @@
+"""
+Tests for config inspector component.
+Tests the multi-pane comparison and editing features.
+"""
+
+import os
+import pytest
+import hashlib
+from pathlib import Path
+
+
+@pytest.mark.ide
+class TestConfigInspector:
+    """Tests for config inspector functionality."""
+    
+    def test_single_pane_default_view(self):
+        """
+        Scenario: Single-pane default view
+        WHEN a user requests `GET /`
+        THEN it SHALL display a single pane with the first master config
+        """
+        # Simulate default view
+        panes = [{"name": "TILT_RESOURCE_DEFAULTS.star", "content": "# Content"}]
+        
+        assert len(panes) == 1, "Default view should have 1 pane"
+        assert "TILT_RESOURCE_DEFAULTS.star" in panes[0]["name"]
+    
+    def test_dual_pane_comparison(self):
+        """
+        Scenario: Dual-pane comparison
+        WHEN a user requests `GET /?master1=TILT_RESOURCE_DEFAULTS.star&master2=spec.master`
+        THEN it SHALL display two panes side-by-side
+        AND both configs SHALL be viewable simultaneously
+        """
+        # Simulate dual-pane request
+        requested_masters = ["TILT_RESOURCE_DEFAULTS.star", "spec.master"]
+        
+        panes = [
+            {"name": name, "content": f"# {name} content"}
+            for name in requested_masters
+        ]
+        
+        assert len(panes) == 2, "Dual-pane should have 2 panes"
+        assert all(p["name"] in requested_masters for p in panes)
+    
+    def test_triple_pane_with_sync_scroll(self):
+        """
+        Scenario: Triple-pane with sync scroll
+        WHEN a user requests `GET /?master1=A.star&master2=B.star&master3=C.star&sync=true`
+        THEN it SHALL display three panes
+        AND scrolling one pane SHALL sync scroll the others
+        """
+        requested_masters = ["A.star", "B.star", "C.star"]
+        sync_enabled = True
+        
+        panes = [
+            {"name": name, "content": f"# {name} content", "sync_scroll": sync_enabled}
+            for name in requested_masters
+        ]
+        
+        assert len(panes) == 3, "Triple-pane should have 3 panes"
+        assert all(p.get("sync_scroll") for p in panes), "All panes should have sync scroll enabled"
+    
+    def test_edit_mode_toggle(self, temp_dir):
+        """
+        Scenario: Edit mode toggle
+        WHEN a user clicks the "✏️ Edit Mode" button
+        THEN textareas SHALL become editable
+        AND save buttons SHALL appear for each pane
+        """
+        # Simulate edit mode toggle
+        edit_mode = True
+        
+        pane = {
+            "name": "test.star",
+            "content": "# Original",
+            "editable": edit_mode,
+            "dirty": False
+        }
+        
+        assert pane["editable"], "Pane should be editable in edit mode"
+        
+        # Simulate edit
+        pane["content"] = "# Modified"
+        pane["dirty"] = True
+        
+        assert pane["dirty"], "Pane should be marked as dirty after edit"
+    
+    def test_safe_file_saving_with_backups(self, temp_dir):
+        """
+        Scenario: Safe file saving
+        WHEN a user saves changes in edit mode
+        THEN it SHALL create a backup in `.backups/` before writing
+        AND it SHALL use atomic write (temp file + rename)
+        """
+        test_file = temp_dir / "test.star"
+        original_content = "# Original content"
+        test_file.write_text(original_content)
+        
+        # Create backup directory
+        backup_dir = temp_dir / ".backups"
+        backup_dir.mkdir(exist_ok=True)
+        
+        # Simulate safe save
+        new_content = "# Modified content"
+        self._safe_save_file(test_file, new_content, backup_dir)
+        
+        # Verify backup created (backup files are named like "test.star.0")
+        backup_files = list(backup_dir.glob(f"{test_file.name}.*"))
+        assert len(backup_files) > 0, f"Backup should be created in {backup_dir}"
+        
+        # Verify new content written
+        assert test_file.read_text() == new_content, "File should have new content"
+        
+        # Verify backup has original content
+        backup_content = backup_files[0].read_text()
+        assert backup_content == original_content, "Backup should have original content"
+    
+    def test_conflict_detection(self, temp_dir):
+        """
+        Scenario: Conflict detection
+        WHEN a user attempts to save but the file was modified on disk since loading
+        THEN it SHALL return `409 Conflict` with current file hash
+        AND it SHALL ask user to refresh and retry
+        """
+        test_file = temp_dir / "test.star"
+        original_content = "# Version 1"
+        test_file.write_text(original_content)
+        
+        # Load file and compute hash
+        loaded_content = test_file.read_text()
+        loaded_hash = hashlib.sha256(loaded_content.encode()).hexdigest()
+        
+        # Simulate external modification
+        test_file.write_text("# Version 2 (external change)")
+        
+        # Try to save with old hash
+        current_content = test_file.read_text()
+        current_hash = hashlib.sha256(current_content.encode()).hexdigest()
+        
+        # Hash mismatch = conflict
+        assert loaded_hash != current_hash, "Should detect conflict (hash mismatch)"
+    
+    def _safe_save_file(self, path: Path, content: str, backup_dir: Path):
+        """Simulate safe file save with backup."""
+        import tempfile
+        import shutil
+        
+        # Create backup
+        if path.exists():
+            backup_path = backup_dir / f"{path.name}.{len(list(backup_dir.glob('*')))}"
+            shutil.copy2(path, backup_path)
+        
+        # Atomic write using temp file
+        temp_fd, temp_path = tempfile.mkstemp(dir=path.parent)
+        try:
+            with os.fdopen(temp_fd, 'w') as f:
+                f.write(content)
+            os.replace(temp_path, path)
+        except Exception:
+            os.unlink(temp_path)
+            raise

package/tests/tilt-engine/test_daemon_focus_mode.py

@@ -0,0 +1,89 @@
+"""
+Tests for daemon focus mode compliance.
+Tests that discovery respects focus mode stack restrictions.
+"""
+
+import pytest
+from pathlib import Path
+import json
+
+
+@pytest.mark.daemon
+class TestDaemonFocusMode:
+    """Tests for focus mode compliance."""
+    
+    def test_focus_mode_restricts_discovery(self, temp_dir):
+        """
+        Scenario: Focus mode restricts discovery
+        WHEN `--focus identity` is enabled and a new resource appears in `services/product/billing/`
+        THEN the daemon SHALL NOT trigger registration (queue it for later)
+        AND it SHALL log "⏳ Resource queued (focus mode)"
+        """
+        # Simulate focus mode config
+        focus_config = {
+            "enabled": True,
+            "stacks": ["identity", "order"],
+            "excluded_paths": []
+        }
+        
+        # Resource outside focus
+        resource_stack = "billing"
+        is_in_focus = resource_stack in focus_config["stacks"]
+        
+        assert not is_in_focus, "billing should not be in focus mode"
+        
+        # In real daemon, this would queue instead of registering
+        # For test, verify the filtering logic works
+        should_register = not focus_config["enabled"] or is_in_focus
+        assert not should_register, "Resource outside focus should not be registered immediately"
+    
+    def test_focus_mode_allows_matching_resources(self, temp_dir):
+        """
+        Scenario: Focus mode allows matching resources
+        WHEN `--focus identity` is enabled and a new resource appears in `services/product/identity/`
+        THEN the daemon SHALL trigger registration normally
+        """
+        # Create resource in focus stack
+        focus_config = {
+            "enabled": True,
+            "stacks": ["identity", "order"],
+            "excluded_paths": []
+        }
+        
+        resource_stack = "identity"
+        is_in_focus = resource_stack in focus_config["stacks"]
+        
+        assert is_in_focus, "identity should be in focus mode"
+        
+        # In focus - should register
+        should_register = not focus_config["enabled"] or is_in_focus
+        assert should_register, "Resource in focus should be registered"
+    
+    def test_focus_mode_disabled_allows_all(self):
+        """Test that when focus mode is disabled, all resources are registered."""
+        focus_config = {
+            "enabled": False,
+            "stacks": ["identity"],
+            "excluded_paths": []
+        }
+        
+        resource_stack = "billing"
+        is_in_focus = resource_stack in focus_config["stacks"]
+        
+        # Focus disabled - should register regardless
+        should_register = not focus_config["enabled"] or is_in_focus
+        assert should_register, "When focus mode disabled, all resources should register"
+    
+    def test_focus_mode_stack_matching(self):
+        """Test stack matching logic for focus mode."""
+        test_cases = [
+            ({"enabled": True, "stacks": ["identity"]}, "identity", True),
+            ({"enabled": True, "stacks": ["identity"]}, "billing", False),
+            ({"enabled": True, "stacks": ["identity", "order"]}, "order", True),
+            ({"enabled": False, "stacks": ["identity"]}, "billing", True),
+        ]
+        
+        for config, stack, expected in test_cases:
+            is_in_focus = stack in config["stacks"]
+            should_register = not config["enabled"] or is_in_focus
+            assert should_register == expected, f"Failed for {stack} with config {config}"

package/tests/tilt-engine/test_daemon_polling.py

@@ -0,0 +1,122 @@
+"""
+Tests for discovery daemon polling behavior.
+Tests the continuous monitoring and polling intervals.
+"""
+
+import asyncio
+import pytest
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+
+
+@pytest.mark.daemon
+class TestDaemonPolling:
+    """Tests for daemon polling functionality."""
+    
+    @pytest.mark.asyncio
+    async def test_daemon_polls_at_configured_interval(self):
+        """
+        Scenario: Daemon polls at configured interval
+        WHEN the daemon starts with `DISCOVERY_SCAN_INTERVAL=2`
+        THEN it SHALL call the scanner function every 2 seconds
+        """
+        mock_scanner = Mock(return_value=[])
+        
+        # Mock the daemon loop to run only 3 iterations
+        call_count = 0
+        async def mock_daemon_loop():
+            nonlocal call_count
+            for _ in range(3):
+                mock_scanner()
+                call_count += 1
+                await asyncio.sleep(0.1)  # Fast sleep for testing
+        
+        # Run the mock daemon
+        await mock_daemon_loop()
+        
+        assert call_count == 3, f"Expected 3 polling calls, got {call_count}"
+        assert mock_scanner.call_count == 3
+    
+    @pytest.mark.asyncio
+    async def test_daemon_stops_cleanly_on_signal(self):
+        """
+        Scenario: Daemon can be stopped
+        WHEN the daemon receives a stop signal
+        THEN it SHALL cease polling and exit cleanly within 1 second
+        """
+        stop_event = asyncio.Event()
+        poll_count = [0]  # Use list to allow mutation in nested function
+        
+        async def polling_loop():
+            while not stop_event.is_set():
+                poll_count[0] += 1
+                try:
+                    await asyncio.wait_for(stop_event.wait(), timeout=0.1)
+                except asyncio.TimeoutError:
+                    pass
+        
+        # Start polling
+        task = asyncio.create_task(polling_loop())
+        
+        # Let it poll a few times
+        await asyncio.sleep(0.25)
+        
+        # Signal stop
+        stop_event.set()
+        
+        # Wait for clean exit with timeout
+        try:
+            await asyncio.wait_for(task, timeout=1.0)
+        except asyncio.TimeoutError:
+            task.cancel()
+        
+        assert poll_count[0] >= 2, "Should have polled at least twice"
+        assert task.done(), "Task should be completed"
+    
+    def test_polling_respects_interval_setting(self):
+        """Test that the daemon respects DISCOVERY_SCAN_INTERVAL."""
+        import os
+        
+        # Default should be 5 seconds
+        interval = int(os.environ.get("DISCOVERY_SCAN_INTERVAL", "5"))
+        
+        assert interval > 0, "Interval should be positive"
+        assert interval <= 60, "Interval should be reasonable (<= 60s)"
+    
+    @pytest.mark.asyncio
+    async def test_polling_detects_changes_over_time(self, temp_dir):
+        """Test that daemon detects changes across multiple polling cycles."""
+        from pathlib import Path
+        import json
+        
+        # Create initial service
+        services_dir = temp_dir / "services" / "product"
+        services_dir.mkdir(parents=True)
+        
+        resource_dir = services_dir / "initial" / "service"
+        resource_dir.mkdir(parents=True)
+        (resource_dir / "service.json").write_text(json.dumps({"name": "initial"}))
+        
+        poll_results = []
+        
+        async def mock_scan_cycle():
+            # Simulate scanning
+            import sys
+            sys.path.insert(0, str(Path("discovery").resolve()))
+            from resource_snapshot import get_current_services
+            
+            services = get_current_services(str(services_dir))
+            poll_results.append(len(services))
+        
+        # First poll - should find 1 service
+        await mock_scan_cycle()
+        assert poll_results[-1] == 1
+        
+        # Add new service
+        new_dir = services_dir / "new" / "service"
+        new_dir.mkdir(parents=True)
+        (new_dir / "service.json").write_text(json.dumps({"name": "new"}))
+        
+        # Second poll - should find 2 services
+        await mock_scan_cycle()
+        assert poll_results[-1] == 2

package/tests/tilt-engine/test_daemon_registration.py

@@ -0,0 +1,115 @@
+"""
+Tests for daemon auto-registration functionality.
+Tests the triggering of Tilt resource creation for new services.
+"""
+
+import pytest
+from pathlib import Path
+from unittest.mock import Mock, patch, call
+import json
+
+
+@pytest.mark.daemon
+class TestDaemonRegistration:
+    """Tests for daemon auto-registration."""
+    
+    def test_new_resource_triggers_registration(self, temp_dir):
+        """
+        Scenario: New service triggers registration
+        WHEN the daemon detects a new service.json file not in the cache
+        THEN it SHALL emit a registration event with the service path and metadata
+        AND the Tilt resource for that service SHALL be created
+        """
+        from pathlib import Path
+        import sys
+        sys.path.insert(0, str(Path("discovery").resolve()))
+        from resource_snapshot import diff_snapshots, save_snapshot, load_snapshot
+        
+        original_dir = Path.cwd()
+        
+        try:
+            # Set up initial snapshot
+            services_dir = temp_dir / "services" / "product"
+            initial_service = services_dir / "existing" / "service"
+            initial_service.mkdir(parents=True)
+            (initial_service / "service.json").write_text(json.dumps({"name": "existing"}))
+            
+            import os
+            os.chdir(temp_dir)
+            
+            # Save initial snapshot
+            from resource_snapshot import get_current_services
+            initial_services = get_current_services("services/product")
+            save_snapshot(initial_services)
+            
+            # Simulate adding new service
+            new_service = services_dir / "new" / "service"
+            new_service.mkdir(parents=True)
+            (new_service / "service.json").write_text(json.dumps({"name": "new"}))
+            
+            # Get current services and diff
+            current_services = get_current_services("services/product")
+            old_snapshot = load_snapshot()
+            
+            added, removed, modified = diff_snapshots(old_snapshot, current_services)
+            
+            # Verify new service was detected
+            assert len(added) == 1, f"Expected 1 new service, got {len(added)}"
+            assert any("new" in s for s in added), "Should detect the new service"
+        finally:
+            os.chdir(original_dir)
+    
+    def test_unchanged_services_do_not_trigger(self, temp_dir):
+        """
+        Scenario: No registration for unchanged services
+        WHEN the daemon scans and finds no changes from previous snapshot
+        THEN it SHALL NOT emit any registration events
+        """
+        from pathlib import Path
+        import sys
+        import os
+        sys.path.insert(0, str(Path("discovery").resolve()))
+        from resource_snapshot import save_snapshot, load_snapshot, diff_snapshots, get_current_services
+        
+        original_dir = Path.cwd()
+        
+        try:
+            # Set up services
+            services_dir = temp_dir / "services" / "product"
+            resource_dir = services_dir / "stable" / "service"
+            resource_dir.mkdir(parents=True)
+            (resource_dir / "service.json").write_text(json.dumps({"name": "stable"}))
+            
+            os.chdir(temp_dir)
+            
+            # Save snapshot
+            services = get_current_services("services/product")
+            save_snapshot(services)
+            
+            # Scan again (no changes)
+            current_services = get_current_services("services/product")
+            old_snapshot = load_snapshot()
+            
+            added, removed, modified = diff_snapshots(old_snapshot, current_services)
+            
+            # Verify no changes detected
+            assert len(added) == 0, "Should have no added services"
+            assert len(removed) == 0, "Should have no removed services"
+            assert len(modified) == 0, "Should have no modified services"
+        finally:
+            os.chdir(original_dir)
+    
+    def test_registration_includes_resource_metadata(self):
+        """Test that registration events include full service metadata."""
+        mock_registration_event = {
+            "path": "services/product/test/service.json",
+            "name": "test-service",
+            "type": "backend",
+            "stack": "test",
+            "port": 4000
+        }
+        
+        assert "path" in mock_registration_event
+        assert "name" in mock_registration_event
+        assert "type" in mock_registration_event
+        assert "port" in mock_registration_event

package/tests/tilt-engine/test_daemon_validation.py

@@ -0,0 +1,107 @@
+"""
+Tests for daemon service validation.
+Tests that invalid service.json files are rejected before registration.
+"""
+
+import pytest
+import json
+from pathlib import Path
+
+
+@pytest.mark.daemon
+class TestDaemonValidation:
+    """Tests for service validation."""
+    
+    def test_invalid_resource_json_rejected(self):
+        """
+        Scenario: Invalid service.json rejected
+        WHEN a new service.json file has missing required fields (e.g., no `name`)
+        THEN the daemon SHALL log "❌ Invalid service.json at {path}"
+        AND it SHALL NOT attempt registration
+        """
+        # Invalid service - missing required fields
+        invalid_service = {
+            "type": "backend",
+            "port": 4000
+            # Missing: name, domain, path
+        }
+        
+        # Validate required fields
+        required_fields = ["name", "type", "domain", "path"]
+        missing_fields = [f for f in required_fields if f not in invalid_service]
+        
+        assert len(missing_fields) > 0, "Should detect missing fields"
+        assert "name" in missing_fields, "Should detect missing 'name' field"
+        
+        # In real daemon, this would be rejected
+        is_valid = len(missing_fields) == 0
+        assert not is_valid, "Invalid service should be rejected"
+    
+    def test_valid_resource_json_accepted(self):
+        """
+        Scenario: Valid service.json accepted
+        WHEN a new service.json file has all required fields (`name`, `type`, `domain`, `port`)
+        THEN the daemon SHALL proceed with registration
+        """
+        # Valid service with all required fields
+        valid_service = {
+            "name": "test-service",
+            "type": "backend",
+            "stack": "test",
+            "port": 4000,
+            "path": "services/product/test/test-service"
+        }
+        
+        required_fields = ["appName", "appType", "stack", "path"]
+        missing_fields = [f for f in required_fields if f not in valid_service]
+        
+        is_valid = len(missing_fields) == 0
+        assert is_valid, "Valid service should be accepted"
+    
+    def test_validation_detects_port_range(self):
+        """Test that port is validated to be in reasonable range."""
+        test_cases = [
+            ({"appName": "test", "appType": "backend", "stack": "test", "path": "p", "port": 3000}, True),
+            ({"appName": "test", "appType": "backend", "stack": "test", "path": "p", "port": 9999}, True),
+            ({"appName": "test", "appType": "backend", "stack": "test", "path": "p", "port": 80}, False),  # Too low
+            ({"appName": "test", "appType": "backend", "stack": "test", "path": "p", "port": 100000}, False),  # Too high
+        ]
+        
+        for service, expected_valid in test_cases:
+            port = service.get("port", 0)
+            is_valid = 3000 <= port <= 9999
+            assert is_valid == expected_valid, f"Port {port} validation failed"
+    
+    def test_validation_detects_invalid_type(self):
+        """Test that appType is validated against allowed values."""
+        valid_types = ["backend", "frontend", "library", "migrator", "sdk", "worker"]
+        
+        test_cases = [
+            ("backend", True),
+            ("frontend", True),
+            ("microservice", False),  # Invalid type
+            ("api", False),  # Invalid type
+        ]
+        
+        for app_type, expected_valid in test_cases:
+            is_valid = app_type in valid_types
+            assert is_valid == expected_valid, f"Type '{app_type}' validation failed"
+    
+    def test_validation_allows_optional_fields(self):
+        """Test that optional fields don't cause validation failure."""
+        resource_with_optional = {
+            "name": "test-service",
+            "type": "backend",
+            "stack": "test",
+            "port": 4000,
+            "path": "services/product/test/test-service",
+            # Optional fields
+            "features": ["prisma", "nats"],
+            "replicas": 2,
+            "healthCheck": True
+        }
+        
+        required_fields = ["name", "type", "domain", "path"]
+        has_all_required = all(f in resource_with_optional for f in required_fields)
+        
+        assert has_all_required, "Service with optional fields should still be valid"