| |
| """ |
| Unit Tests for Stack 2.9 Tools Module |
| Tests all 37+ tools: file operations, git, code execution, web, memory, and task planning. |
| """ |
|
|
| import pytest |
| import sys |
| import json |
| import tempfile |
| from pathlib import Path |
| from unittest.mock import MagicMock, patch, mock_open |
|
|
| |
| sys.path.insert(0, str(Path(__file__).parent.parent / "stack_cli")) |
|
|
| from stack_cli.tools import ( |
| TOOLS, |
| get_tool, |
| list_tools, |
| get_tool_schemas, |
| tool_read_file, |
| tool_write_file, |
| tool_edit_file, |
| tool_search_files, |
| tool_grep, |
| tool_copy_file, |
| tool_move_file, |
| tool_delete_file, |
| tool_git_status, |
| tool_git_commit, |
| tool_git_push, |
| tool_git_pull, |
| tool_git_branch, |
| tool_git_log, |
| tool_git_diff, |
| tool_run_command, |
| tool_run_tests, |
| tool_lint_code, |
| tool_format_code, |
| tool_check_type, |
| tool_start_server, |
| tool_install_dependencies, |
| tool_web_search, |
| tool_web_fetch, |
| tool_download_file, |
| tool_check_url, |
| tool_screenshot, |
| tool_memory_recall, |
| tool_memory_save, |
| tool_memory_list, |
| tool_context_load, |
| tool_project_scan, |
| tool_create_task, |
| tool_list_tasks, |
| tool_update_task, |
| tool_delete_task, |
| tool_create_plan, |
| tool_execute_plan, |
| ) |
|
|
|
|
| class TestToolsRegistry: |
| """Test tools registry.""" |
|
|
| def test_tools_count(self): |
| """Verify we have 37+ tools.""" |
| tools = list_tools() |
| assert len(tools) >= 37, f"Expected 37+ tools, got {len(tools)}" |
|
|
| def test_get_tool_valid(self): |
| """Test getting a valid tool.""" |
| tool = get_tool("read") |
| assert tool is not None |
| assert callable(tool) |
|
|
| def test_get_tool_invalid(self): |
| """Test getting an invalid tool.""" |
| tool = get_tool("nonexistent_tool") |
| assert tool is None |
|
|
| def test_get_tool_schemas(self): |
| """Test getting tool schemas.""" |
| schemas = get_tool_schemas() |
| assert isinstance(schemas, list) |
| assert len(schemas) > 0 |
|
|
|
|
| class TestFileOperations: |
| """Test file operation tools.""" |
|
|
| def test_read_file_success(self, temp_file): |
| """Test reading a file.""" |
| result = tool_read_file(str(temp_file)) |
| |
| assert result["success"] is True |
| assert "content" in result |
| assert "Line 1" in result["content"] |
|
|
| def test_read_file_not_found(self): |
| """Test reading nonexistent file.""" |
| result = tool_read_file("/nonexistent/file.txt") |
| |
| assert result["success"] is False |
| assert "error" in result |
|
|
| def test_read_file_with_limit(self, temp_file): |
| """Test reading file with limit.""" |
| result = tool_read_file(str(temp_file), limit=2) |
| |
| assert result["success"] is True |
| lines = result["content"].split('\n') |
| assert len(lines) <= 3 |
|
|
| def test_write_file_success(self, temp_workspace): |
| """Test writing a file.""" |
| path = temp_workspace / "written.txt" |
| result = tool_write_file(str(path), "Hello World") |
| |
| assert result["success"] is True |
| assert path.exists() |
| assert path.read_text() == "Hello World" |
|
|
| def test_write_file_creates_dirs(self, temp_workspace): |
| """Test writing creates parent directories.""" |
| path = temp_workspace / "subdir" / "nested" / "file.txt" |
| result = tool_write_file(str(path), "content") |
| |
| assert result["success"] is True |
| assert path.exists() |
|
|
| def test_edit_file_success(self, temp_file): |
| """Test editing a file.""" |
| result = tool_edit_file(str(temp_file), "Line 1", "Line ONE") |
| |
| assert result["success"] is True |
| content = temp_file.read_text() |
| assert "Line ONE" in content |
|
|
| def test_edit_file_not_found(self): |
| """Test editing nonexistent file.""" |
| result = tool_edit_file("/nonexistent/file.txt", "old", "new") |
| |
| assert result["success"] is False |
|
|
| def test_edit_file_text_not_found(self, temp_file): |
| """Test editing with non-existent text.""" |
| result = tool_edit_file(str(temp_file), "NonExistentText", "new") |
| |
| assert result["success"] is False |
|
|
| def test_search_files(self, temp_project): |
| """Test searching for files.""" |
| result = tool_search_files(str(temp_project), "*.py") |
| |
| assert result["success"] is True |
| assert "matches" in result |
|
|
| def test_grep_basic(self, temp_file): |
| """Test grep functionality.""" |
| result = tool_grep(str(temp_file), "Line 1") |
| |
| assert result["success"] is True |
| assert "matches" in result |
| assert result["count"] > 0 |
|
|
| def test_grep_with_context(self, temp_file): |
| """Test grep with context.""" |
| result = tool_grep(str(temp_file), "Line", context=1) |
| |
| assert result["success"] is True |
| if result["matches"]: |
| assert "context" in result["matches"][0] |
|
|
| def test_copy_file(self, temp_file, temp_workspace): |
| """Test copying a file.""" |
| dest = temp_workspace / "copied.txt" |
| result = tool_copy_file(str(temp_file), str(dest)) |
| |
| assert result["success"] is True |
| assert dest.exists() |
|
|
| def test_move_file(self, temp_file, temp_workspace): |
| """Test moving a file.""" |
| dest = temp_workspace / "moved.txt" |
| result = tool_move_file(str(temp_file), str(dest)) |
| |
| assert result["success"] is True |
| assert dest.exists() |
|
|
| def test_delete_file_without_force(self, temp_file): |
| """Test delete without force.""" |
| result = tool_delete_file(str(temp_file)) |
| |
| assert result["success"] is True |
| assert "would_delete" in result |
|
|
| def test_delete_file_with_force(self, temp_file): |
| """Test delete with force.""" |
| result = tool_delete_file(str(temp_file), force=True) |
| |
| assert result["success"] is True |
| assert not temp_file.exists() |
|
|
|
|
| class TestGitOperations: |
| """Test git operation tools.""" |
|
|
| def test_git_status_no_repo(self): |
| """Test git status on non-repo.""" |
| result = tool_git_status("/nonexistent") |
| |
| assert result["success"] is False |
| assert "error" in result |
|
|
| @patch('subprocess.run') |
| def test_git_status_success(self, mock_run, temp_git_repo): |
| """Test git status success.""" |
| mock_result = MagicMock() |
| mock_result.stdout = " M modified.py\nA added.py\n" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_status(str(temp_git_repo)) |
| |
| assert result["success"] is True |
|
|
| @patch('subprocess.run') |
| def test_git_commit(self, mock_run, temp_git_repo): |
| """Test git commit.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "[main abc123] Test commit" |
| mock_result.stderr = "" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_commit(str(temp_git_repo), "Test commit") |
| |
| assert result["success"] is True |
|
|
| @patch('subprocess.run') |
| def test_git_push(self, mock_run): |
| """Test git push.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "To github.com:test/test.git\n abc123..def456 main -> main\n" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_push(str(temp_git_repo)) |
| |
| assert result["success"] is True |
|
|
| @patch('subprocess.run') |
| def test_git_pull(self, mock_run): |
| """Test git pull.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "Updating abc123..def456\n" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_pull(str(temp_git_repo)) |
| |
| assert result["success"] is True |
|
|
| @patch('subprocess.run') |
| def test_git_branch_list(self, mock_run): |
| """Test listing branches.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "* main\n develop\n feature/test\n" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_branch(str(temp_git_repo)) |
| |
| assert result["success"] is True |
| assert "branches" in result |
|
|
| @patch('subprocess.run') |
| def test_git_log(self, mock_run): |
| """Test git log.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "abc123 Commit message 1\ndef456 Commit message 2\n" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_log(str(temp_git_repo)) |
| |
| assert result["success"] is True |
|
|
| @patch('subprocess.run') |
| def test_git_diff(self, mock_run): |
| """Test git diff.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "diff --git a/test.py b/test.py\n+new line\n" |
| mock_run.return_value = mock_result |
| |
| result = tool_git_diff(str(temp_git_repo)) |
| |
| assert result["success"] is True |
|
|
|
|
| class TestCodeExecution: |
| """Test code execution tools.""" |
|
|
| @patch('subprocess.run') |
| def test_run_command_success(self, mock_run): |
| """Test running a command successfully.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_result.stdout = "output" |
| mock_result.stderr = "" |
| mock_run.return_value = mock_result |
| |
| result = tool_run_command("echo hello") |
| |
| assert result["success"] is True |
| assert result["stdout"] == "output" |
|
|
| @patch('subprocess.run') |
| def test_run_command_failure(self, mock_run): |
| """Test running a failing command.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 1 |
| mock_result.stdout = "" |
| mock_result.stderr = "error" |
| mock_run.return_value = mock_result |
| |
| result = tool_run_command("false") |
| |
| assert result["success"] is False |
|
|
| @patch('subprocess.run') |
| def test_run_command_timeout(self, mock_run): |
| """Test command timeout.""" |
| mock_run.side_effect = subprocess.TimeoutExpired("cmd", 1) |
| |
| result = tool_run_command("sleep 100", timeout=1) |
| |
| assert result["success"] is False |
| assert "timeout" in result["error"].lower() |
|
|
| @patch('subprocess.run') |
| def test_run_tests(self, mock_run): |
| """Test running tests.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_result.stdout = "test output" |
| mock_result.stderr = "" |
| mock_run.return_value = mock_result |
| |
| result = tool_run_tests(".") |
| |
| assert "success" in result |
|
|
| @patch('subprocess.run') |
| def test_lint_code(self, mock_run): |
| """Test linting code.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_result.stdout = "lint output" |
| mock_run.return_value = mock_result |
| |
| result = tool_lint_code(".") |
| |
| assert "success" in result |
|
|
| @patch('subprocess.run') |
| def test_format_code(self, mock_run): |
| """Test formatting code.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_run.return_value = mock_result |
| |
| result = tool_format_code(".") |
| |
| assert "success" in result |
|
|
| @patch('subprocess.run') |
| def test_check_type(self, mock_run): |
| """Test type checking.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_run.return_value = mock_result |
| |
| result = tool_check_type(".") |
| |
| assert "success" in result |
|
|
| @patch('subprocess.Popen') |
| def test_start_server_background(self, mock_popen): |
| """Test starting server in background.""" |
| mock_proc = MagicMock() |
| mock_proc.pid = 12345 |
| mock_popen.return_value = mock_proc |
| |
| result = tool_start_server("python server.py", 8000, background=True) |
| |
| assert result["success"] is True |
| assert "pid" in result |
|
|
|
|
| class TestWebTools: |
| """Test web tools.""" |
|
|
| @patch('subprocess.run') |
| def test_web_search(self, mock_run): |
| """Test web search.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_result.stdout = '[{"title": "Result", "url": "http://example.com"}]' |
| mock_run.return_value = mock_result |
| |
| result = tool_web_search("python") |
| |
| assert result["success"] is True |
| assert "results" in result |
|
|
| @patch('subprocess.run') |
| def test_web_fetch(self, mock_run): |
| """Test web fetch.""" |
| mock_result = MagicMock() |
| mock_result.returncode = 0 |
| mock_result.stdout = "<html>test</html>" |
| mock_run.return_value = mock_result |
| |
| result = tool_web_fetch("http://example.com") |
| |
| assert result["success"] is True |
| assert "content" in result |
|
|
| @patch('subprocess.run') |
| def test_check_url(self, mock_run): |
| """Test URL check.""" |
| mock_result = MagicMock() |
| mock_result.stdout = "200" |
| mock_run.return_value = mock_result |
| |
| result = tool_check_url("http://example.com") |
| |
| assert result["success"] is True |
|
|
|
|
| class TestMemoryTools: |
| """Test memory tools.""" |
|
|
| @patch('pathlib.Path.read_text') |
| def test_memory_recall(self, mock_read): |
| """Test memory recall.""" |
| mock_read.return_value = "### test\ntest content" |
| |
| result = tool_memory_recall("test") |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.write_text') |
| def test_memory_save(self, mock_write): |
| """Test memory save.""" |
| with patch('pathlib.Path.exists', return_value=True): |
| result = tool_memory_save("test_key", "test_value") |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.exists') |
| def test_memory_list(self, mock_exists): |
| """Test memory list.""" |
| mock_exists.return_value = False |
| |
| result = tool_memory_list() |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.read_text') |
| def test_context_load(self, mock_read): |
| """Test context load.""" |
| mock_read.return_value = "# Context" |
| |
| result = tool_context_load() |
| |
| assert result["success"] is True |
|
|
| def test_project_scan(self, temp_project): |
| """Test project scan.""" |
| result = tool_project_scan(str(temp_project)) |
| |
| assert result["success"] is True |
| assert "project" in result |
|
|
|
|
| class TestTaskPlanningTools: |
| """Test task planning tools.""" |
|
|
| @patch('pathlib.Path.write_text') |
| def test_create_task(self, mock_write): |
| """Test creating a task.""" |
| with patch('pathlib.Path.exists', return_value=False): |
| result = tool_create_task("Test task", "Description", "high") |
| |
| assert result["success"] is True |
| assert "task" in result |
|
|
| @patch('pathlib.Path.read_text') |
| def test_list_tasks(self, mock_read): |
| """Test listing tasks.""" |
| mock_read.return_value = "[]" |
| |
| result = tool_list_tasks() |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.read_text') |
| @patch('pathlib.Path.write_text') |
| def test_update_task(self, mock_write, mock_read): |
| """Test updating a task.""" |
| mock_read.return_value = '[{"id": "test123", "title": "Test"}]' |
| |
| result = tool_update_task("test123", status="completed") |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.read_text') |
| @patch('pathlib.Path.write_text') |
| def test_delete_task(self, mock_write, mock_read): |
| """Test deleting a task.""" |
| mock_read.return_value = '[{"id": "test123", "title": "Test"}]' |
| |
| result = tool_delete_task("test123") |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.write_text') |
| def test_create_plan(self, mock_write): |
| """Test creating a plan.""" |
| with patch('pathlib.Path.exists', return_value=False): |
| result = tool_create_plan("Goal", ["step1", "step2"]) |
| |
| assert result["success"] is True |
|
|
| @patch('pathlib.Path.read_text') |
| @patch('pathlib.Path.write_text') |
| def test_execute_plan(self, mock_write, mock_read): |
| """Test executing a plan.""" |
| mock_read.return_value = '[{"id": "plan1", "goal": "Goal", "steps": ["step1"]}]' |
| |
| result = tool_execute_plan("plan1") |
| |
| assert result["success"] is True |
|
|
|
|
| if __name__ == "__main__": |
| pytest.main([__file__, "-v"]) |
|
|
