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.

4.7 KB
Raw Blame
from __future__ import annotations

import threading
from pathlib import Path
from typing import Protocol
from unittest.mock import patch
from uuid import UUID, uuid4

from sqlalchemy import select

from local_deep_research.constants import ResearchStatus
from local_deep_research.database.encrypted_db import db_manager
from local_deep_research.database.models import (
    QueueStatus,
    QueuedResearch,
    ResearchHistory,
    TaskMetadata,
    UserActiveResearch,
)
from local_deep_research.database.session_passwords import (
    session_password_store,
)
from local_deep_research.settings.manager import SettingsManager
from local_deep_research.web.auth.session_manager import session_manager
from local_deep_research.web.research_state import (
    remove_active_research,
    set_active_research,
)

from tests.connected.conftest import csrf_headers, register_connected_user


class ConnectedUserFixture(Protocol):
    # Flask app/client type hints dropped: the branch's ``client`` fixture
    # is a Flask-compat-shimmed Starlette TestClient.
    app: object
    client: object
    username: str
    password: str
    data_root: Path


def test_queued_submission_persists_research_and_processor_metadata(
    connected_user: ConnectedUserFixture,
) -> None:
    case = connected_user

    register_connected_user(case)
    session_ids = tuple(
        session_id
        for session_id in session_manager.sessions
        if session_manager.validate_session(session_id) == case.username
    )
    assert len(session_ids) == 1
    session_id = session_ids[0]

    assert (
        session_password_store.get_session_password(case.username, session_id)
        == case.password
    )

    database_session = db_manager.get_session(case.username)
    assert database_session is not None
    active_research_id = str(uuid4())
    with database_session:
        settings_manager = SettingsManager(database_session)
        assert settings_manager.set_setting("app.queue_mode", "queue")
        assert settings_manager.set_setting("app.max_concurrent_researches", 1)
        database_session.add(
            UserActiveResearch(
                username=case.username,
                research_id=active_research_id,
                status=ResearchStatus.IN_PROGRESS,
                thread_id=str(threading.current_thread().ident),
                settings_snapshot={},
            )
        )
        database_session.commit()

    set_active_research(
        active_research_id,
        {"thread": threading.current_thread()},
    )
    try:
        with patch(
            "local_deep_research.web.routers.research.start_research_process"
        ) as start_research_process:
            response = case.client.post(
                "/api/start_research",
                json={
                    "query": "How does queued persistence stay coherent?",
                    "model": "connected-test-model",
                },
                headers=csrf_headers(case.client),
            )

        assert response.status_code == 200, response.text[:500]
        payload = response.json()
        assert payload["status"] == ResearchStatus.QUEUED
        research_id = payload["research_id"]
        assert UUID(research_id).version == 4
        assert payload["queue_position"] == 1
        start_research_process.assert_not_called()

        persisted_session = db_manager.get_session(case.username)
        assert persisted_session is not None
        with persisted_session:
            histories = persisted_session.scalars(select(ResearchHistory)).all()
            queued_researches = persisted_session.scalars(
                select(QueuedResearch)
            ).all()
            task_metadata = persisted_session.scalars(
                select(TaskMetadata)
            ).all()
            queue_statuses = persisted_session.scalars(
                select(QueueStatus)
            ).all()

        assert len(histories) == 1
        assert str(histories[0].id) == research_id
        assert str(histories[0].status) == ResearchStatus.QUEUED
        assert len(queued_researches) == 1
        assert str(queued_researches[0].research_id) == research_id
        assert str(queued_researches[0].username) == case.username
        assert str(queued_researches[0].position) == "1"
        assert len(task_metadata) == 1
        assert str(task_metadata[0].task_id) == research_id
        assert str(task_metadata[0].status) == ResearchStatus.QUEUED
        assert str(task_metadata[0].task_type) == "research"
        assert str(task_metadata[0].priority) == "0"
        assert len(queue_statuses) == 1
        assert str(queue_statuses[0].active_tasks) == "0"
        assert str(queue_statuses[0].queued_tasks) == "1"
    finally:
        remove_active_research(active_research_id)