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.3 KB
Raw Blame
"""``create_user_database`` must be serialized per user by the init lock.

Only ``open_user_database`` took ``_get_init_lock``. Two concurrent creates
for the same username could both pass the ``db_path.exists()`` guard; the
loser's orphaned-salt recovery then unlinked the winner's in-flight
``.db``/``.salt`` and both registrations failed (#6355). The exists-check,
salt and file creation, the migrations and the cache publish now all run
under the lock, exactly like the cold-open path.
"""

import threading

import pytest

from local_deep_research.database import encrypted_db
from local_deep_research.database.encrypted_db import DatabaseManager

PASSWORD = "CorrectHorse1!"


@pytest.fixture
def manager(tmp_path, monkeypatch):
    monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path))
    mgr = DatabaseManager()
    mgr.data_dir = tmp_path
    if not mgr.has_encryption:
        pytest.skip("SQLCipher not available; the salt path is encrypted-only")
    yield mgr
    mgr.close_all_databases()


def test_file_creation_runs_under_the_init_lock(manager, monkeypatch):
    username = "locked_create_user"
    lock = manager._get_init_lock(username)
    real_create_salt = encrypted_db.create_database_salt
    seen = []

    def observed_create_salt(db_path):
        seen.append(lock.locked())
        return real_create_salt(db_path)

    monkeypatch.setattr(
        encrypted_db, "create_database_salt", observed_create_salt
    )

    manager.create_user_database(username, PASSWORD)

    assert seen == [True]
    assert not lock.locked()


def test_migrations_run_under_the_init_lock(manager, monkeypatch):
    from local_deep_research.database import initialize

    username = "migrated_user"
    lock = manager._get_init_lock(username)
    real_initialize = initialize.initialize_database
    seen = []

    def observed_initialize(engine, session):
        seen.append(lock.locked())
        return real_initialize(engine, session)

    monkeypatch.setattr(initialize, "initialize_database", observed_initialize)

    manager.create_user_database(username, PASSWORD)

    assert seen == [True]
    assert not lock.locked()


def test_concurrent_creates_for_one_user_leave_a_usable_database(manager):
    username = "raced_user"
    barrier = threading.Barrier(2)
    outcomes: list = []

    def create():
        barrier.wait()
        try:
            outcomes.append(
                ("ok", manager.create_user_database(username, PASSWORD))
            )
        except ValueError as exc:
            outcomes.append(("error", str(exc)))

    threads = [threading.Thread(target=create) for _ in range(2)]
    for t in threads:
        t.start()
    for t in threads:
        t.join(timeout=60)

    kinds = sorted(kind for kind, _ in outcomes)
    assert kinds == ["error", "ok"], outcomes
    error_message = next(msg for kind, msg in outcomes if kind == "error")
    assert "already exists" in error_message

    db_path = manager._get_user_db_path(username)
    assert db_path.exists()
    manager.close_all_databases()
    assert manager.open_user_database(username, PASSWORD) is not None


@pytest.mark.parametrize("leftover_pending", [False, True])
def test_creation_mints_a_fresh_epoch_over_leftover_sidecars(
    manager, leftover_pending
):
    # Given epoch sidecars left beside a database path that no longer has
    # a database (an account removed without them, a partial restore)
    from local_deep_research.database.rekey_lock import read_rekey_epoch_state

    username = "recreated_user"
    db_path = manager._get_user_db_path(username)
    db_path.parent.mkdir(parents=True, exist_ok=True)
    stale_epoch = "00000000-0000-0000-0000-000000000001"
    db_path.with_name(f"{db_path.name}.rekey.epoch").write_text(
        stale_epoch, encoding="ascii"
    )
    if leftover_pending:
        db_path.with_name(f"{db_path.name}.rekey.pending").write_text(
            "00000000-0000-0000-0000-000000000002", encoding="ascii"
        )

    # When the account is registered again
    assert manager.create_user_database(username, PASSWORD) is not None

    # Then it gets a fresh stable epoch, not the earlier database's
    state = read_rekey_epoch_state(db_path)
    assert state.pending_epoch is None
    assert state.committed_epoch is not None
    assert state.committed_epoch != stale_epoch
    assert manager._connection_epochs[username] == state.committed_epoch