Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

14.8 KB
Raw Blame
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from xagent.core.tools.adapters.vibe.document_parser import (
    DocumentParseTool,
    DocumentParseWithOutputTool,
)
from xagent.core.tools.core.document_parser import (
    DocumentCapabilities,
    DocumentParseArgs,
    DocumentParseWithOutputArgs,
    DocumentParseWithOutputResult,
    document_parser_registry,
    filter_parsers_by_capabilities,
)
from xagent.providers.pdf_parser.base import (
    DocumentParser,
    FigureParsing,
    FullTextResult,
    LocalParsing,
    ParsedFigures,
    ParsedTable,
    ParsedTextSegment,
    ParseResult,
    RemoteParsing,
    SegmentedTextResult,
    TextParsing,
)


class MockWorkspace:
    """Mock TaskWorkspace for resolving paths."""

    def resolve_path_with_search(self, path: str):
        if path == "input.pdf":
            return "/mock/workspace/input.pdf"
        raise FileNotFoundError(f"Path not found: {path}")

    def resolve_path(self, path: str):
        if path == "output.txt":
            return "/mock/workspace/output.txt"
        return path


# Create mock parser class instances with specific capabilities
def create_mock_parser(name, capabilities):
    mock_parser_class = MagicMock(spec=DocumentParser)
    mock_parser_class.__name__ = name
    mock_parser_class.get_capabilities.return_value = set(capabilities)

    mock_instance = AsyncMock(spec=DocumentParser)
    mock_parser_class.return_value = mock_instance
    return mock_parser_class, mock_instance


# Global registry
REGISTRY_MOCK_CONTENT = {
    "pypdf": create_mock_parser(
        "PyPdfParser", [TextParsing, SegmentedTextResult, LocalParsing]
    )[0],
    "deepdoc": create_mock_parser(
        "DeepDocParser",
        [TextParsing, FigureParsing, SegmentedTextResult, LocalParsing],
    )[0],
    "mineru_basic": create_mock_parser(
        "MinerUBasicDocumentParser", [TextParsing, FullTextResult, RemoteParsing]
    )[0],
    "mineru_enhanced": create_mock_parser(
        "MinerUEnhancedDocumentParser", [TextParsing, FigureParsing, RemoteParsing]
    )[0],
    "full_local_combo": create_mock_parser(
        "FullLocalCombo",
        [TextParsing, FigureParsing, FullTextResult, SegmentedTextResult, LocalParsing],
    )[0],
}


@pytest.fixture
def mock_parser_registry():
    """Fixture to mock the registry and its parsers."""
    # Create fresh instances for each test
    registry_instances = {}
    for name in REGISTRY_MOCK_CONTENT:
        parser_class, mock_instance = create_mock_parser(
            name, REGISTRY_MOCK_CONTENT[name].get_capabilities.return_value
        )
        registry_instances[name] = mock_instance

    with (
        patch.object(
            document_parser_registry, "parsers", return_value=REGISTRY_MOCK_CONTENT
        ) as mock_parsers,
        patch.object(
            document_parser_registry,
            "get_parser",
            side_effect=lambda name: registry_instances[name],
        ) as mock_get,
    ):
        # Reset all mocks before yielding
        for instance in registry_instances.values():
            instance.reset_mock()

        yield {
            "parsers": mock_parsers,
            "get_parser": mock_get,
            "instances": registry_instances,
            "parser_classes": REGISTRY_MOCK_CONTENT,
        }

        # Reset all mocks after test
        for instance in registry_instances.values():
            instance.reset_mock()


@pytest.fixture
def mock_workspace():
    return MockWorkspace()


@pytest.fixture
def parse_result_full():
    """A ParseResult object containing all fields."""
    return ParseResult(
        full_text="Complete document text.",
        text_segments=[
            ParsedTextSegment(text="Segment 1 text.", metadata={"page": 1}),
            ParsedTextSegment(text="Segment 2 text.", metadata={"page": 2}),
        ],
        figures=[
            ParsedFigures(text="Image Description.", metadata={"type": "Figure"}),
        ],
        tables=[
            ParsedTable(
                html="<table><tr><td>Table Content</td></tr></table>",
                metadata={"type": "Table"},
            ),
        ],
        metadata={"doc_title": "Test Doc", "parser_version": "v1.0"},
    )


def test_document_parse_tool_metadata():
    tool = DocumentParseTool()
    assert tool.name == "document_parse"
    assert tool.args_type() == DocumentParseArgs
    assert tool.return_type() == ParseResult


def test_document_parse_with_output_tool_metadata(mock_workspace):
    tool = DocumentParseWithOutputTool(mock_workspace)
    assert tool.name == "document_parse"
    assert tool.args_type() == DocumentParseWithOutputArgs
    assert tool.return_type() == DocumentParseWithOutputResult


