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

package/tests/tilt-engine/test_code_executor.py

@@ -1,152 +0,0 @@
-"""
-Tests for code executor component.
-Tests the terminal interface and command safety features.
-"""
-
-import pytest
-import asyncio
-from pathlib import Path
-from typing import List, Tuple
-
-
-@pytest.mark.ide
-class TestCodeExecutor:
-    """Tests for code executor functionality."""
-    
-    def test_allowed_command_execution(self, safe_commands):
-        """
-        Scenario: Allowed command execution
-        WHEN a user submits `bun test` via the terminal interface
-        THEN it SHALL execute the command
-        AND it SHALL stream output to the browser in real-time
-        """
-        for cmd in safe_commands:
-            is_allowed = self._is_command_allowed(cmd)
-            assert is_allowed, f"Command should be allowed: {cmd}"
-    
-    def test_dangerous_command_blocked(self, dangerous_commands):
-        """
-        Scenario: Dangerous command blocked
-        WHEN a user submits `rm -rf /` via the terminal interface
-        THEN it SHALL return `403 Forbidden`
-        AND it SHALL NOT execute the command
-        AND it SHALL log the blocked attempt
-        """
-        for cmd in dangerous_commands:
-            is_allowed = self._is_command_allowed(cmd)
-            assert not is_allowed, f"Dangerous command should be blocked: {cmd}"
-    
-    @pytest.mark.asyncio
-    async def test_timeout_enforcement(self):
-        """
-        Scenario: Timeout enforcement
-        WHEN a user submits a command that runs longer than 60 seconds
-        THEN it SHALL terminate the process after 60 seconds
-        AND it SHALL return partial output with a timeout message
-        """
-        # Simulate long-running command
-        timeout_seconds = 60
-        
-        async def long_command():
-            await asyncio.sleep(100)  # Would run for 100s
-            return "complete"
-        
-        # Wrap with timeout
-        try:
-            result = await asyncio.wait_for(long_command(), timeout=timeout_seconds)
-            assert False, "Should have timed out"
-        except asyncio.TimeoutError:
-            pass  # Expected
-        
-        # Verify timeout occurred
-        assert True, "Timeout was correctly enforced"
-    
-    def test_command_history_navigation(self):
-        """
-        Scenario: Command history
-        WHEN a user presses the Up arrow in the terminal
-        THEN it SHALL display the previously executed command
-        AND Down arrow SHALL navigate forward in history
-        """
-        # Simulate command history
-        history: List[str] = [
-            "bun test",
-            "ls -la",
-            "git status"
-        ]
-        
-        current_index = len(history)  # Start at end (empty line)
-        
-        # Press Up - should go to last command
-        current_index -= 1
-        assert current_index == 2
-        assert history[current_index] == "git status"
-        
-        # Press Up again
-        current_index -= 1
-        assert history[current_index] == "ls -la"
-        
-        # Press Down - should go forward
-        current_index += 1
-        assert history[current_index] == "git status"
-    
-    def test_command_output_streaming(self):
-        """Test that command output streams in real-time."""
-        output_lines = [
-            "Running tests...",
-            "Test 1 passed",
-            "Test 2 passed",
-            "All tests passed!"
-        ]
-        
-        # Simulate streaming
-        received_lines = []
-        for line in output_lines:
-            received_lines.append(line)
-        
-        assert len(received_lines) == len(output_lines)
-        assert received_lines == output_lines
-    
-    def test_blocked_command_logging(self, dangerous_commands):
-        """Test that blocked commands are logged."""
-        blocked_commands: List[str] = []
-        
-        for cmd in dangerous_commands:
-            if not self._is_command_allowed(cmd):
-                blocked_commands.append(cmd)
-        
-        assert len(blocked_commands) == len(dangerous_commands)
-    
-    def _is_command_allowed(self, command: str) -> bool:
-        """Check if command is allowed."""
-        dangerous_patterns = [
-            "rm -rf /",
-            "sudo",
-            "su -",
-            "passwd",
-            "mkfs",
-            "dd if=/dev/zero",
-            "> /dev/sda",
-            "chmod 777 /",
-            ":(){ :|:& };:",  # Fork bomb
-        ]
-        
-        cmd_lower = command.lower()
-        
-        for pattern in dangerous_patterns:
-            if pattern in cmd_lower:
-                return False
-        
-        # Allow common safe commands
-        safe_prefixes = [
-            "bun ",
-            "npm ",
-            "git ",
-            "ls",
-            "cat ",
-            "echo ",
-            "pwd",
-            "cd ",
-        ]
-        
-        return any(command.startswith(prefix) for prefix in safe_prefixes)

