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

package/tests/tilt-engine/test_config_inspector.py

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

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

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

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

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