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.

5.6 KB
Raw Blame
from __future__ import annotations

import threading
from queue import SimpleQueue
from uuid import uuid4

import pytest
from sqlalchemy import event
from sqlalchemy.pool import QueuePool

from local_deep_research.constants import ResearchStatus
from local_deep_research.database.encrypted_db import db_manager
from local_deep_research.database.queue_service import UserQueueService
from local_deep_research.database.session_context import get_user_db_session
from local_deep_research.web.queue.processor_v2 import QueueProcessorV2
from tests.connected.queue_test_support import (
    ConnectedUserFixture,
    QueueResearchSeed,
    QueueState,
    WorkerFailure,
    _queue_state,
    _register_connected_user,
    _seed_queued_research,
    raise_worker_failures,
)


def test_conditional_atomic_claim_allows_one_same_id_dispatch(
    connected_user: ConnectedUserFixture,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    case = connected_user
    monkeypatch.setattr(db_manager, "_use_static_pool", False)
    monkeypatch.setattr(db_manager, "_pool_class", QueuePool)
    _register_connected_user(case)

    research_id = str(uuid4())
    processors = (QueueProcessorV2(), QueueProcessorV2())
    claim_update_barrier = threading.Barrier(2)
    processor_start_barrier = threading.Barrier(2)
    worker_spawn_entered = threading.Event()
    allow_worker_spawn_to_return = threading.Event()
    conditional_claim_seen = threading.Event()
    unconditional_claim_seen = threading.Event()
    spawn_states: list[QueueState] = []
    dispatches: list[str] = []
    session_ids: list[int] = []
    dbapi_connection_ids: list[int] = []
    worker_failures: SimpleQueue[WorkerFailure] = SimpleQueue()

    with get_user_db_session(case.username, case.password) as db_session:
        _seed_queued_research(
            db_session,
            case.username,
            QueueResearchSeed(research_id=research_id, position=1),
        )

    engine = db_manager.open_user_database(case.username, case.password)
    assert engine is not None

    def record_dbapi_connection(
        dbapi_connection, _connection_record, _connection_proxy
    ) -> None:
        dbapi_connection_ids.append(id(dbapi_connection))

    def synchronize_claim_update(
        _connection,
        _cursor,
        statement: str,
        _parameters,
        _context,
        _executemany,
    ) -> None:
        normalized_statement = statement.lower()
        if normalized_statement.startswith("update queued_researches"):
            conditional_claim_present = (
                "is_processing is 0" in normalized_statement
                or "is_processing = 0" in normalized_statement
            )
            if conditional_claim_present:
                conditional_claim_seen.set()
            else:
                unconditional_claim_seen.set()
            claim_update_barrier.wait(timeout=5)

    def record_claimed_spawn(
        claimed_research_id: str, *_args, **_kwargs
    ) -> threading.Thread:
        with get_user_db_session(case.username, case.password) as db_session:
            spawn_states.append(_queue_state(db_session, claimed_research_id))
        dispatches.append(claimed_research_id)
        worker_spawn_entered.set()
        assert allow_worker_spawn_to_return.wait(timeout=5)
        return threading.current_thread()

    event.listen(engine, "checkout", record_dbapi_connection)
    event.listen(engine, "before_cursor_execute", synchronize_claim_update)
    monkeypatch.setattr(
        "local_deep_research.web.queue.processor_v2.start_research_process",
        record_claimed_spawn,
    )

    def claim_research(processor: QueueProcessorV2) -> None:
        try:
            processor_start_barrier.wait(timeout=5)
            with get_user_db_session(
                case.username, case.password
            ) as db_session:
                session_ids.append(id(db_session))
                processor._start_queued_researches(
                    db_session,
                    UserQueueService(db_session),
                    case.username,
                    case.password,
                    1,
                )
        except BaseException as exception:
            worker_failures.put(
                WorkerFailure(exception, exception.__traceback__)
            )

    claim_threads = tuple(
        threading.Thread(target=claim_research, args=(processor,))
        for processor in processors
    )
    for claim_thread in claim_threads:
        claim_thread.start()

    worker_spawned = False
    try:
        worker_spawned = worker_spawn_entered.wait(timeout=5)
    finally:
        allow_worker_spawn_to_return.set()
        for claim_thread in claim_threads:
            claim_thread.join(timeout=5)
        event.remove(engine, "before_cursor_execute", synchronize_claim_update)
        event.remove(engine, "checkout", record_dbapi_connection)

    assert all(not claim_thread.is_alive() for claim_thread in claim_threads)
    raise_worker_failures(worker_failures)
    assert worker_spawned

    expected_claimed_state: QueueState = (
        ResearchStatus.IN_PROGRESS,
        1,
        1,
        "processing",
        0,
        1,
        0,
    )
    assert len(set(session_ids)) == 2
    assert len(set(dbapi_connection_ids)) == 2
    assert dispatches == [research_id]
    assert spawn_states == [expected_claimed_state]
    assert conditional_claim_seen.is_set()
    assert not unconditional_claim_seen.is_set()

    with get_user_db_session(case.username, case.password) as db_session:
        assert _queue_state(db_session, research_id) == (
            ResearchStatus.IN_PROGRESS,
            0,
            0,
            "processing",
            1,
            1,
            0,
        )