kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tests/tool_backend/test_browser_tool.py

@@ -0,0 +1,335 @@
+import datetime
+import pytest
+import uuid
+from unittest.mock import AsyncMock, MagicMock, patch
+from kolega_code.agent.tool_backend.browser_tool import BrowserTool
+from kolega_code.config import AgentConfig
+
+
+class TestBrowserTool:
+    """Test suite for BrowserTool console log filtering functionality."""
+
+    @pytest.fixture
+    def mock_config(self):
+        """Create a mock agent config."""
+        return MagicMock(spec=AgentConfig)
+
+    @pytest.fixture
+    def mock_connection_manager(self):
+        """Create a mock connection manager."""
+        return AsyncMock()
+
+    @pytest.fixture
+    def mock_caller(self):
+        """Create a mock caller."""
+        caller = MagicMock()
+        caller.agent_name = "test-agent"
+        return caller
+
+    @pytest.fixture
+    def browser_tool(self, mock_config, mock_connection_manager, mock_caller):
+        """Create a browser tool instance for testing."""
+        return BrowserTool(
+            project_path="/test/path",
+            workspace_id="test-workspace",
+            thread_id=str(uuid.uuid4()),
+            connection_manager=mock_connection_manager,
+            config=mock_config,
+            caller=mock_caller,
+        )
+
+    @pytest.fixture
+    def mock_console_logs_result(self):
+        """Create mock console logs result from browser manager."""
+        return {
+            "console_logs": [
+                {
+                    "type": "error",
+                    "text": "JavaScript error occurred",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": {"url": "test.js", "lineNumber": 42, "columnNumber": 10},
+                },
+                {
+                    "type": "warning",
+                    "text": "Deprecated API usage",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": None,
+                },
+            ],
+            "total_logs_count": 10,
+            "returned_count": 2,
+            "filters_applied": {
+                "max_logs": 50,
+                "log_types": ["error", "warning", "assert"],
+                "minutes_back": None,
+                "max_chars": 8000,
+            },
+        }
+
+    @pytest.mark.asyncio
+    async def test_get_browser_console_logs_default_parameters(self, browser_tool, mock_console_logs_result):
+        """Test get_browser_console_logs with default parameters."""
+        browser_tool.browser_manager.get_browser_console_logs = AsyncMock(return_value=mock_console_logs_result)
+
+        result = await browser_tool.get_browser_console_logs("test-browser-id")
+
+        # Verify the browser manager was called with default parameters
+        browser_tool.browser_manager.get_browser_console_logs.assert_called_once_with(
+            "test-browser-id", max_logs=50, log_types=None, minutes_back=None, max_chars=8000
+        )
+
+        # Check that the result contains expected markdown formatting
+        assert "## Console Logs" in result
+        assert "**Showing 2 of 10 total logs**" in result
+        assert "**Filtered by types:** error, warning, assert" in result
+        assert "**Max logs:** 50" in result
+        assert "| Type | Timestamp | Message | Location |" in result
+        assert "| error |" in result
+        assert "| warning |" in result
+        assert "JavaScript error occurred" in result
+        assert "Deprecated API usage" in result
+
+    @pytest.mark.asyncio
+    async def test_get_browser_console_logs_custom_parameters(self, browser_tool, mock_console_logs_result):
+        """Test get_browser_console_logs with custom parameters."""
+        # Update mock result to reflect custom parameters
+        mock_console_logs_result["filters_applied"] = {
+            "max_logs": 10,
+            "log_types": ["error"],
+            "minutes_back": 5,
+            "max_chars": 1000,
+        }
+
+        browser_tool.browser_manager.get_browser_console_logs = AsyncMock(return_value=mock_console_logs_result)
+
+        result = await browser_tool.get_browser_console_logs(
+            "test-browser-id", max_logs=10, log_types=["error"], minutes_back=5, max_chars=1000
+        )
+
+        # Verify the browser manager was called with custom parameters
+        browser_tool.browser_manager.get_browser_console_logs.assert_called_once_with(
+            "test-browser-id", max_logs=10, log_types=["error"], minutes_back=5, max_chars=1000
+        )
+
+        # Check that the result reflects custom filtering
+        assert "**Filtered by types:** error" in result
+        assert "**Time window:** Last 5 minutes" in result
+        assert "**Character limit:** 1000" in result
+        assert "**Max logs:** 10" in result
+
+    @pytest.mark.asyncio
+    async def test_get_browser_console_logs_no_logs(self, browser_tool):
+        """Test get_browser_console_logs when no logs are found."""
+        mock_empty_result = {
+            "console_logs": [],
+            "total_logs_count": 0,
+            "returned_count": 0,
+            "filters_applied": {
+                "max_logs": 50,
+                "log_types": ["error", "warning", "assert"],
+                "minutes_back": None,
+                "max_chars": 8000,
+            },
+        }
+
+        browser_tool.browser_manager.get_browser_console_logs = AsyncMock(return_value=mock_empty_result)
+
+        result = await browser_tool.get_browser_console_logs("test-browser-id")
+
+        assert result == "## Console Logs\n\nNo console logs found."
+
+    @pytest.mark.asyncio
+    async def test_get_browser_console_logs_location_formatting(self, browser_tool):
+        """Test that console log locations are formatted correctly."""
+        mock_result = {
+            "console_logs": [
+                {
+                    "type": "error",
+                    "text": "Error with location",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": {"url": "test.js", "lineNumber": 42, "columnNumber": 10},
+                },
+                {
+                    "type": "warning",
+                    "text": "Warning without location",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": None,
+                },
+            ],
+            "total_logs_count": 2,
+            "returned_count": 2,
+            "filters_applied": {
+                "max_logs": 50,
+                "log_types": ["error", "warning", "assert"],
+                "minutes_back": None,
+                "max_chars": 8000,
+            },
+        }
+
+        browser_tool.browser_manager.get_browser_console_logs = AsyncMock(return_value=mock_result)
+
+        result = await browser_tool.get_browser_console_logs("test-browser-id")
+
+        # Check location formatting
+        assert "test.js:42:10" in result  # Formatted location
+        assert "N/A" in result  # No location case
+
+    @pytest.mark.asyncio
+    async def test_get_browser_console_logs_escapes_pipe_characters(self, browser_tool):
+        """Test that pipe characters in log messages are escaped for markdown tables."""
+        mock_result = {
+            "console_logs": [
+                {
+                    "type": "error",
+                    "text": "Error with | pipe character",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": None,
+                },
+            ],
+            "total_logs_count": 1,
+            "returned_count": 1,
+            "filters_applied": {
+                "max_logs": 50,
+                "log_types": ["error", "warning", "assert"],
+                "minutes_back": None,
+                "max_chars": 8000,
+            },
+        }
+
+        browser_tool.browser_manager.get_browser_console_logs = AsyncMock(return_value=mock_result)
+
+        result = await browser_tool.get_browser_console_logs("test-browser-id")
+
+        # Check that pipe character is escaped
+        assert "Error with \\| pipe character" in result
+
+    @pytest.mark.asyncio
+    async def test_get_browser_content_with_console_log_filtering(self, browser_tool):
+        """Test get_browser_content with console log filtering."""
+        mock_content_result = {
+            "current_url": "https://example.com",
+            "title": "Test Page",
+            "html": "<html><body>Test</body></html>",
+            "console_logs": [
+                {
+                    "type": "error",
+                    "text": "JavaScript error",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": None,
+                },
+            ],
+            "console_log_metadata": {
+                "total_logs_count": 5,
+                "returned_count": 1,
+                "filters_applied": {"max_logs": 10, "log_types": ["error"], "minutes_back": None, "max_chars": 1000},
+            },
+        }
+
+        browser_tool.browser_manager.get_browser_content = AsyncMock(return_value=mock_content_result)
+
+        result = await browser_tool.get_browser_content(
+            "test-browser-id", max_logs=10, log_types=["error"], max_chars=1000
+        )
+
+        # Verify the browser manager was called with filtering parameters
+        browser_tool.browser_manager.get_browser_content.assert_called_once_with(
+            "test-browser-id", max_logs=10, log_types=["error"], minutes_back=None, max_chars=1000
+        )
+
+        # Check that the result contains expected content
+        assert "# Browser Content: Test Page" in result
+        assert "**Current URL:** https://example.com" in result
+        assert "## Console Logs" in result
+        assert "**Showing 1 of 5 total logs**" in result
+        assert "**Filtered by types:** error" in result
+        assert "**Character limit:** 1000" in result
+        assert "**Max logs:** 10" in result
+        assert "## Page HTML" in result
+        assert "<html><body>Test</body></html>" in result
+
+    @pytest.mark.asyncio
+    async def test_get_browser_content_no_console_logs(self, browser_tool):
+        """Test get_browser_content when there are no console logs."""
+        mock_content_result = {
+            "current_url": "https://example.com",
+            "title": "Test Page",
+            "html": "<html><body>Test</body></html>",
+            "console_logs": [],
+            "console_log_metadata": {
+                "total_logs_count": 0,
+                "returned_count": 0,
+                "filters_applied": {
+                    "max_logs": 50,
+                    "log_types": ["error", "warning", "assert"],
+                    "minutes_back": None,
+                    "max_chars": 8000,
+                },
+            },
+        }
+
+        browser_tool.browser_manager.get_browser_content = AsyncMock(return_value=mock_content_result)
+
+        result = await browser_tool.get_browser_content("test-browser-id")
+
+        # Should not contain console logs section when there are no logs
+        assert "# Browser Content: Test Page" in result
+        assert "**Current URL:** https://example.com" in result
+        assert "## Console Logs" not in result
+        assert "## Page HTML" in result
+
+    @pytest.mark.asyncio
+    async def test_get_browser_content_truncates_large_html(self, browser_tool):
+        mock_content_result = {
+            "current_url": "https://example.com",
+            "title": "Large Page",
+            "html": "a" * 100_050,
+            "console_logs": [],
+            "console_log_metadata": {
+                "total_logs_count": 0,
+                "returned_count": 0,
+                "filters_applied": {
+                    "max_logs": 50,
+                    "log_types": ["error", "warning", "assert"],
+                    "minutes_back": None,
+                    "max_chars": 8000,
+                },
+            },
+        }
+
+        browser_tool.browser_manager.get_browser_content = AsyncMock(return_value=mock_content_result)
+
+        result = await browser_tool.get_browser_content("test-browser-id")
+
+        assert "HTML truncated by size: Showing first 100,000 of 100,050 characters" in result
+        html_content = result.split("```html\n", 1)[1].rsplit("\n```", 1)[0]
+        assert len(html_content) == 100_000
+
+    @pytest.mark.asyncio
+    async def test_get_browser_content_without_metadata(self, browser_tool):
+        """Test get_browser_content when console_log_metadata is missing."""
+        mock_content_result = {
+            "current_url": "https://example.com",
+            "title": "Test Page",
+            "html": "<html><body>Test</body></html>",
+            "console_logs": [
+                {
+                    "type": "error",
+                    "text": "JavaScript error",
+                    "timestamp": datetime.datetime.now().isoformat(),
+                    "location": None,
+                },
+            ],
+            # Missing console_log_metadata
+        }
+
+        browser_tool.browser_manager.get_browser_content = AsyncMock(return_value=mock_content_result)
+
+        result = await browser_tool.get_browser_content("test-browser-id")
+
+        # Should still work without metadata
+        assert "# Browser Content: Test Page" in result
+        assert "## Console Logs" in result
+        assert "JavaScript error" in result
+        # Should not contain metadata information
+        assert "**Showing" not in result
+        assert "**Filtered by types:**" not in result

