kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tests/tool_backend/test_replace_lines_tool.py

@@ -0,0 +1,141 @@
+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.replace_lines_tool import ReplaceLinesTool
+
+
+@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 replace_lines_tool(project_path, mock_connection_manager, agent_config, mock_base_agent):
+    return ReplaceLinesTool(
+        project_path, "test_workspace", str(uuid.uuid4()), mock_connection_manager, agent_config, mock_base_agent
+    )
+
+
+@pytest.fixture
+def sample_file(project_path):
+    file_path = project_path / "test.txt"
+    file_path.write_text("Line 1\nLine 2\nLine 3\nLine 4\nLine 5")
+    return file_path
+
+
+@pytest.mark.asyncio
+class TestReplaceLinesTool:
+    async def test_replace_lines_success(self, replace_lines_tool, sample_file):
+        new_content = "New Line 2\nNew Line 3"
+        result = await replace_lines_tool.replace_lines("test.txt", 2, 3, new_content)
+
+        expected_result = "Replaced lines 2-3 in file test.txt\n\nReplaced:\n```\nLine 2\nLine 3\n```\nwith:\n```\nNew Line 2\nNew Line 3\n```"
+        assert result == expected_result
+        assert sample_file.read_text() == "Line 1\nNew Line 2\nNew Line 3\nLine 4\nLine 5"
+
+    async def test_replace_lines_single_line(self, replace_lines_tool, sample_file):
+        new_content = "New Line 1"
+        result = await replace_lines_tool.replace_lines("test.txt", 1, 1, new_content)
+
+        expected_result = (
+            "Replaced lines 1-1 in file test.txt\n\nReplaced:\n```\nLine 1\n```\nwith:\n```\nNew Line 1\n```"
+        )
+        assert result == expected_result
+        assert sample_file.read_text() == "New Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
+
+    async def test_replace_lines_at_end(self, replace_lines_tool, sample_file):
+        new_content = "New Line 5"
+        result = await replace_lines_tool.replace_lines("test.txt", 5, 5, new_content)
+
+        # Use direct string comparison to avoid newline issues
+        # Note: No trailing newline for the last line of the file
+        expected_result = "Replaced lines 5-5 in file test.txt\n\nReplaced:\n```\nLine 5```\nwith:\n```\nNew Line 5```"
+        assert result == expected_result
+        assert sample_file.read_text() == "Line 1\nLine 2\nLine 3\nLine 4\nNew Line 5"
+
+    async def test_replace_lines_file_not_found(self, replace_lines_tool):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            await replace_lines_tool.replace_lines("nonexistent.txt", 1, 1, "Content")
+        assert str(exc_info.value) == "File not found: nonexistent.txt"
+
+    async def test_replace_lines_invalid_start_line(self, replace_lines_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await replace_lines_tool.replace_lines("test.txt", 0, 1, "Content")
+        assert str(exc_info.value) == "Invalid start_line: 0. Line numbers must be 1-indexed."
+
+    async def test_replace_lines_invalid_end_line(self, replace_lines_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await replace_lines_tool.replace_lines("test.txt", 3, 2, "Content")
+        assert (
+            str(exc_info.value) == "Invalid line range: end_line (2) must be greater than or equal to start_line (3)."
+        )
+
+    async def test_replace_lines_start_line_exceeds_file_length(self, replace_lines_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await replace_lines_tool.replace_lines("test.txt", 6, 6, "Content")
+        assert str(exc_info.value) == "Invalid start_line: 6. File only has 5 lines."
+
+    @patch("pathlib.Path.write_text")
+    async def test_replace_lines_permission_error(self, mock_write_text, replace_lines_tool, sample_file):
+        mock_write_text.side_effect = PermissionError("Permission denied")
+
+        with pytest.raises(PermissionError) as exc_info:
+            await replace_lines_tool.replace_lines("test.txt", 1, 1, "Content")
+        assert str(exc_info.value) == "Permission denied"
+
+    async def test_replace_lines_with_empty_content(self, replace_lines_tool, sample_file):
+        result = await replace_lines_tool.replace_lines("test.txt", 2, 2, "")
+
+        expected_result = "Replaced lines 2-2 in file test.txt\n\nReplaced:\n```\nLine 2\n```\nwith:\n```\n\n```"
+        assert result == expected_result
+        assert sample_file.read_text() == "Line 1\n\nLine 3\nLine 4\nLine 5"
+
+    async def test_replace_lines_preserve_newline(self, replace_lines_tool, project_path):
+        # Create a file with a trailing newline
+        file_path = project_path / "newline.txt"
+        file_path.write_text("Line 1\nLine 2\n")
+
+        new_content = "New Line 1\nNew Line 2"
+        result = await replace_lines_tool.replace_lines("newline.txt", 1, 2, new_content)
+
+        expected_result = "Replaced lines 1-2 in file newline.txt\n\nReplaced:\n```\nLine 1\nLine 2\n```\nwith:\n```\nNew Line 1\nNew Line 2\n```"
+        assert result == expected_result
+        assert file_path.read_text() == "New Line 1\nNew Line 2\n"
+
+    async def test_replace_lines_with_multiple_newlines(self, replace_lines_tool, sample_file):
+        new_content = "New Line 2\n\nNew Line 4"
+        result = await replace_lines_tool.replace_lines("test.txt", 2, 3, new_content)
+
+        expected_result = "Replaced lines 2-3 in file test.txt\n\nReplaced:\n```\nLine 2\nLine 3\n```\nwith:\n```\nNew Line 2\n\nNew Line 4\n```"
+        assert result == expected_result
+        assert sample_file.read_text() == "Line 1\nNew Line 2\n\nNew Line 4\nLine 4\nLine 5"

kolega_code/agent/tests/tool_backend/test_search_and_replace_tool.py

@@ -0,0 +1,174 @@
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+import uuid
+
+from kolega_code.agent.tool_backend.search_and_replace_tool import SearchAndReplaceTool
+
+
+@pytest.fixture
+def project_path(tmp_path):
+    return tmp_path
+
+
+@pytest.fixture
+def sample_file(project_path):
+    file_path = project_path / "test.txt"
+    file_path.write_text("Line 1\nLine 2\nLine 3\nLine 4\nLine 5")
+    return file_path
+
+
+@pytest.fixture
+def mock_connection_manager():
+    return AsyncMock()
+
+
+@pytest.fixture
+def agent_config():
+    return {}
+
+
+@pytest.fixture
+def mock_base_agent():
+    mock = Mock()
+    mock.agent_name = "test_agent"
+    return mock
+
+
+@pytest.fixture
+def search_and_replace_tool(project_path, mock_connection_manager, agent_config, mock_base_agent):
+    return SearchAndReplaceTool(
+        project_path, "test_workspace", str(uuid.uuid4()), mock_connection_manager, agent_config, mock_base_agent
+    )
+
+
+@pytest.mark.asyncio
+class TestSearchAndReplaceTool:
+    async def test_search_and_replace_success(self, search_and_replace_tool, sample_file):
+        blocks = """<<<<<<< SEARCH
+Line 2
+Line 3
+=======
+New Line 2
+New Line 3
+>>>>>>> REPLACE"""
+
+        result = await search_and_replace_tool.search_and_replace("test.txt", blocks)
+
+        expected_result = (
+            "Search and replace in file test.txt\n\n"
+            "Replaced:\n"
+            "```\nLine 2\nLine 3\n```\n"
+            "with:\n"
+            "```\nNew Line 2\nNew Line 3\n```"
+        )
+        assert result == expected_result
+        assert sample_file.read_text() == "Line 1\nNew Line 2\nNew Line 3\nLine 4\nLine 5"
+
+    async def test_search_and_replace_no_match(self, search_and_replace_tool, sample_file):
+        blocks = """<<<<<<< SEARCH
+Line X
+Line Y
+=======
+New Line X
+New Line Y
+>>>>>>> REPLACE"""
+
+        with pytest.raises(ValueError) as exc_info:
+            await search_and_replace_tool.search_and_replace("test.txt", blocks)
+
+        assert "does not match any content in the file" in str(exc_info.value)
+
+    async def test_search_and_replace_multiple_matches(self, search_and_replace_tool, project_path):
+        file_path = project_path / "duplicate.txt"
+        file_path.write_text("Line A\nLine B\nLine C\nLine A\nLine B\nLine C")
+
+        blocks = """<<<<<<< SEARCH
+Line A
+Line B
+=======
+New Line A
+New Line B
+>>>>>>> REPLACE"""
+
+        with pytest.raises(ValueError) as exc_info:
+            await search_and_replace_tool.search_and_replace("duplicate.txt", blocks)
+
+        assert "matched 2 occurrences" in str(exc_info.value)
+
+    async def test_search_and_replace_no_blocks(self, search_and_replace_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await search_and_replace_tool.search_and_replace("test.txt", "Invalid blocks format")
+
+        assert "No valid search and replace blocks found" in str(exc_info.value)
+
+    async def test_search_and_replace_multiple_blocks(self, search_and_replace_tool, sample_file):
+        blocks = """<<<<<<< SEARCH
+Line 1
+=======
+New Line 1
+>>>>>>> REPLACE
+<<<<<<< SEARCH
+Line 2
+=======
+New Line 2
+>>>>>>> REPLACE"""
+
+        with pytest.raises(ValueError) as exc_info:
+            await search_and_replace_tool.search_and_replace("test.txt", blocks)
+
+        assert "Multiple search and replace blocks provided" in str(exc_info.value)
+
+    async def test_search_and_replace_empty_search(self, search_and_replace_tool, sample_file):
+        blocks = """<<<<<<< SEARCH
+
+=======
+New Content
+>>>>>>> REPLACE"""
+
+        with pytest.raises(ValueError) as exc_info:
+            await search_and_replace_tool.search_and_replace("test.txt", blocks)
+
+        assert "Empty search block" in str(exc_info.value)
+
+    async def test_search_and_replace_file_not_found(self, search_and_replace_tool):
+        blocks = """<<<<<<< SEARCH
+Line 1
+=======
+New Line 1
+>>>>>>> REPLACE"""
+
+        with pytest.raises(FileNotFoundError) as exc_info:
+            await search_and_replace_tool.search_and_replace("nonexistent.txt", blocks)
+
+        assert "File not found: nonexistent.txt" in str(exc_info.value)
+
+    async def test_search_and_replace_no_changes(self, search_and_replace_tool, sample_file):
+        blocks = """<<<<<<< SEARCH
+Line 2
+Line 3
+=======
+Line 2
+Line 3
+>>>>>>> REPLACE"""
+
+        result = await search_and_replace_tool.search_and_replace("test.txt", blocks)
+
+        assert "No changes made" in result
+        assert sample_file.read_text() == "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
+
+    async def test_search_and_replace_permission_error(self, search_and_replace_tool, sample_file):
+        blocks = """<<<<<<< SEARCH
+Line 2
+Line 3
+=======
+New Line 2
+New Line 3
+>>>>>>> REPLACE"""
+
+        # Create a test that we can't write to
+        with patch("pathlib.Path.open", side_effect=PermissionError("Permission denied when writing to file")):
+            with pytest.raises(PermissionError) as exc_info:
+                await search_and_replace_tool.search_and_replace("test.txt", blocks)
+
+            assert "Permission denied" in str(exc_info.value)

kolega_code/agent/tests/tool_backend/test_search_codebase_tool.py

@@ -0,0 +1,228 @@
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+import uuid
+
+from kolega_code.config import AgentConfig, ModelConfig, ModelProvider, RateLimitConfig
+from kolega_code.agent.tool_backend.search_codebase_tool import SearchCodebaseTool
+
+
+@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 search_codebase_tool(project_path, mock_connection_manager, agent_config, mock_base_agent):
+    return SearchCodebaseTool(
+        project_path, "test_workspace", str(uuid.uuid4()), mock_connection_manager, agent_config, mock_base_agent
+    )
+
+
+@pytest.fixture
+def sample_files(project_path):
+    # Create a directory structure with various files
+    (project_path / "src").mkdir()
+    (project_path / "tests").mkdir()
+
+    # Create Python files
+    (project_path / "src" / "main.py").write_text('def main():\n    print("Hello World")\n')
+    (project_path / "src" / "utils.py").write_text('def helper():\n    return "Helper function"\n')
+    (project_path / "tests" / "test_main.py").write_text("def test_main():\n    assert True\n")
+
+    # Create a binary file
+    (project_path / "src" / "data.bin").write_bytes(b"\x00\x01\x02\x03")
+
+    # Create a file in excluded directory
+    (project_path / ".git").mkdir()
+    (project_path / ".git" / "config").write_text("git config content")
+
+    # Create a large file
+    (project_path / "src" / "large.txt").write_text("x" * (11 * 1024 * 1024))
+
+
+@pytest.mark.asyncio
+class TestSearchCodebaseTool:
+    async def test_search_codebase_basic(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("print")
+
+        assert "Search Results for 'print'" in result
+        assert "src/main.py" in result
+        assert 'Line 2: print("Hello World")' in result
+
+    async def test_search_codebase_case_insensitive(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("PRINT")
+
+        assert "Search Results for 'PRINT'" in result
+        assert "src/main.py" in result
+        assert 'Line 2: print("Hello World")' in result
+
+    async def test_search_codebase_case_sensitive(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("PRINT", case_sensitive=True)
+
+        assert "No matches found for pattern 'PRINT'" in result
+
+    async def test_search_codebase_file_pattern(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("def", file_pattern="*.py")
+
+        assert "Search Results for 'def'" in result
+        assert "src/main.py" in result
+        assert "src/utils.py" in result
+        assert "tests/test_main.py" in result
+
+    async def test_search_codebase_no_matches(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("nonexistent_pattern")
+
+        assert "No matches found for pattern 'nonexistent_pattern'" in result
+
+    async def test_search_codebase_invalid_regex(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("[", literal=False)
+
+        assert "Error: Invalid regular expression" in result
+
+    async def test_search_codebase_excludes_binary_files(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("\x00")
+
+        assert "No matches found for pattern" in result
+
+    async def test_search_codebase_excludes_git_files(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("git config")
+
+        assert "No matches found for pattern" in result
+
+    async def test_search_codebase_excludes_large_files(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("x")
+
+        assert "large.txt" not in result
+
+    async def test_search_codebase_multiple_matches(self, search_codebase_tool, sample_files):
+        result = await search_codebase_tool.search_codebase("def")
+
+        assert "Search Results for 'def'" in result
+        assert "src/main.py" in result
+        assert "src/utils.py" in result
+        assert "tests/test_main.py" in result
+        assert "Line 1: def main():" in result
+        assert "Line 1: def helper():" in result
+        assert "Line 1: def test_main():" in result
+
+    async def test_search_codebase_with_context(self, search_codebase_tool, project_path):
+        # Create a file with multiple matches
+        file_path = project_path / "test.py"
+        file_path.write_text('def first():\n    print("First")\n\ndef second():\n    print("Second")\n')
+
+        result = await search_codebase_tool.search_codebase("print")
+
+        assert "test.py" in result
+        assert 'Line 2: print("First")' in result
+        assert 'Line 5: print("Second")' in result
+
+    async def test_search_codebase_result_limit(self, search_codebase_tool, project_path):
+        # Create a file with more than 5 matches (the per-file display limit)
+        file_path = project_path / "test.py"
+        file_path.write_text("\n".join(f'print("Line {i}")' for i in range(200)))
+
+        result = await search_codebase_tool.search_codebase("print")
+
+        # Check that we show 5 lines and then indicate there are more
+        assert 'Line 1: print("Line 0")' in result
+        assert 'Line 5: print("Line 4")' in result
+        assert "... and 195 more matches" in result
+        assert "(200 matches)" in result
+
+    async def test_search_codebase_with_special_characters(self, search_codebase_tool, project_path):
+        # Create a file with special characters
+        file_path = project_path / "special.py"
+        file_path.write_text('def special():\n    print("Special chars: !@#$%^&*()")\n')
+
+        result = await search_codebase_tool.search_codebase("!@#")
+
+        assert "special.py" in result
+        assert 'Line 2: print("Special chars: !@#$%^&*()")' in result
+
+    async def test_search_codebase_literal_mode(self, search_codebase_tool, project_path):
+        """Test literal search mode with regex special characters"""
+        # Create files with patterns that would be invalid regex
+        file_path = project_path / "code.py"
+        file_path.write_text("""
+def process_array(arr):
+    value = arr[0])  # Unbalanced parenthesis
+    return value
+
+def func():
+    print("Testing [](){}")
+""")
+
+        # Test 1: Search for unbalanced parenthesis - should work in literal mode
+        result = await search_codebase_tool.search_codebase("])", literal=True)
+        assert "code.py" in result
+        assert "Line 3: value = arr[0])" in result
+
+        # Test 2: Same pattern should fail in regex mode
+        result = await search_codebase_tool.search_codebase("])", literal=False)
+        assert "Error: Invalid regular expression" in result
+
+        # Test 3: Search for pattern with special chars in literal mode
+        result = await search_codebase_tool.search_codebase("[](){}", literal=True)
+        assert "code.py" in result
+        assert 'Line 7: print("Testing [](){}")' in result
+
+        # Test 4: Verify default is literal=True
+        result = await search_codebase_tool.search_codebase("])")
+        assert "code.py" in result
+        assert "Line 3: value = arr[0])" in result
+
+    async def test_search_codebase_long_line_truncation(self, search_codebase_tool, project_path):
+        """Test that long lines are truncated to 200 characters"""
+        # Create a file with a very long line (minified JSON style)
+        long_line = '{"key":"' + "x" * 500 + '","match":"FINDME"}'
+        file_path = project_path / "minified.json"
+        file_path.write_text(long_line)
+
+        result = await search_codebase_tool.search_codebase("FINDME")
+
+        assert "minified.json" in result
+        # The line should be truncated to 200 characters with "..."
+        assert "..." in result
+        # Verify the full long line is NOT in the output
+        assert "x" * 500 not in result
+        # The truncated line should be approximately 200 characters (plus "Line N: " prefix and "...")
+        lines = result.split("\n")
+        for line in lines:
+            if "Line 1:" in line and "minified.json" not in line:
+                # Extract just the content part after "Line N: "
+                content_match = line.split("Line 1: ", 1)
+                if len(content_match) > 1:
+                    content = content_match[1]
+                    # Should be exactly 200 chars + "..." = 203 chars
+                    assert len(content) == 203, f"Expected 203 chars, got {len(content)}"
+                    assert content.endswith("...")
+                break
+