Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

6.3 KB
Raw Blame
from unittest.mock import MagicMock, Mock

import arxiv
import pytest
from pytest_mock import MockerFixture

from local_deep_research.utilities import arxiv_api as arxiv_api_module


class FetchIterationError(RuntimeError):
    pass


def _stub_policy_client(
    mocker: MockerFixture,
) -> tuple[MagicMock, MagicMock, Mock]:
    policy = mocker.patch.object(arxiv_api_module, "_policy_arxiv_client")
    context = policy.return_value
    context.__exit__.return_value = False
    client = context.__enter__.return_value
    return policy, context, client


def _paper(
    entry_id: str = "https://arxiv.org/abs/2101.12345v1",
) -> arxiv.Result:
    return arxiv.Result(entry_id=entry_id)


def test_request_types_expose_stable_defaults_and_values() -> None:
    request = arxiv_api_module.ArxivQueryRequest(query="q", max_results=10)

    assert request.sort_by is arxiv_api_module.ArxivSortCriterion.RELEVANCE
    assert request.sort_order is arxiv_api_module.ArxivSortOrder.DESCENDING
    assert arxiv_api_module.ArxivSortCriterion.RELEVANCE == "relevance"
    assert (
        arxiv_api_module.ArxivSortCriterion.LAST_UPDATED_DATE
        == "lastUpdatedDate"
    )
    assert arxiv_api_module.ArxivSortCriterion.SUBMITTED_DATE == "submittedDate"
    assert arxiv_api_module.ArxivSortOrder.ASCENDING == "ascending"
    assert arxiv_api_module.ArxivSortOrder.DESCENDING == "descending"


def test_query_request_maps_search_enums_and_materializes_inside_context(
    mocker: MockerFixture,
) -> None:
    policy, context, client = _stub_policy_client(mocker)
    search_value = Mock(name="search")
    search = mocker.patch.object(arxiv, "Search", return_value=search_value)
    papers = [_paper()]

    def results(_search: Mock):
        assert context.__exit__.call_count == 0
        yield from papers

    client.results.side_effect = results
    request = arxiv_api_module.ArxivQueryRequest(
        query="graph models",
        max_results=7,
        sort_by=arxiv_api_module.ArxivSortCriterion.LAST_UPDATED_DATE,
        sort_order=arxiv_api_module.ArxivSortOrder.ASCENDING,
    )

    fetched = arxiv_api_module.fetch_arxiv_results(request)

    assert fetched == papers
    assert fetched[0] is papers[0]
    search.assert_called_once_with(
        query="graph models",
        max_results=7,
        sort_by=arxiv.SortCriterion.LastUpdatedDate,
        sort_order=arxiv.SortOrder.Ascending,
    )
    policy.assert_called_once_with(page_size=7)
    client.results.assert_called_once_with(search_value)
    context.__exit__.assert_called_once_with(None, None, None)


def test_id_request_uses_id_search_and_default_client_page_size(
    mocker: MockerFixture,
) -> None:
    policy, _, client = _stub_policy_client(mocker)
    search_value = Mock(name="search")
    search = mocker.patch.object(arxiv, "Search", return_value=search_value)
    paper = _paper()
    client.results.return_value = iter([paper])

    fetched = arxiv_api_module.fetch_arxiv_results(
        arxiv_api_module.ArxivIdRequest(arxiv_id="2101.12345")
    )

    assert fetched == [paper]
    search.assert_called_once_with(id_list=["2101.12345"], max_results=1)
    policy.assert_called_once_with()


@pytest.mark.parametrize(
    "fetch_request",
    [
        arxiv_api_module.ArxivQueryRequest(query="graph models", max_results=2),
        arxiv_api_module.ArxivIdRequest(arxiv_id="2101.12345v1"),
    ],
    ids=["query", "identifier"],
)
def test_result_text_is_stripped_as_feedparser_stripped_it(
    mocker: MockerFixture,
    fetch_request: arxiv_api_module.ArxivRequest,
) -> None:
    # arxiv 4.x keeps the surrounding whitespace feedparser stripped in
    # 2.x. str.strip() is what feedparser used, so Unicode whitespace
    # (U+00A0, U+3000) goes too; inner whitespace and absent fields stay.
    _, _, client = _stub_policy_client(mocker)
    mocker.patch.object(arxiv, "Search", return_value=Mock())
    padded = arxiv.Result(
        entry_id="\n  https://arxiv.org/abs/2101.12345v1\n",
        title=" Graph models ",
        authors=[
            arxiv.Result.Author("\n  Example Author\n"),
            arxiv.Result.Author("Second Author"),
        ],
        summary="  Research abstract.\n  Second line.\n",
        comment=" Two figures\n",
        journal_ref=" Example Journal ",
        doi="\t10.1234/example ",
    )
    bare = arxiv.Result(
        entry_id="https://arxiv.org/abs/2101.54321v1",
        comment=None,
        journal_ref=None,
        doi=None,
    )
    client.results.return_value = iter([padded, bare])

    fetched = arxiv_api_module.fetch_arxiv_results(fetch_request)

    assert fetched[0] is padded
    assert fetched[1] is bare
    assert padded.entry_id == "https://arxiv.org/abs/2101.12345v1"
    assert padded.title == "Graph models"
    assert padded.summary == "Research abstract.\n  Second line."
    assert padded.comment == "Two figures"
    assert padded.journal_ref == "Example Journal"
    assert padded.doi == "10.1234/example"
    assert [author.name for author in padded.authors] == [
        "Example Author",
        "Second Author",
    ]
    assert (bare.comment, bare.journal_ref, bare.doi) == (None, None, None)


def test_iteration_error_propagates_after_context_cleanup(
    mocker: MockerFixture,
) -> None:
    _, context, client = _stub_policy_client(mocker)
    mocker.patch.object(arxiv, "Search", return_value=Mock())
    failure = FetchIterationError("iteration failed")

    def results(_search: Mock):
        raise failure
        yield

    client.results.side_effect = results

    with pytest.raises(FetchIterationError) as exc_info:
        arxiv_api_module.fetch_arxiv_results(
            arxiv_api_module.ArxivIdRequest(arxiv_id="2101.12345")
        )

    assert exc_info.value is failure
    assert context.__exit__.call_args.args[0] is FetchIterationError
    assert context.__exit__.call_args.args[1] is failure


def test_search_construction_error_propagates_without_opening_client(
    mocker: MockerFixture,
) -> None:
    policy, _, _ = _stub_policy_client(mocker)
    failure = FetchIterationError("search failed")
    mocker.patch.object(arxiv, "Search", side_effect=failure)

    with pytest.raises(FetchIterationError) as exc_info:
        arxiv_api_module.fetch_arxiv_results(
            arxiv_api_module.ArxivIdRequest(arxiv_id="2101.12345")
        )

    assert exc_info.value is failure
    policy.assert_not_called()