kolega_code/agent/tests/tool_backend/test_build_tool.py

@@ -0,0 +1,93 @@
+import asyncio
+from pathlib import Path
+
+import pytest
+
+from kolega_code.agent.tool_backend.build_tool import BuildTool
+from kolega_code.agent.tool_backend.base_tool import BaseTool
+
+
+class DummyFS:
+    def __init__(self, files: dict[str, str]):
+        self._files = files
+
+    def exists(self, path: str) -> bool:
+        return path in self._files
+
+    def read_text(self, path: str, encoding: str = "utf-8") -> str:
+        if path not in self._files:
+            raise FileNotFoundError(path)
+        return self._files[path]
+
+
+class DummyTM:
+    def __init__(self, outputs: dict[str, str] | None = None):
+        self.outputs = outputs or {}
+        self.calls = []
+
+    async def run_command(self, command: str, cwd: str | None = None, timeout: int | None = None) -> str:
+        self.calls.append((command, cwd, timeout))
+        return self.outputs.get(command, f"ok: {command}")
+
+
+def make_tool(fs_map: dict[str, str], tm_outputs: dict[str, str] | None = None) -> BuildTool:
+    tool = BuildTool(
+        project_path=Path("/repo"),
+        workspace_id="ws",
+        thread_id="th",
+        connection_manager=None,
+        config=None,
+        caller=None,
+        filesystem=DummyFS(fs_map),
+        terminal_manager=DummyTM(tm_outputs),
+    )
+    return tool
+
+
+@pytest.mark.asyncio
+async def test_build_backend_specific_command():
+    manifest = """
+name: demo
+runtime: node:18
+backend_build_command: npm run build:api
+"""
+    tool = make_tool({".kolega-manifest.yaml": manifest})
+    result = await tool.build_backend()
+    assert "npm run build:api" in result
+    assert "ok: npm run build:api" in result
+
+
+@pytest.mark.asyncio
+async def test_build_frontend_specific_command():
+    manifest = """
+name: demo
+runtime: node:18
+frontend_build_command: npm run build:web
+"""
+    tool = make_tool({".kolega-manifest.yaml": manifest})
+    result = await tool.build_frontend()
+    assert "npm run build:web" in result
+    assert "ok: npm run build:web" in result
+
+
+@pytest.mark.asyncio
+async def test_build_fallback_to_generic_build_command():
+    manifest = """
+name: demo
+runtime: node:18
+build_command: npm run build
+"""
+    tool = make_tool({".kolega-manifest.yaml": manifest})
+    be = await tool.build_backend()
+    fe = await tool.build_frontend()
+    assert "npm run build" in be
+    assert "npm run build" in fe
+
+
+@pytest.mark.asyncio
+async def test_build_no_manifest_or_command():
+    tool = make_tool({})
+    be = await tool.build_backend()
+    fe = await tool.build_frontend()
+    assert "No backend_build_command or build_command" in be
+    assert "No frontend_build_command or build_command" in fe

