Skip to content

Build and run agents you can see, understand and trust.

14.6 KB
Raw Blame
# -*- coding: utf-8 -*-
"""Glob tool test case."""
import os
import tempfile
from unittest.async_case import IsolatedAsyncioTestCase
from unittest.mock import AsyncMock

from utils import AnyString
from agentscope.tool import ExecResult, Glob, LocalBackend
from agentscope.permission import (
    PermissionContext,
    PermissionBehavior,
    PermissionRule,
)


# pylint: disable=too-many-public-methods
class GlobToolTest(IsolatedAsyncioTestCase):
    """The glob tool test case."""

    async def asyncSetUp(self) -> None:
        """The async setup method."""
        self.glob_tool = Glob()
        # Create a temporary directory with test files
        self.temp_dir = tempfile.mkdtemp()

        # Create test files
        with open(
            os.path.join(self.temp_dir, "test1.py"),
            "w",
            encoding="utf-8",
        ):
            pass
        with open(
            os.path.join(self.temp_dir, "test2.py"),
            "w",
            encoding="utf-8",
        ):
            pass
        with open(
            os.path.join(self.temp_dir, "test.txt"),
            "w",
            encoding="utf-8",
        ):
            pass

        # Create subdirectory
        sub_dir = os.path.join(self.temp_dir, "subdir")
        os.makedirs(sub_dir)
        with open(os.path.join(sub_dir, "test3.py"), "w", encoding="utf-8"):
            pass

    async def asyncTearDown(self) -> None:
        """Clean up temporary files."""
        import shutil

        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    async def test_tool_properties(self) -> None:
        """Test glob tool properties."""
        self.assertEqual(self.glob_tool.name, "Glob")
        self.assertIsInstance(self.glob_tool.description, str)
        self.assertIsInstance(self.glob_tool.input_schema, dict)
        self.assertFalse(self.glob_tool.is_mcp)
        self.assertTrue(self.glob_tool.is_read_only)
        self.assertTrue(self.glob_tool.is_concurrency_safe)

    async def test_check_permissions(self) -> None:
        """Test glob tool permission checking."""
        context = PermissionContext()
        tool_input = {"pattern": "*.py"}
        decision = await self.glob_tool.check_permissions(tool_input, context)

        # Read/Glob/Grep are read-only, return PASSTHROUGH
        self.assertEqual(decision.behavior, PermissionBehavior.PASSTHROUGH)

    async def test_invalid_helper_output(self) -> None:
        """Malformed helper output must not masquerade as no matches."""
        backend = LocalBackend()
        backend.is_dir = AsyncMock(return_value=True)
        backend.exec_shell = AsyncMock()
        tool = Glob(backend=backend)
        for output in (
            b"not-json",
            b"null",
            b"{}",
            b'"path.py"',
            b"[1]",
            b"[null]",
        ):
            with self.subTest(output=output):
                backend.exec_shell.return_value = ExecResult(0, output, b"")
                chunk = await tool(pattern="*.py", path=self.temp_dir)
                self.assertEqual(
                    chunk.model_dump(
                        exclude={
                            "id": True,
                            "content": {"__all__": {"id", "created_at"}},
                        },
                    ),
                    {
                        "content": [
                            {
                                "type": "text",
                                "text": "Glob helper returned invalid output: "
                                "expected a JSON array of file paths.",
                                "finished_at": None,
                            },
                        ],
                        "state": "error",
                        "is_last": True,
                        "metadata": {},
                    },
                )

    async def test_simple_pattern(self) -> None:
        """Test simple glob pattern."""
        chunk = await self.glob_tool(
            pattern="*.py",
            path=self.temp_dir,
        )

        self.assertEqual(chunk.state, "running")

        # Should find test1.py and test2.py
        content = chunk.content[0].text
        self.assertIn("test1.py", content)
        self.assertIn("test2.py", content)
        self.assertNotIn("test.txt", content)

    async def test_dash_prefixed_patterns(self) -> None:
        """The helper must receive option-like patterns as literal values."""
        for name, pattern in (
            ("-report.txt", "-report*.txt"),
            ("--help", "--help"),
            ("-report=one.txt", "-report=*.txt"),
        ):
            with self.subTest(pattern=pattern):
                target = os.path.join(self.temp_dir, name)
                with open(target, "w", encoding="utf-8"):
                    pass
                chunk = await self.glob_tool(
                    pattern=pattern,
                    path=self.temp_dir,
                )
                self.assertEqual(chunk.state, "running")
                self.assertEqual(chunk.content[0].text, target)

    async def test_recursive_pattern(self) -> None:
        """Test recursive glob pattern."""
        chunk = await self.glob_tool(
            pattern="**/*.py",
            path=self.temp_dir,
        )

        content = chunk.content[0].text

        # Should find all .py files including in subdirectory
        self.assertIn("test1.py", content)
        self.assertIn("test2.py", content)
        self.assertIn("test3.py", content)

    async def test_current_directory_segments(self) -> None:
        """Standalone dot segments do not change the matched files."""
        for pattern, expected in (
            ("./*.py", ["test1.py", "test2.py"]),
            ("./**/*.py", ["subdir/test3.py", "test1.py", "test2.py"]),
            ("subdir/./*.py", ["subdir/test3.py"]),
            (r".\subdir\.\*.py", ["subdir/test3.py"]),
        ):
            with self.subTest(pattern=pattern):
                chunk = await self.glob_tool(
                    pattern=pattern,
                    path=self.temp_dir,
                )
                self.assertListEqual(
                    sorted(chunk.content[0].text.splitlines()),
                    [
                        os.path.join(self.temp_dir, *name.split("/"))
                        for name in expected
                    ],
                )

    async def test_dot_prefixed_names_are_preserved(self) -> None:
        """Normalizing '.' must not strip dots from hidden names."""
        directory = os.path.join(self.temp_dir, ".config")
        os.makedirs(directory)
        path = os.path.join(directory, ".env")
        with open(path, "w", encoding="utf-8"):
            pass

        result = await self.glob_tool(
            pattern="./.config/./.env",
            path=self.temp_dir,
        )

        self.assertEqual(result.content[0].text, path)

    async def test_default_head_limit_truncates_large_result(self) -> None:
        """Test the default head limit returns the newest 250 files."""
        expected_paths = []
        for index in range(251):
            file_path = os.path.join(self.temp_dir, f"match_{index}.log")
            with open(file_path, "w", encoding="utf-8"):
                pass
            os.utime(file_path, (index, index))
            expected_paths.append(file_path)

        chunk = await self.glob_tool(
            pattern="match_*.log",
            path=self.temp_dir,
        )

        expected = "\n".join(reversed(expected_paths[1:]))
        expected += "\n\n[Showing results with pagination = limit: 250]"
        self.assertEqual(chunk.content[0].text, expected)

    async def test_head_limit_zero_returns_all_results(self) -> None:
        """Test zero disables the default head limit."""
        expected_paths = []
        for index in range(4):
            file_path = os.path.join(self.temp_dir, f"unlimited_{index}.txt")
            with open(file_path, "w", encoding="utf-8"):
                pass
            os.utime(file_path, (index, index))
            expected_paths.append(file_path)

        chunk = await self.glob_tool(
            pattern="unlimited_*.txt",
            path=self.temp_dir,
            head_limit=0,
        )
        self.assertEqual(
            chunk.content[0].text,
            "\n".join(reversed(expected_paths)),
        )

    async def test_negative_head_limit_returns_error(self) -> None:
        """Test a negative head limit returns an error."""
        chunk = await self.glob_tool(
            pattern="*.py",
            path=self.temp_dir,
            head_limit=-1,
        )

        self.assertEqual(chunk.state, "error")
        self.assertEqual(
            chunk.content[0].text,
            "Error: head_limit must be non-negative.",
        )

    async def test_offset_paginates_results(self) -> None:
        """Test that callers can retrieve later pages of results."""
        expected_paths = []
        for index in range(6):
            file_path = os.path.join(self.temp_dir, f"paged_{index}.txt")
            with open(file_path, "w", encoding="utf-8"):
                pass
            os.utime(file_path, (index, index))
            expected_paths.append(file_path)

        second_page = await self.glob_tool(
            pattern="paged_*.txt",
            path=self.temp_dir,
            head_limit=2,
            offset=2,
        )
        self.assertEqual(
            second_page.content[0].text,
            f"{expected_paths[3]}\n{expected_paths[2]}\n\n"
            "[Showing results with pagination = limit: 2, offset: 2]",
        )

        last_page = await self.glob_tool(
            pattern="paged_*.txt",
            path=self.temp_dir,
            head_limit=2,
            offset=4,
        )
        self.assertEqual(
            last_page.content[0].text,
            "\n".join([expected_paths[1], expected_paths[0]]),
        )

    async def test_negative_offset_returns_error(self) -> None:
        """Test a negative offset returns an error."""
        chunk = await self.glob_tool(
            pattern="*.py",
            path=self.temp_dir,
            offset=-1,
        )

        self.assertEqual(chunk.state, "error")
        self.assertEqual(
            chunk.content[0].text,
            "Error: offset must be non-negative.",
        )

    async def test_windows_style_separator_pattern(self) -> None:
        """Test glob patterns that use backslashes as path separators."""
        chunk = await self.glob_tool(
            pattern=r"subdir\*.py",
            path=self.temp_dir,
        )

        self.assertDictEqual(
            chunk.model_dump(),
            {
                "content": [
                    {
                        "type": "text",
                        "text": os.path.join(
                            self.temp_dir,
                            "subdir",
                            "test3.py",
                        ),
                        "id": AnyString(),
                        "created_at": AnyString(),
                        "finished_at": None,
                    },
                ],
                "state": "running",
                "is_last": True,
                "metadata": {},
                "id": AnyString(),
            },
        )

    async def test_no_matches(self) -> None:
        """Test pattern with no matches."""
        chunk = await self.glob_tool(
            pattern="*.nonexistent",
            path=self.temp_dir,
        )

        self.assertEqual(chunk.state, "running")
        self.assertEqual(
            chunk.content[0].text,
            "No files found matching pattern: *.nonexistent",
        )

    async def test_match_rule_path(self) -> None:
        """Test match_rule with path patterns."""
        # Test matching explicit path
        self.assertTrue(
            await self.glob_tool.match_rule(
                self.temp_dir,
                {"path": self.temp_dir, "pattern": "*.py"},
            ),
        )

        # Test wildcard pattern matching path
        parent_dir = os.path.dirname(self.temp_dir)
        self.assertTrue(
            await self.glob_tool.match_rule(
                parent_dir + "/**",
                {"path": self.temp_dir, "pattern": "*.py"},
            ),
        )

        # Test non-matching path
        self.assertFalse(
            await self.glob_tool.match_rule(
                "/some/other/path/**",
                {"path": self.temp_dir, "pattern": "*.py"},
            ),
        )

    async def test_match_rule_pattern(self) -> None:
        """Test match_rule with pattern matching."""
        # Test matching against the pattern itself
        self.assertTrue(
            await self.glob_tool.match_rule(
                "*.py",
                {"pattern": "*.py"},
            ),
        )

        # Test wildcard pattern matching
        self.assertTrue(
            await self.glob_tool.match_rule(
                "**/*.py",
                {"pattern": "src/**/*.py"},
            ),
        )

        # Test non-matching pattern
        self.assertFalse(
            await self.glob_tool.match_rule(
                "*.txt",
                {"pattern": "*.py"},
            ),
        )

    async def test_match_rule_path_priority(self) -> None:
        """Test that path matching takes priority over pattern matching."""
        # If path matches, should return True even if pattern doesn't
        self.assertTrue(
            await self.glob_tool.match_rule(
                self.temp_dir,
                {"path": self.temp_dir, "pattern": "*.txt"},
            ),
        )

    async def test_generate_suggestions_with_path(self) -> None:
        """Test generate_suggestions for glob with explicit path."""

        suggestions = await self.glob_tool.generate_suggestions(
            {"path": self.temp_dir, "pattern": "*.py"},
        )

        self.assertIsInstance(suggestions, list)
        self.assertGreater(len(suggestions), 0)
        self.assertIsInstance(suggestions[0], PermissionRule)

        # Should suggest directory pattern
        abs_path = os.path.abspath(self.temp_dir)
        expected_pattern = abs_path.rstrip("/") + "/**"
        suggestion_contents = [s.rule_content for s in suggestions]
        self.assertIn(expected_pattern, suggestion_contents)

    async def test_generate_suggestions_defaults_to_cwd(self) -> None:
        """Test generate_suggestions defaults to cwd when no path provided."""

        suggestions = await self.glob_tool.generate_suggestions(
            {"pattern": "*.py"},
        )

        self.assertIsInstance(suggestions, list)
        self.assertGreater(len(suggestions), 0)

        cwd = os.getcwd()
        expected_pattern = os.path.abspath(cwd).rstrip("/") + "/**"
        suggestion_contents = [s.rule_content for s in suggestions]
        self.assertIn(expected_pattern, suggestion_contents)