package/tests/tilt-engine/test_code_viewer.py

@@ -1,127 +0,0 @@
-"""
-Tests for code viewer component.
-Tests the syntax highlighting and file rendering features.
-"""
-
-import pytest
-from pathlib import Path
-
-
-@pytest.mark.ide
-class TestCodeViewer:
-    """Tests for code viewer functionality."""
-    
-    def test_typescript_file_syntax_highlighting(self, temp_dir):
-        """
-        Scenario: TypeScript file rendering
-        WHEN a user requests to view a `.ts` file in the code viewer
-        THEN it SHALL return HTML with syntax-highlighted TypeScript
-        AND it SHALL include line numbers
-        """
-        # Create TypeScript file
-        ts_file = temp_dir / "example.ts"
-        ts_file.write_text("""interface User {
-  id: number;
-  name: string;
-}
-
-const user: User = { id: 1, name: "Test" };""")
-        
-        # Simulate code viewer response
-        content = ts_file.read_text()
-        html = self._generate_code_html(content, "typescript")
-        
-        # Verify HTML structure
-        assert "<pre>" in html or "<code>" in html, "Should contain code block"
-        assert "line-number" in html or "data-line" in html, "Should include line numbers"
-        assert "interface" in html, "Should preserve TypeScript keywords"
-    
-    def test_read_only_indicator_display(self, temp_dir):
-        """
-        Scenario: File read-only indicator
-        WHEN viewing any file in the code viewer
-        THEN the page SHALL display a "👁️ READ-ONLY" indicator
-        AND the content SHALL NOT be editable
-        """
-        html = self._generate_viewer_html("test.ts", "content", editable=False)
-        
-        # Verify read-only indicator
-        assert "👁️" in html or "READ-ONLY" in html, "Should show read-only indicator"
-        assert 'contenteditable="false"' in html or "readonly" in html.lower(), "Content should not be editable"
-    
-    def test_unsupported_file_type_handling(self, temp_dir):
-        """
-        Scenario: Unsupported file type
-        WHEN a user requests a binary file (e.g., `.png`, `.exe`)
-        THEN it SHALL return `415 Unsupported Media Type`
-        AND it SHALL suggest downloading the file instead
-        """
-        # Create binary file
-        binary_file = temp_dir / "test.png"
-        binary_file.write_bytes(b"\x89PNG\r\n\x1a\n")  # PNG magic bytes
-        
-        # Check if file is binary
-        is_binary = self._is_binary_file(binary_file)
-        assert is_binary, "Should detect binary file"
-        
-        # Binary files should not be displayed as text
-        should_display = not is_binary
-        assert not should_display, "Binary files should not be displayed in code viewer"
-    
-    def _generate_code_html(self, content: str, language: str) -> str:
-        """Helper to generate syntax-highlighted HTML."""
-        lines = content.split("\n")
-        
-        html_lines = ['<div class="code-viewer read-only">']
-        html_lines.append('<div class="read-only-indicator">👁️ READ-ONLY</div>')
-        html_lines.append(f'<pre class="language-{language}"><code>')
-        
-        for i, line in enumerate(lines, 1):
-            html_lines.append(f'<span class="line" data-line="{i}"><span class="line-number">{i}</span>{self._escape_html(line)}</span>')
-        
-        html_lines.append('</code></pre>')
-        html_lines.append('</div>')
-        
-        return "\n".join(html_lines)
-    
-    def _generate_viewer_html(self, filename: str, content: str, editable: bool = False) -> str:
-        """Helper to generate viewer HTML."""
-        return f"""<!DOCTYPE html>
-<html>
-<head><title>{filename}</title></head>
-<body>
-<div class="code-viewer {'' if editable else 'read-only'}">
-  <div class="header">
-    <span>👁️ READ-ONLY</span>
-    <span>{filename}</span>
-  </div>
-  <pre><code contenteditable="{'true' if editable else 'false'}">{self._escape_html(content)}</code></pre>
-</div>
-</body>
-</html>"""
-    
-    def _escape_html(self, text: str) -> str:
-        """Escape HTML special characters."""
-        return (text
-                .replace("&", "&amp;")
-                .replace("<", "&lt;")
-                .replace(">", "&gt;")
-                .replace('"', "&quot;"))
-    
-    def _is_binary_file(self, path: Path) -> bool:
-        """Check if file is binary."""
-        try:
-            with open(path, "rb") as f:
-                chunk = f.read(1024)
-                return b"\x00" in chunk or not self._is_text_content(chunk)
-        except Exception:
-            return True
-    
-    def _is_text_content(self, content: bytes) -> bool:
-        """Check if content is likely text."""
-        # Try to decode as UTF-8
-        try:
-            content.decode("utf-8")
-            return True
-        except UnicodeDecodeError:
-            return False