def test_full_text_local_with_figure(mock_parser_registry):
    caps = DocumentCapabilities(
        capability_text=True,
        capability_figure=True,
        requires_full_text_result=True,
        requires_segmented_result=False,
        use_local_parser=True,
    )
    # Expected matches: "full_local_combo"
    result = filter_parsers_by_capabilities(
        mock_parser_registry["parser_classes"], caps
    )
    assert result == ["full_local_combo"]


def test_segmented_local_text_only(mock_parser_registry):
    caps = DocumentCapabilities(
        capability_text=True,
        capability_figure=False,
        requires_full_text_result=False,
        requires_segmented_result=True,
        use_local_parser=True,
    )
    # Expected matches: "pypdf", "deepdoc", "full_local_combo"
    result = filter_parsers_by_capabilities(
        mock_parser_registry["parser_classes"], caps
    )
    assert sorted(result) == sorted(["pypdf", "deepdoc", "full_local_combo"])


def test_full_text_remote_text_only(mock_parser_registry):
    caps = DocumentCapabilities(
        capability_text=True,
        capability_figure=False,
        requires_full_text_result=True,
        requires_segmented_result=False,
        use_local_parser=False,
    )
    # Expected matches: "mineru_basic"
    result = filter_parsers_by_capabilities(
        mock_parser_registry["parser_classes"], caps
    )
    assert result == ["mineru_basic"]


def test_no_parsers_match(mock_parser_registry):
    caps = DocumentCapabilities(
        capability_text=True,
        capability_figure=False,
        requires_full_text_result=True,
        requires_segmented_result=True,
        use_local_parser=True,
    )
    result = filter_parsers_by_capabilities(
        mock_parser_registry["parser_classes"], caps
    )
    assert result == ["full_local_combo"]

    caps_fail = DocumentCapabilities(
        capability_text=True,
        capability_figure=True,
        requires_full_text_result=True,
        requires_segmented_result=False,
        use_local_parser=False,
    )
    result_fail = filter_parsers_by_capabilities(
        mock_parser_registry["parser_classes"], caps_fail
    )
    assert result_fail == []


@pytest.mark.asyncio
async def test_document_parse_tool_successful_run(
    mock_parser_registry, mock_workspace, parse_result_full
):
    parser_name = "full_local_combo"
    mock_parser_registry["instances"][
        parser_name
    ].parse.return_value = parse_result_full

    tool = DocumentParseTool(workspace=mock_workspace)
    args = {
        "file_path": "input.pdf",
        "parser_name": parser_name,
        "capabilities": {
            "capability_text": True,
            "capability_figure": True,
            "requires_full_text_result": True,
            "requires_segmented_result": True,
            "use_local_parser": True,
        },
    }

    result = await tool.run_json_async(args)

    assert result == parse_result_full
    mock_parser_registry["instances"][parser_name].parse.assert_called_once_with(
        "/mock/workspace/input.pdf", progress_callback=None
    )


@pytest.mark.asyncio
async def test_document_parse_tool_default_parser_selection(mock_workspace):
    """Test that document parse tool correctly uses deepdoc parser for PDF files."""
    # Use a real PDF file for testing
    from pathlib import Path

    # Use fixed path for test PDF file
    test_pdf_path = (
        Path(__file__).parent.parent.parent / "resources" / "test_files" / "test.pdf"
    )

    if not test_pdf_path.exists():
        pytest.skip(f"Test PDF not found: {test_pdf_path}")

    tool = DocumentParseTool(workspace=mock_workspace)
    args = {
        "file_path": str(test_pdf_path),
        "parser_name": "",  # Empty parser_name triggers auto-selection for PDF -> deepdoc
        "capabilities": {
            "capability_text": True,
            "capability_figure": True,  # Allow figure parsing for deepdoc
            "requires_full_text_result": False,
            "requires_segmented_result": True,
            "use_local_parser": True,
        },
    }

    result = await tool.run_json_async(args)

    # Verify we got a valid ParseResult
    assert result is not None
    from xagent.core.tools.core.document_parser import ParseResult

    assert isinstance(result, ParseResult)
    assert hasattr(result, "text_segments")
    assert hasattr(result, "tables")
    assert hasattr(result, "figures")
    assert hasattr(result, "full_text")

    # Verify content was extracted
    assert len(result.text_segments) > 0
    assert len(result.full_text) > 0

    # For PDF files, deepdoc should be able to extract figures
    # (This depends on the actual PDF content)


@pytest.mark.asyncio
async def test_document_parse_tool_error_no_compatible_parsers(
    mock_parser_registry, mock_workspace
):
    tool = DocumentParseTool(workspace=mock_workspace)
    args = {
        "file_path": "input.pdf",
        "parser_name": "",
        "capabilities": {
            "capability_text": True,
            "capability_figure": True,
            "requires_full_text_result": True,
            "requires_segmented_result": False,
            "use_local_parser": False,  # remote
        },
    }
    with pytest.raises(ValueError, match="No parsers found matching requirements"):
        await tool.run_json_async(args)