kolega_code/agent/tests/tool_backend/test_create_file_tool.py

@@ -0,0 +1,115 @@
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+import uuid
+
+from kolega_code.config import AgentConfig, ModelConfig, ModelProvider, RateLimitConfig
+from kolega_code.agent.tool_backend.create_file_tool import CreateFileTool
+
+
+@pytest.fixture
+def mock_connection_manager():
+    return AsyncMock()
+
+
+@pytest.fixture
+def project_path(tmp_path):
+    return tmp_path
+
+
+@pytest.fixture
+def agent_config():
+    return AgentConfig(
+        anthropic_api_key="test_key",
+        openai_api_key="test-key",
+        long_context_config=ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig()
+        ),
+        fast_config=ModelConfig(provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig()),
+        thinking_config=ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig(), thinking_tokens=1024
+        ),
+    )
+
+
+@pytest.fixture
+def mock_base_agent():
+    mock = Mock()
+    mock.agent_name = "test_agent"
+    return mock
+
+
+@pytest.fixture
+def create_file_tool(project_path, mock_connection_manager, agent_config, mock_base_agent):
+    return CreateFileTool(
+        project_path, "test_workspace", str(uuid.uuid4()), mock_connection_manager, agent_config, mock_base_agent
+    )
+
+
+class TestCreateFileTool:
+    @pytest.mark.asyncio
+    async def test_create_file_success(self, create_file_tool, project_path):
+        result = await create_file_tool.create_file("test.txt", "Hello World")
+
+        assert "File created successfully" in result
+        assert (project_path / "test.txt").exists()
+        assert (project_path / "test.txt").read_text() == "Hello World"
+
+    @pytest.mark.asyncio
+    async def test_create_file_in_subdirectory(self, create_file_tool, project_path):
+        result = await create_file_tool.create_file("subdir/test.txt", "Hello World")
+
+        assert "File created successfully" in result
+        assert (project_path / "subdir" / "test.txt").exists()
+        assert (project_path / "subdir" / "test.txt").read_text() == "Hello World"
+
+    @pytest.mark.asyncio
+    async def test_create_file_already_exists(self, create_file_tool, project_path):
+        # Create the file first
+        (project_path / "test.txt").write_text("Original content")
+
+        result = await create_file_tool.create_file("test.txt", "New content")
+
+        assert "File already exists" in result
+        assert (project_path / "test.txt").read_text() == "Original content"
+
+    @pytest.mark.asyncio
+    async def test_create_file_parent_directory_does_not_exist(self, create_file_tool, project_path):
+        result = await create_file_tool.create_file("nonexistent/test.txt", "Hello World")
+
+        assert "File created successfully" in result
+        assert (project_path / "nonexistent" / "test.txt").exists()
+        assert (project_path / "nonexistent" / "test.txt").read_text() == "Hello World"
+
+    @pytest.mark.asyncio
+    async def test_create_file_permission_error(self, create_file_tool, project_path):
+        with patch("pathlib.Path.write_text", side_effect=PermissionError):
+            result = await create_file_tool.create_file("test.txt", "Hello World")
+
+            assert "Permission denied" in result
+            assert not (project_path / "test.txt").exists()
+
+    @pytest.mark.asyncio
+    async def test_create_file_general_error(self, create_file_tool, project_path):
+        with patch("pathlib.Path.write_text", side_effect=Exception("General error")):
+            result = await create_file_tool.create_file("test.txt", "Hello World")
+
+            assert "Error creating file" in result
+            assert not (project_path / "test.txt").exists()
+
+    @pytest.mark.asyncio
+    async def test_create_file_with_empty_content(self, create_file_tool, project_path):
+        result = await create_file_tool.create_file("test.txt", "")
+
+        assert "File created successfully" in result
+        assert (project_path / "test.txt").exists()
+        assert (project_path / "test.txt").read_text() == ""
+
+    @pytest.mark.asyncio
+    async def test_create_file_with_multiline_content(self, create_file_tool, project_path):
+        content = "Line 1\nLine 2\nLine 3"
+        result = await create_file_tool.create_file("test.txt", content)
+
+        assert "File created successfully" in result
+        assert (project_path / "test.txt").exists()
+        assert (project_path / "test.txt").read_text() == content