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.4 KB
Raw Blame
from contextlib import contextmanager
from pathlib import Path
from unittest.mock import MagicMock

import pytest


@contextmanager
def _session_context(session):
    yield session


def _forbid_filesystem_mutations(monkeypatch):
    calls = []

    def forbidden(*args, **kwargs):
        calls.append((args, kwargs))
        raise AssertionError("queue lifecycle attempted a filesystem mutation")

    monkeypatch.setattr(Path, "write_text", forbidden)
    monkeypatch.setattr(Path, "write_bytes", forbidden)
    monkeypatch.setattr(Path, "unlink", forbidden)
    return calls


@pytest.mark.parametrize("task_id", ["../escape", "/tmp/escape", "bad\\x00id"])
def test_cancellation_status_persists_only_to_database(task_id, monkeypatch):
    # ``_do_update_task_status`` moved from the deleted Flask
    # ``research_library.routes.rag_routes`` to ``web.routers.rag`` in the
    # FastAPI migration (#3299); the retry-wrapped body is unchanged.
    import local_deep_research.web.routers.rag as routes

    task = MagicMock(status="processing", metadata_json={})
    session = MagicMock()
    session.query.return_value.filter_by.return_value.first.return_value = task
    monkeypatch.setattr(
        "local_deep_research.database.session_context.get_user_db_session",
        lambda *args, **kwargs: _session_context(session),
    )
    fs_calls = _forbid_filesystem_mutations(monkeypatch)

    routes._do_update_task_status(
        "alice", "password", task_id, status="cancelled"
    )

    assert task.status == "cancelled"
    assert task.completed_at is not None
    session.commit.assert_called_once()
    assert fs_calls == []


def test_cancellation_commit_failure_surfaces_without_filesystem_fallback(
    monkeypatch,
):
    # ``_do_update_task_status`` moved from the deleted Flask
    # ``research_library.routes.rag_routes`` to ``web.routers.rag`` in the
    # FastAPI migration (#3299); the retry-wrapped body is unchanged.
    import local_deep_research.web.routers.rag as routes

    task = MagicMock(status="processing", metadata_json={})
    session = MagicMock()
    session.query.return_value.filter_by.return_value.first.return_value = task
    session.commit.side_effect = RuntimeError("database unavailable")
    monkeypatch.setattr(
        "local_deep_research.database.session_context.get_user_db_session",
        lambda *args, **kwargs: _session_context(session),
    )
    fs_calls = _forbid_filesystem_mutations(monkeypatch)

    with pytest.raises(RuntimeError, match="database unavailable"):
        routes._do_update_task_status(
            "alice", "password", "cancel-me", status="cancelled"
        )

    assert fs_calls == []


@pytest.mark.parametrize("username", ["../escape", "/tmp/escape"])
def test_queue_sweep_state_is_database_only_for_hostile_usernames(
    username, monkeypatch
):
    import local_deep_research.web.queue.processor_v2 as processor_module

    processor = processor_module.QueueProcessorV2(check_interval=1)
    session = MagicMock()
    session.query.return_value.outerjoin.return_value.filter.return_value.all.return_value = []
    monkeypatch.setattr(
        processor_module,
        "reconcile_research_queue_status",
        lambda _session: False,
    )
    fs_calls = _forbid_filesystem_mutations(monkeypatch)

    result = processor._sweep_missing_parent_queue_rows(session, username)

    assert result.can_dispatch is True
    assert result.cleaned_ids == frozenset()
    session.commit.assert_not_called()
    assert fs_calls == []


def test_queue_sweep_cleanup_commits_database_rows_without_filesystem_state(
    monkeypatch,
):
    import local_deep_research.web.queue.processor_v2 as processor_module

    processor = processor_module.QueueProcessorV2(check_interval=1)
    session = MagicMock()
    query = session.query.return_value
    # Queue orphans join the history table; metadata orphans also join the
    # queue table, to leave rows another user's queue entry points at.
    query.outerjoin.return_value.filter.return_value.all.return_value = [
        ("../queued",)
    ]
    query.outerjoin.return_value.outerjoin.return_value.filter.return_value.all.return_value = [
        ("/tmp/metadata",)
    ]
    cleaned = MagicMock(cleaned_ids=frozenset({"../queued", "/tmp/metadata"}))
    cleanup = MagicMock(return_value=cleaned)
    monkeypatch.setattr(
        processor_module, "cleanup_queued_research_state", cleanup
    )
    fs_calls = _forbid_filesystem_mutations(monkeypatch)

    result = processor._sweep_missing_parent_queue_rows(session, "alice")

    cleanup.assert_called_once_with(
        session,
        {"../queued", "/tmp/metadata"},
        include_claimed=True,
        acting_user="alice",
    )
    session.commit.assert_called_once()
    assert result.cleaned_ids == cleaned.cleaned_ids
    assert fs_calls == []


@pytest.mark.parametrize(
    "report_path", ["../escape.md", "/tmp/escape.md", "nested/../../escape.md"]
)
def test_queue_error_operation_retains_report_path_in_memory_without_writing(
    report_path, monkeypatch
):
    from local_deep_research.web.queue.processor_v2 import QueueProcessorV2

    processor = QueueProcessorV2(check_interval=1)
    fs_calls = _forbid_filesystem_mutations(monkeypatch)

    processor.queue_error_update(
        "alice",
        "research-1",
        "failed",
        "error",
        {},
        "2026-01-01T00:00:00",
        report_path=report_path,
    )

    operation = next(iter(processor.pending_operations.values()))
    assert operation["research_id"] == "research-1"
    assert operation["report_path"] == report_path
    assert fs_calls == []


def test_pending_error_flush_assigns_report_path_to_database_column_only(
    monkeypatch,
):
    from local_deep_research.web.queue.processor_v2 import QueueProcessorV2

    processor = QueueProcessorV2(check_interval=1)
    hostile_path = "../../outside/report.md"
    processor.queue_error_update(
        "alice",
        "research-2",
        "failed",
        "error",
        {"source": "test"},
        "2026-01-01T00:00:00",
        report_path=hostile_path,
    )
    research = MagicMock(id="research-2")
    session = MagicMock()
    session.query.return_value.filter.return_value.all.return_value = [research]
    fs_calls = _forbid_filesystem_mutations(monkeypatch)

    assert processor.process_pending_operations_for_user("alice", session) == 1

    assert research.report_path == hostile_path
    session.commit.assert_called_once()
    assert processor.pending_operations == {}
    assert fs_calls == []