@pytest.mark.asyncio
async def test_document_parse_tool_error_parser_failure(
    mock_parser_registry, mock_workspace
):
    parser_name = "pypdf"
    mock_parser_registry["instances"][parser_name].parse.side_effect = Exception(
        "Parsing failed internally"
    )

    tool = DocumentParseTool(workspace=mock_workspace)
    args = {
        "file_path": "input.pdf",
        "parser_name": parser_name,
        "capabilities": {
            "capability_text": True,
            "capability_figure": False,
            "requires_full_text_result": False,
            "requires_segmented_result": True,
            "use_local_parser": True,
        },
    }

    with pytest.raises(
        RuntimeError, match=f"Document parsing failed with {parser_name}"
    ):
        await tool.run_json_async(args)


@pytest.mark.asyncio
async def test_document_parse_tool_error_incompatible_requested_parser(
    mock_parser_registry, mock_workspace
):
    # Requesting pypdf (Segmented/Local) but demanding FullTextResult
    tool = DocumentParseTool(workspace=mock_workspace)
    args = {
        "file_path": "input.pdf",
        "parser_name": "pypdf",
        "capabilities": {
            "capability_text": True,
            "capability_figure": False,
            "requires_full_text_result": True,  # Incompatible with pypdf
            "requires_segmented_result": False,
            "use_local_parser": True,
        },
    }

    with pytest.raises(
        ValueError, match="Requested parser 'pypdf' doesn't meet requirements"
    ):
        await tool.run_json_async(args)


@pytest.mark.asyncio
@patch("builtins.open")
async def test_document_parse_with_output_tool_successful_execution(
    mock_open, mock_parser_registry, mock_workspace, parse_result_full
):
    parser_name = "full_local_combo"
    mock_parser_registry["instances"][
        parser_name
    ].parse.return_value = parse_result_full

    mock_file = MagicMock()
    mock_open.return_value.__enter__.return_value = mock_file

    tool = DocumentParseWithOutputTool(workspace=mock_workspace)
    args = {
        "file_path": "input.pdf",
        "parser_name": parser_name,
        "output_path": "output.txt",
        "output_format": "txt",  # Explicitly specify txt format for this test
        "capabilities": {
            "capability_text": True,
            "capability_figure": False,
            "requires_full_text_result": False,
            "requires_segmented_result": True,
            "use_local_parser": True,
        },
    }

    result = await tool.run_json_async(args)

    assert result == DocumentParseWithOutputResult()
    mock_parser_registry["instances"][parser_name].parse.assert_called_once_with(
        "/mock/workspace/input.pdf", progress_callback=None
    )
    mock_open.assert_called_once_with(
        "/mock/workspace/output.txt", "w", encoding="utf-8"
    )
    mock_file.write.assert_any_call("=== FULL TEXT ===\n")
    mock_file.write.assert_any_call("Complete document text.")
    mock_file.write.assert_any_call("\n\n")
    mock_file.write.assert_any_call("=== TEXT SEGMENTS ===\n")
    mock_file.write.assert_any_call("--- Segment 1 ---\n")
    mock_file.write.assert_any_call("Text: Segment 1 text.\n")
    mock_file.write.assert_any_call("Metadata: {'page': 1}\n")
    mock_file.write.assert_any_call("=== FIGURES ===\n")
    mock_file.write.assert_any_call("--- Figure 1 ---\n")
    mock_file.write.assert_any_call("Text: Image Description.\n")
    mock_file.write.assert_any_call("Metadata: {'type': 'Figure'}\n")
    mock_file.write.assert_any_call("=== TABLES ===\n")
    mock_file.write.assert_any_call("--- Table 1 ---\n")
    mock_file.write.assert_any_call(
        "HTML: <table><tr><td>Table Content</td></tr></table>\n"
    )
    mock_file.write.assert_any_call("Metadata: {'type': 'Table'}\n")
    mock_file.write.assert_any_call("=== METADATA ===\n")
    mock_file.write.assert_any_call("doc_title: Test Doc\n")
    mock_file.write.assert_any_call("parser_version: v1.0\n")


@pytest.mark.asyncio
@patch("builtins.open")
async def test_document_parse_with_output_tool_error_on_file_writing(
    mock_open, mock_parser_registry, mock_workspace, parse_result_full
):
    parser_name = "full_local_combo"
    mock_parser_registry["instances"][
        parser_name
    ].parse.return_value = parse_result_full

    mock_open.side_effect = PermissionError("Cannot access file")

    tool = DocumentParseWithOutputTool(workspace=mock_workspace)

    args = {
        "file_path": "input.pdf",
        "parser_name": parser_name,
        "output_path": "output.txt",
        "capabilities": {
            "capability_text": True,
            "capability_figure": False,
            "requires_full_text_result": False,
            "requires_segmented_result": True,
            "use_local_parser": True,
        },
    }

    with pytest.raises(
        RuntimeError, match="Failed to write output to /mock/workspace/output.txt"
    ):
        await tool.run_json_async(args)