package/tests/tilt-engine/test_compose_port_anchors.py

@@ -1,310 +0,0 @@
-"""
-Test the compose port anchor replacement logic.
-
-This directly tests the _replace_ports_with_anchors function behavior
-to ensure backend services get *backend-port and frontends get *frontend-port.
-"""
-
-import pytest
-import re
-
-pytestmark = [pytest.mark.fast, pytest.mark.generator]
-
-
-class TestReplacePortsWithAnchors:
-    """Test the port anchor replacement logic that caused the Traefik bug."""
-    
-    @pytest.fixture
-    def backend_resource_entry(self) -> str:
-        """Backend service entry - should get *backend-port."""
-        return '''  identity-backend:
-    image: identity_identity-backend:dev
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.services.identity-backend.loadbalancer.server.port=4004"
-      - "traefik.http.services.identity-backend.loadbalancer.healthcheck.path=/api/v1/health"
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:4004/api/v1/health"]
-    deploy:
-      resources:
-        limits:
-          memory: 512M
-'''
-    
-    @pytest.fixture
-    def frontend_resource_entry(self) -> str:
-        """Frontend service entry - should get *frontend-port."""
-        return '''  identity-frontend:
-    image: identity_identity-frontend:dev
-    <<: *frontend-memory-limit
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.services.identity-frontend.loadbalancer.server.port=3000"
-    healthcheck:
-      test: ["CMD", "wget", "--quiet", "--tries=1", "--spider", "http://127.0.0.1:3000"]
-'''
-    
-    @pytest.fixture
-    def sdk_resource_entry(self) -> str:
-        """SDK service entry - should get *sdk-port."""
-        return '''  identity-sdk:
-    image: identity_identity-sdk:dev
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.services.identity-sdk.loadbalancer.server.port=5175"
-'''
-    
-    def simulate_replace_ports_with_anchors(
-        self, 
-        entry: str, 
-        has_sdk: bool = False, 
-        has_frontend: bool = False,
-        has_backend: bool = False
-    ) -> str:
-        """
-        Simulate the fixed _replace_ports_with_anchors function.
-        
-        This mirrors the logic in compose.star after the fix:
-        - Detects entry type by checking entry content
-        - Uses entry type, not just global flags
-        """
-        # Detect entry type from content (same logic as _is_backend_entry, _is_sdk_entry)
-        is_sdk = "-sdk:" in entry or entry.strip().startswith("identity-sdk:")
-        is_frontend = "<<: *frontend-memory-limit" in entry
-        is_backend = "healthcheck:" in entry and "curl" in entry and not is_frontend and not is_sdk
-        
-        result = []
-        for line in entry.split('\n'):
-            new_line = line
-            
-            # Replace Traefik loadbalancer port
-            if "loadbalancer.server.port=" in line and "traefik.http.services." in line:
-                # Extract port value
-                port_match = re.search(r'loadbalancer\.server\.port=(\d+)', line)
-                if port_match:
-                    port_val = int(port_match.group(1))
-                    
-                    if port_val == 3000:
-                        # Port 3000 always uses backend-port
-                        new_line = line.replace(
-                            f"loadbalancer.server.port={port_val}",
-                            "loadbalancer.server.port=*backend-port"
-                        )
-                    else:
-                        # Non-3000 ports: use correct anchor based on entry type
-                        if is_sdk and has_sdk:
-                            new_line = line.replace(
-                                f"loadbalancer.server.port={port_val}",
-                                "loadbalancer.server.port=*sdk-port"
-                            )
-                        elif is_backend and has_backend:
-                            # CRITICAL FIX: Use backend-port for backends
-                            new_line = line.replace(
-                                f"loadbalancer.server.port={port_val}",
-                                "loadbalancer.server.port=*backend-port"
-                            )
-                        elif is_frontend and has_frontend:
-                            # Frontend uses frontend-port
-                            new_line = line.replace(
-                                f"loadbalancer.server.port={port_val}",
-                                "loadbalancer.server.port=*frontend-port"
-                            )
-            
-            result.append(new_line)
-        
-        return '\n'.join(result)
-    
-    def test_backend_gets_backend_port_anchor(self, backend_resource_entry: str):
-        """Backend with port 4004 must get *backend-port anchor."""
-        result = self.simulate_replace_ports_with_anchors(
-            backend_resource_entry,
-            has_sdk=False,
-            has_frontend=True,  # Simulate identity stack which has frontend
-            has_backend=True
-        )
-        
-        # Should have backend-port, NOT frontend-port
-        assert "*backend-port" in result, "Backend must use *backend-port anchor"
-        assert "*frontend-port" not in result, "Backend must NOT use *frontend-port anchor"
-        assert "*sdk-port" not in result, "Backend must NOT use *sdk-port anchor"
-    
-    def test_frontend_gets_frontend_port_anchor(self, frontend_resource_entry: str):
-        """Frontend with port 3000 (or other) must get *frontend-port anchor."""
-        result = self.simulate_replace_ports_with_anchors(
-            frontend_resource_entry,
-            has_sdk=False,
-            has_frontend=True,
-            has_backend=False
-        )
-        
-        # Port 3000 gets converted to backend-port (by design for 3000)
-        # But if it were 4000, it would get frontend-port
-        assert "*frontend-port" in result or "*backend-port" in result
-    
-    def test_frontend_non_3000_port_gets_frontend_anchor(self):
-        """Frontend with port 4000 must get *frontend-port (not *backend-port)."""
-        frontend_with_4000 = '''  custom-frontend:
-    image: test:test
-    <<: *frontend-memory-limit
-    labels:
-      - "traefik.http.services.custom-frontend.loadbalancer.server.port=4000"
-'''
-        result = self.simulate_replace_ports_with_anchors(
-            frontend_with_4000,
-            has_sdk=False,
-            has_frontend=True,
-            has_backend=True  # Even with has_backend=True
-        )
-        
-        # Frontend should get frontend-port even with port 4000
-        assert "*frontend-port" in result, "Frontend must use *frontend-port"
-        assert "*backend-port" not in result, "Frontend must NOT use *backend-port"
-    
-    def test_sdk_gets_sdk_port_anchor(self, sdk_resource_entry: str):
-        """SDK with port 5175 must get *sdk-port anchor."""
-        result = self.simulate_replace_ports_with_anchors(
-            sdk_resource_entry,
-            has_sdk=True,
-            has_frontend=True,
-            has_backend=True
-        )
-        
-        assert "*sdk-port" in result, "SDK must use *sdk-port anchor"
-        assert "*backend-port" not in result, "SDK must NOT use *backend-port"
-        assert "*frontend-port" not in result, "SDK must NOT use *frontend-port"
-    
-    def test_port_3000_always_backend_port(self):
-        """Port 3000 always maps to *backend-port regardless of service type."""
-        resource_with_3000 = '''  some-service:
-    labels:
-      - "traefik.http.services.some-service.loadbalancer.server.port=3000"
-'''
-        result = self.simulate_replace_ports_with_anchors(
-            resource_with_3000,
-            has_sdk=False,
-            has_frontend=True,
-            has_backend=True
-        )
-        
-        # Port 3000 always becomes *backend-port
-        assert "*backend-port" in result
-        assert "*frontend-port" not in result
-    
-    def test_original_bug_scenario(self):
-        """
-        Reproduce the original bug: identity-backend got *frontend-port.
-        
-        The bug occurred because:
-        1. has_frontend=True (because identity stack has a frontend)
-        2. Port 4004 != 3000
-        3. Old code checked has_frontend first, ignoring entry type
-        4. Result: backend got *frontend-port instead of *backend-port
-        """
-        identity_backend = '''  identity-management-backend:
-    image: identity_identity-management-backend:dev
-    labels:
-      - "traefik.enable=true"
-      - "traefik.http.services.identity-management-backend.loadbalancer.server.port=4004"
-      - "traefik.http.services.identity-management-backend.loadbalancer.healthcheck.path=/api/v1/health"
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:4004/api/v1/health"]
-'''
-        
-        # Simulate old buggy logic (BEFORE fix)
-        def old_buggy_replace(entry: str, has_frontend: bool = False) -> str:
-            """The buggy version - only checks has_frontend flag."""
-            result = []
-            for line in entry.split('\n'):
-                if "loadbalancer.server.port=" in line:
-                    port_match = re.search(r'loadbalancer\.server\.port=(\d+)', line)
-                    if port_match:
-                        port_val = int(port_match.group(1))
-                        if port_val != 3000:
-                            # BUG: Only checks has_frontend, ignores entry type!
-                            if has_frontend:
-                                line = line.replace(
-                                    f"loadbalancer.server.port={port_val}",
-                                    "loadbalancer.server.port=*frontend-port"  # WRONG!
-                                )
-                result.append(line)
-            return '\n'.join(result)
-        
-        # Buggy result (what was happening before)
-        buggy_result = old_buggy_replace(identity_backend, has_frontend=True)
-        assert "*frontend-port" in buggy_result, "Bug: backend got frontend-port"
-        
-        # Fixed result (after our fix)
-        fixed_result = self.simulate_replace_ports_with_anchors(
-            identity_backend,
-            has_sdk=False,
-            has_frontend=True,
-            has_backend=True
-        )
-        assert "*backend-port" in fixed_result, "Fix: backend now gets backend-port"
-        assert "*frontend-port" not in fixed_result
-    
-    def test_mixed_stack_all_services_correct_anchors(self):
-        """Test full identity stack with backend + frontend + SDK."""
-        entries = [
-            ('''  identity-management-backend:
-    image: identity_identity-management-backend:dev
-    labels:
-      - "traefik.http.services.identity-management-backend.loadbalancer.server.port=4004"
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:4004/api/v1/health"]
-''', "*backend-port"),
-            ('''  identity-management-frontend:
-    <<: *frontend-memory-limit
-    labels:
-      - "traefik.http.services.identity-management-frontend.loadbalancer.server.port=4000"
-''', "*frontend-port"),
-            ('''  identity-sdk:
-    labels:
-      - "traefik.http.services.identity-sdk.loadbalancer.server.port=5175"
-''', "*sdk-port"),
-        ]
-        
-        for entry, expected_anchor in entries:
-            result = self.simulate_replace_ports_with_anchors(
-                entry,
-                has_sdk=True,
-                has_frontend=True,
-                has_backend=True
-            )
-            assert expected_anchor in result, f"Entry should use {expected_anchor}"
-
-
-class TestPortAnchorExtraction:
-    """Test that port anchors are correctly extracted from service entries."""
-    
-    def test_extract_backend_port_from_entry(self):
-        """Extract backend port (4004) from service entry."""
-        entry = '''  backend:
-    labels:
-      - "traefik.http.services.backend.loadbalancer.server.port=4004"
-'''
-        match = re.search(r'loadbalancer\.server\.port=(\d+)', entry)
-        assert match
-        assert match.group(1) == "4004"
-    
-    def test_extract_frontend_port_from_entry(self):
-        """Extract frontend port (3000) from service entry."""
-        entry = '''  frontend:
-    labels:
-      - "traefik.http.services.frontend.loadbalancer.server.port=3000"
-'''
-        match = re.search(r'loadbalancer\.server\.port=(\d+)', entry)
-        assert match
-        assert match.group(1) == "3000"
-    
-    def test_no_port_returns_none(self):
-        """Entry without loadbalancer port should return None."""
-        entry = '''  some-service:
-    image: test:test
-'''
-        match = re.search(r'loadbalancer\.server\.port=(\d+)', entry)
-        assert match is None
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])