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.

66.7 KB
Raw Blame
"""Backup failures survive worker changes and reach the authenticated UI."""

from collections import OrderedDict
from concurrent.futures import ThreadPoolExecutor
from contextlib import contextmanager
from datetime import UTC, datetime, timedelta
import errno
import json
import os
from pathlib import Path
import subprocess
import sys
import threading
from unittest.mock import MagicMock

import pytest
from sqlalchemy import create_engine, inspect, select
from sqlalchemy.orm import Session

from local_deep_research.database import auth_db
from local_deep_research.database.backup import backup_status as status
from local_deep_research.database.backup.backup_executor import BackupExecutor
from local_deep_research.database.backup.backup_service import (
    BackupResult,
    BackupService,
)


def _status_engine(path):
    from local_deep_research.database.sqlcipher_compat import (
        connect_sqlcipher,
        get_sqlcipher_module,
    )

    def connect():
        connection = connect_sqlcipher(
            get_sqlcipher_module(), str(path), check_same_thread=False
        )
        connection.execute("PRAGMA key = \"x'" + bytes(range(32)).hex() + "'\"")
        connection.execute("PRAGMA cipher_compatibility = 4")
        return connection

    return create_engine("sqlite://", creator=connect)


@pytest.fixture
def status_db(tmp_path, monkeypatch):
    engines = {}

    @contextmanager
    def session(username):
        if username not in engines:
            engines[username] = _status_engine(tmp_path / (username + ".db"))
        engine = engines[username]
        with Session(engine) as db:
            yield db

    monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path))
    monkeypatch.setattr(status, "_encrypted_status_session", session)
    monkeypatch.setattr(status, "_recent", OrderedDict())
    engine = _status_engine(tmp_path / "alice.db")
    engines["alice"] = engine
    try:
        yield engine
    finally:
        for item in engines.values():
            item.dispose()


@pytest.fixture
def service(status_db, tmp_path, monkeypatch):
    from local_deep_research.database.backup import backup_service

    backup_dir = tmp_path / "backups"
    backup_dir.mkdir()
    monkeypatch.setattr(
        backup_service, "get_user_backup_directory", lambda username: backup_dir
    )
    monkeypatch.setattr(
        backup_service, "get_encrypted_database_path", lambda: tmp_path
    )
    return BackupService("alice", "not-a-real-password")


def test_no_attempt_is_distinct_from_success(status_db):
    assert status.get_backup_status("alice") == {
        "status_available": True,
        "last_attempt": None,
    }


def test_failure_is_persistent_and_scoped_to_account(status_db):
    status.record_backup_result(
        "alice", False, status.BackupError.INSUFFICIENT_SPACE
    )
    status._recent.clear()
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["success"] is False
    assert attempt["error_code"] == "insufficient_space"
    assert "disk space" in attempt["error"]
    assert datetime.fromisoformat(attempt["completed_at"]).tzinfo is not None
    assert status.get_backup_status("bob")["last_attempt"] is None


def test_another_process_can_read_the_encrypted_result(status_db, tmp_path):
    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    script = """
import json
from contextlib import contextmanager
from pathlib import Path
from sqlalchemy import create_engine
from sqlalchemy.orm import Session
from local_deep_research.database.sqlcipher_compat import connect_sqlcipher, get_sqlcipher_module
from local_deep_research.database.backup import backup_status as status
import os

def connect():
    connection = connect_sqlcipher(get_sqlcipher_module(), str(Path(os.environ['LDR_DATA_DIR']) / 'alice.db'))
    key_sql = chr(34) + "x" + chr(39) + bytes(range(32)).hex() + chr(39) + chr(34)
    connection.execute('PRAGMA key = ' + key_sql)
    connection.execute('PRAGMA cipher_compatibility = 4')
    return connection
engine = create_engine('sqlite://', creator=connect)
with engine.connect() as connection:
    connection.exec_driver_sql('SELECT * FROM user_backup_attempt_status').all()
@contextmanager
def session(username):
    with Session(engine) as db:
        yield db
status._encrypted_status_session = session
print(json.dumps(status.get_backup_status('alice')))
engine.dispose()
"""
    result = subprocess.run(
        [sys.executable, "-c", script],
        cwd=Path(__file__).resolve().parents[3],
        capture_output=True,
        text=True,
        timeout=45,
        check=False,
    )
    assert result.returncode == 0, result.stderr
    report = json.loads(result.stdout)
    assert report["status_available"] is True, result.stderr
    assert report["last_attempt"]["error_code"] == "verification"
    assert (
        not (tmp_path / "alice.db").read_bytes().startswith(b"SQLite format 3")
    )


def test_later_success_clears_failure(status_db):
    status.record_backup_result("alice", False)
    status.record_backup_result("alice", True)
    status._recent.clear()
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["success"] is True
    assert attempt["error"] is None
    assert attempt["error_code"] is None


def test_delayed_older_writer_cannot_replace_newer_result(
    status_db, monkeypatch
):
    now = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [now, now - timedelta(seconds=10)]
    monkeypatch.setattr(status, "datetime", clock)
    status.record_backup_result("alice", True)
    status.record_backup_result("alice", False)
    status._recent.clear()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


@pytest.mark.parametrize("purge_incomplete", [False, True])
@pytest.mark.parametrize(
    "write_order", ["simultaneous", "older_first", "newer_first"]
)
def test_concurrent_encrypted_writers_merge_attempt_and_purge(
    status_db, tmp_path, monkeypatch, purge_incomplete, write_order
):
    """Independent connections must retain both facts in either commit order.

    The simultaneous case releases both writers together; the ordered cases
    also pin the result without depending on which thread SQLite schedules.
    """
    status.record_backup_result("alice", True)  # Initialize the encrypted DB.
    start = datetime.now(UTC) + timedelta(minutes=1)
    observed = threading.local()
    clock = MagicMock()
    clock.now.side_effect = lambda tz: observed.at
    monkeypatch.setattr(status, "datetime", clock)
    barrier = threading.Barrier(2, timeout=15)
    ordinary_ready = threading.Event()
    committed = threading.Event()
    completed = []
    fallback = MagicMock(side_effect=AssertionError("unexpected fallback"))

    def write(name):
        observed.at = start + timedelta(seconds=name == "newer")
        engine = _status_engine(tmp_path / "alice.db")

        @contextmanager
        def session():
            with Session(engine) as db:
                if name == "newer":
                    ordinary_ready.set()
                barrier.wait()
                if (
                    write_order != "simultaneous"
                    and name != write_order.removesuffix("_first")
                ):
                    assert committed.wait(15), "first writer did not commit"
                yield db
                assert not db.in_transaction(), "status write was not committed"
                completed.append(name)
                committed.set()

        try:
            status.record_backup_result(
                "alice",
                name == "newer",
                None if name == "newer" else status.BackupError.VERIFICATION,
                purge_incomplete=purge_incomplete if name == "older" else None,
                direct_session=session,
            )
        finally:
            engine.dispose()

    with monkeypatch.context() as offline:
        offline.setattr(status, "_encrypted_status_session", fallback)
        with ThreadPoolExecutor(max_workers=2) as pool:
            newer = pool.submit(write, "newer")
            # Register the ordinary attempt before the purge is observed,
            # so it cannot carry that purge from their shared local cache.
            assert ordinary_ready.wait(15), "ordinary writer did not start"
            futures = [newer, pool.submit(write, "older")]
            for future in futures:
                future.result(timeout=30)
    fallback.assert_not_called()
    assert sorted(completed) == ["newer", "older"]
    if write_order != "simultaneous":
        assert completed[0] == write_order.removesuffix("_first")

    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["completed_at"] == start + timedelta(seconds=1)
    assert row["success"] is True
    assert row["error_code"] is None
    assert row["purge_checked_at"] == start
    assert row["purge_incomplete"] is purge_incomplete
    cached = status._recent[status._status_key("alice")]
    assert not status._is_pending(cached)
    assert cached["purge_incomplete"] is purge_incomplete
    status._recent.clear()
    report = status.get_backup_status("alice")
    assert report["status_available"] is True
    assert report["last_attempt"]["success"] is (not purge_incomplete)
    assert report["last_attempt"]["purge_incomplete"] is purge_incomplete


@pytest.mark.parametrize("purge_incomplete", [False, True])
def test_delayed_write_acknowledgement_keeps_a_concurrent_unwritten_purge(
    status_db, monkeypatch, purge_incomplete
):
    """A committed older write must not acknowledge a newer failed write.

    Hold the older connection after its real commit, while a new purge can
    only reach memory. Its state must survive the delayed acknowledgement
    and subsequently flush to the encrypted database without a new attempt.
    """
    status.record_backup_result(
        "alice", True, purge_incomplete=not purge_incomplete
    )
    start = datetime.now(UTC) + timedelta(minutes=1)
    observed = threading.local()
    observed.at = start + timedelta(seconds=1)
    clock = MagicMock()
    clock.now.side_effect = lambda tz: observed.at
    monkeypatch.setattr(status, "datetime", clock)
    committed = threading.Event()
    release = threading.Event()

    @contextmanager
    def delayed_session():
        with Session(status_db) as db:
            yield db
            assert not db.in_transaction()
            committed.set()
            assert release.wait(15), "older acknowledgement was not released"

    def older_write():
        observed.at = start
        status.record_backup_result(
            "alice", True, direct_session=delayed_session
        )

    unavailable = MagicMock(side_effect=OSError("test storage unavailable"))
    with monkeypatch.context() as offline:
        offline.setattr(status, "_encrypted_status_session", unavailable)
        with ThreadPoolExecutor(max_workers=1) as pool:
            future = pool.submit(older_write)
            try:
                assert committed.wait(15), "older write did not commit"
                assert not future.done()
                status.record_backup_result(
                    "alice",
                    True,
                    purge_incomplete=purge_incomplete,
                    direct_session=unavailable,
                )
            finally:
                release.set()
            future.result(timeout=30)
    assert unavailable.call_count == 2  # Both new-write paths failed.
    cached = status._recent[status._status_key("alice")]
    assert cached["completed_at"] == start + timedelta(seconds=1)
    assert cached["purge_incomplete"] is purge_incomplete
    assert cached["persisted"] is False
    assert cached["purge_persisted"] is False
    assert _stored_purge(status_db) is (not purge_incomplete)

    status.persist_pending_backup_status("alice")
    assert not status._is_pending(status._recent[status._status_key("alice")])
    status._recent.clear()
    report = status.get_backup_status("alice")
    assert report["status_available"] is True
    assert (
        report["last_attempt"]["completed_at"]
        == (start + timedelta(seconds=1)).isoformat()
    )
    assert report["last_attempt"]["purge_incomplete"] is purge_incomplete
    assert report["last_attempt"]["success"] is (not purge_incomplete)


def test_failed_status_write_keeps_local_failure_and_marks_unavailable(
    status_db, monkeypatch
):
    monkeypatch.setattr(
        status,
        "_encrypted_status_session",
        MagicMock(side_effect=OSError("private path")),
    )
    status.record_backup_result(
        "alice", False, status.BackupError.STORAGE_UNAVAILABLE
    )
    report = status.get_backup_status("alice")
    assert report["status_available"] is False
    assert report["last_attempt"]["error_code"] == "storage_unavailable"
    assert "private path" not in str(report)


def test_data_root_change_does_not_reuse_local_history(
    status_db, tmp_path, monkeypatch
):
    status.record_backup_result("alice", False)
    monkeypatch.setattr(
        status,
        "_status_key",
        lambda username: (str(tmp_path / "another"), username),
    )
    monkeypatch.setattr(
        status, "_encrypted_status_session", MagicMock(side_effect=OSError())
    )
    assert status.get_backup_status("alice") == {
        "status_available": False,
        "last_attempt": None,
    }


def test_local_fallback_is_bounded(status_db, monkeypatch):
    monkeypatch.setattr(status, "_RECENT_LIMIT", 2)
    monkeypatch.setattr(
        status, "_encrypted_status_session", MagicMock(side_effect=OSError())
    )
    for username in ("alice", "bob", "carol"):
        status.record_backup_result(username, False)
    assert len(status._recent) == 2
    assert status.get_backup_status("alice")["last_attempt"] is None
    assert status.get_backup_status("carol")["last_attempt"]["success"] is False


@pytest.mark.parametrize("operation", ["create_backup", "purge_and_refresh"])
def test_real_missing_database_failure_is_recorded(service, operation):
    result = getattr(service, operation)()
    assert result.success is False
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "source_missing"
    )


@pytest.mark.parametrize(
    ("operation", "step"),
    [
        ("create_backup", "_find_verified_backup"),
        ("purge_and_refresh", "_export_backup"),
    ],
)
def test_unexpected_failure_around_the_export_is_recorded_and_reraised(
    service, monkeypatch, operation, step
):
    """Both public operations record what the export itself never reports.

    The injected error stands in for any unexpected failure in the work
    around the export. It is not a model of an unreadable backup directory:
    ``Path.glob`` swallows that error, which is why the panel lists the
    directory with ``list_backup_files`` instead.
    """
    monkeypatch.setattr(
        service,
        step,
        MagicMock(side_effect=OSError(errno.EIO, "private-path")),
    )
    with pytest.raises(OSError):
        getattr(service, operation)()
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["error_code"] == "storage_unavailable"
    assert "private-path" not in str(attempt)


def test_every_error_code_has_a_fixed_message():
    assert set(status._ERROR_MESSAGES) == set(status.BackupError)


@pytest.mark.nonroot
def test_password_change_on_an_unlistable_directory_is_recorded_as_failed(
    service, monkeypatch, loguru_caplog
):
    """``Path.glob`` finds no old backup in a directory the server can write
    but not list, so nothing is deleted. The fresh backup is still written,
    but the attempt must not read as a clean success."""
    if os.name != "posix" or os.geteuid() == 0:
        pytest.skip("permission bits are not enforced for root or on Windows")
    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    service.backup_dir.chmod(0o300)
    try:
        with loguru_caplog.at_level("WARNING"):
            result = service.purge_and_refresh()
    finally:
        service.backup_dir.chmod(0o700)
    assert result.success is True
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["success"] is False
    assert attempt["error_code"] == "purge_incomplete"
    assert "Old-password backups may remain" in attempt["error"]
    assert any(
        record.levelname == "WARNING"
        and "Could not list old backups" in record.getMessage()
        for record in loguru_caplog.records
    )


def test_password_change_on_a_listable_directory_is_a_clean_success(
    service, monkeypatch
):
    old_backup = service.backup_dir / "ldr_backup_20260101_000000.db"
    old_backup.write_bytes(b"x")
    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert not old_backup.exists()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def test_password_change_without_a_backup_directory_is_a_clean_success(
    service, monkeypatch
):
    """A missing directory holds no old backups, so nothing is left behind."""
    service.backup_dir.rmdir()
    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def test_real_low_disk_space_failure_is_recorded(service, monkeypatch):
    from local_deep_research.database.backup import backup_service

    service.db_path.write_bytes(b"source")
    monkeypatch.setattr(
        backup_service.shutil, "disk_usage", lambda path: MagicMock(free=0)
    )
    result = service.create_backup(force=True)
    assert result.success is False
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "insufficient_space"
    )


def test_verified_daily_reuse_does_not_erase_a_failed_new_backup(
    service, monkeypatch
):
    status.record_backup_result("alice", False)
    monkeypatch.setattr(
        service,
        "_find_verified_backup",
        lambda paths: (Path("existing.db"), 100),
    )
    assert service.create_backup().success is True
    assert status.get_backup_status("alice")["last_attempt"]["success"] is False


def test_new_success_records_recovery(service, monkeypatch):
    status.record_backup_result("alice", False)
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.create_backup(force=True).success is True
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def test_unexpected_error_never_persists_exception_contents(
    service, monkeypatch, status_db
):
    secret = "password-and-private-path-must-not-be-recorded"
    monkeypatch.setattr(
        service, "_export_backup", MagicMock(side_effect=RuntimeError(secret))
    )
    with pytest.raises(RuntimeError):
        service.create_backup(force=True)
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
        assert secret not in str(dict(row))
    assert secret not in str(status.get_backup_status("alice"))


def test_status_storage_failure_does_not_fail_successful_backup(
    service, monkeypatch
):
    monkeypatch.setattr(
        status, "_encrypted_status_session", MagicMock(side_effect=OSError())
    )
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.create_backup(force=True).success is True


def test_constructor_failure_is_reported(status_db, monkeypatch):
    from local_deep_research.database.backup import backup_service

    monkeypatch.setattr(
        backup_service,
        "get_user_backup_directory",
        MagicMock(side_effect=PermissionError(errno.EACCES, "private-path")),
    )
    with pytest.raises(PermissionError):
        BackupService("alice", "private-password")
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "permission_denied"
    )


def test_queue_failure_is_reported_and_can_be_retried(status_db):
    # Construct an isolated executor without starting its singleton thread pool.
    executor = object.__new__(BackupExecutor)
    executor._pending_backups = set()
    executor._pending_lock = threading.Lock()
    executor._executor = MagicMock()
    executor._executor.submit.side_effect = RuntimeError("executor closed")
    with pytest.raises(RuntimeError):
        executor.submit_backup("alice", "private-password")
    assert not executor._pending_backups
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "scheduling"
    )
    executor._executor.submit.side_effect = None
    assert executor.submit_backup("alice", "private-password") is True


@pytest.fixture
def api_client(status_db, service, monkeypatch):
    from fastapi import FastAPI
    from fastapi.testclient import TestClient
    from starlette.middleware.sessions import SessionMiddleware
    from local_deep_research.web.routers import settings
    from local_deep_research.web.dependencies.auth import require_auth

    app = FastAPI()
    app.add_middleware(SessionMiddleware, secret_key="backup-status-test")
    app.include_router(settings.router)
    app.dependency_overrides[require_auth] = lambda: "alice"
    monkeypatch.setattr(
        settings, "_get_setting_from_session", lambda *args: True
    )
    from local_deep_research.config import paths

    monkeypatch.setattr(
        paths, "get_user_backup_directory", lambda username: service.backup_dir
    )
    with TestClient(app) as client:
        yield client


def test_real_backup_failure_reaches_authenticated_endpoint(
    service, api_client
):
    assert service.create_backup().success is False
    response = api_client.get("/settings/api/backup-status")
    assert response.status_code == 200
    body = response.json()
    assert body["listing_available"] is True
    assert body["last_attempt"]["error_code"] == "source_missing"
    assert "not-a-real-password" not in response.text
    assert str(service.db_path) not in response.text


def test_unusable_backup_directory_still_reports_the_failure(
    service, api_client, monkeypatch
):
    """``get_user_backup_directory`` raises when it cannot create or restrict
    the directory, for example when another account owns it."""
    from local_deep_research.config import paths

    assert service.create_backup().success is False
    monkeypatch.setattr(
        paths,
        "get_user_backup_directory",
        MagicMock(side_effect=PermissionError()),
    )
    response = api_client.get("/settings/api/backup-status")
    assert response.status_code == 200
    assert response.json()["listing_available"] is False
    assert response.json()["count"] is None
    assert response.json()["last_attempt"]["success"] is False


@pytest.mark.nonroot
def test_unlistable_directory_is_not_reported_as_empty(service, api_client):
    """A directory the server can write but not list is not "no backups yet".

    ``Path.glob`` returns [] for it without raising, so this needs a real
    permission denial, which root and Windows do not enforce.
    """
    if os.name != "posix" or os.geteuid() == 0:
        pytest.skip("permission bits are not enforced for root or on Windows")
    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    (service.backup_dir / "ldr_backup_20260101_000000.db").write_bytes(b"x")
    service.backup_dir.chmod(0o300)
    try:
        assert list(service.backup_dir.glob("ldr_backup_*.db")) == []
        response = api_client.get("/settings/api/backup-status")
    finally:
        service.backup_dir.chmod(0o700)
    assert response.status_code == 200
    body = response.json()
    assert body["listing_available"] is False
    assert body["count"] is None
    assert body["last_attempt"]["error_code"] == "verification"


def test_unreadable_settings_are_not_blamed_on_the_directory(
    service, api_client, monkeypatch
):
    from local_deep_research.web.routers import settings

    (service.backup_dir / "ldr_backup_20260101_000000.db").write_bytes(b"x")
    monkeypatch.setattr(
        settings,
        "_get_setting_from_session",
        MagicMock(side_effect=RuntimeError("settings database unavailable")),
    )
    response = api_client.get("/settings/api/backup-status")
    assert response.status_code == 200
    body = response.json()
    assert body["enabled"] is None
    assert body["listing_available"] is True
    assert body["count"] == 1
    assert "settings database unavailable" not in response.text


def test_list_backup_files_matches_only_backup_databases(tmp_path):
    from local_deep_research.database.backup.backup_service import (
        list_backup_files,
    )

    wanted = tmp_path / "ldr_backup_20260101_000000.db"
    for name in (
        wanted.name,
        "ldr_backup_20260101_000000.db.salt",
        "ldr_backup_20260101_000000.db.tmp",
        "notes.db",
    ):
        (tmp_path / name).write_bytes(b"x")
    assert list_backup_files(tmp_path) == [wanted]
    with pytest.raises(FileNotFoundError):
        list_backup_files(tmp_path / "missing")


def test_endpoint_reads_authenticated_owner_only(service, api_client):
    from local_deep_research.web.dependencies.auth import require_auth

    assert service.create_backup().success is False
    api_client.app.dependency_overrides[require_auth] = lambda: "bob"
    assert (
        api_client.get("/settings/api/backup-status").json()["last_attempt"]
        is None
    )


@pytest.mark.real_session_check
def test_endpoint_requires_authentication(api_client):
    api_client.app.dependency_overrides.clear()
    assert api_client.get("/settings/api/backup-status").status_code == 401


def test_encrypted_status_is_not_a_plaintext_sqlite_database(
    status_db, tmp_path
):
    import sqlite3

    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    data = (tmp_path / "alice.db").read_bytes()
    assert b"verification" not in data
    assert b"alice" not in data
    with sqlite3.connect(tmp_path / "alice.db") as connection:
        with pytest.raises(sqlite3.DatabaseError):
            connection.execute(
                "SELECT * FROM user_backup_attempt_status"
            ).fetchall()


def test_deletion_failure_remains_visible_after_a_successful_backup(
    service, monkeypatch
):
    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    monkeypatch.setattr(
        service,
        "_remove_backup_files",
        MagicMock(side_effect=PermissionError()),
    )
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert old.exists()
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )
    assert service.create_backup(force=True).success is True
    status._recent.clear()
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_only_a_verified_new_purge_clears_the_warning(service, monkeypatch):
    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    remove = service._remove_backup_files
    monkeypatch.setattr(
        service,
        "_remove_backup_files",
        MagicMock(side_effect=PermissionError()),
    )
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    service.purge_and_refresh()
    monkeypatch.setattr(service, "_remove_backup_files", remove)
    service.purge_and_refresh()
    status._recent.clear()
    assert not old.exists()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


@pytest.mark.parametrize("encrypted, connected", [(True, False), (False, True)])
def test_connection_unavailable_never_reopens_or_uses_plaintext_storage(
    monkeypatch, tmp_path, encrypted, connected
):
    from local_deep_research.database.encrypted_db import db_manager

    monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path))
    monkeypatch.setattr(status, "_recent", OrderedDict())
    monkeypatch.setattr(db_manager, "has_encryption", encrypted)
    monkeypatch.setattr(
        db_manager, "is_user_connected", lambda username: connected
    )
    get_session = MagicMock()
    monkeypatch.setattr(db_manager, "get_session", get_session)
    auth_session = MagicMock(
        side_effect=AssertionError("No plaintext status store")
    )
    monkeypatch.setattr(auth_db, "auth_db_session", auth_session)
    status.record_backup_result("alice", False)
    report = status.get_backup_status("alice")
    assert report["status_available"] is False
    assert report["last_attempt"]["success"] is False
    get_session.assert_not_called()
    auth_session.assert_not_called()
    assert not list(tmp_path.rglob("*.db"))


def test_purge_removes_orphaned_salt_and_temporary_pairs(service, monkeypatch):
    names = [
        "ldr_backup_20260101_000000.db.salt",
        "ldr_backup_20260101_000001.db.tmp",
        "ldr_backup_20260101_000001.db.tmp.salt",
        "ldr_backup_20260101_000002.db.damaged-20261018_170000_123456",
        "ldr_backup_20260101_000002.db.damaged-20261018_170000_123456.salt",
        "ldr_backup_20260101_000003.db.damaged-20261018_170000_123456.salt",
    ]
    for name in names:
        (service.backup_dir / name).write_bytes(b"old-pair")
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    service.purge_and_refresh()
    assert not any((service.backup_dir / name).exists() for name in names)
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def test_production_session_path_uses_only_the_existing_encrypted_engine(
    tmp_path, monkeypatch
):
    from local_deep_research.database.encrypted_db import db_manager

    engine = _status_engine(tmp_path / "existing-user.db")
    monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path))
    monkeypatch.setattr(status, "_recent", OrderedDict())
    monkeypatch.setattr(db_manager, "has_encryption", True)
    monkeypatch.setattr(
        db_manager, "is_user_connected", lambda username: username == "alice"
    )
    get_session = MagicMock(side_effect=lambda username: Session(engine))
    monkeypatch.setattr(db_manager, "get_session", get_session)
    auth_session = MagicMock(
        side_effect=AssertionError("No plaintext status store")
    )
    monkeypatch.setattr(auth_db, "auth_db_session", auth_session)
    try:
        status.record_backup_result(
            "alice", False, status.BackupError.VERIFICATION
        )
        status._recent.clear()
        report = status.get_backup_status("alice")
        assert report["status_available"] is True
        assert report["last_attempt"]["error_code"] == "verification"
        assert get_session.call_count == 2
        auth_session.assert_not_called()
        assert not (tmp_path / "ldr_auth.db").exists()
        assert not (tmp_path / "encrypted_databases").exists()
    finally:
        engine.dispose()


@pytest.mark.parametrize("existing_row", [False, True])
def test_disconnected_purge_warning_survives_connected_ordinary_success(
    status_db, monkeypatch, existing_row
):
    if existing_row:
        status.record_backup_result("alice", True)
    with monkeypatch.context() as offline:
        offline.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        status.record_backup_result("alice", True, purge_incomplete=True)
        status.record_backup_result("alice", True)
    status.record_backup_result("alice", True)
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["success"] is True
    assert row["purge_incomplete"] is True
    status._recent.clear()
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_disconnected_verified_clear_survives_connected_ordinary_success(
    status_db, monkeypatch
):
    status.record_backup_result("alice", True, purge_incomplete=True)
    with monkeypatch.context() as offline:
        offline.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        status.record_backup_result("alice", True, purge_incomplete=False)
        status.record_backup_result("alice", True)
    status.record_backup_result("alice", True)
    status._recent.clear()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def test_ordinary_success_does_not_revive_a_persisted_warning_cleared_elsewhere(
    status_db, monkeypatch
):
    start = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [start, start + timedelta(seconds=2)]
    monkeypatch.setattr(status, "datetime", clock)
    status.record_backup_result("alice", True, purge_incomplete=True)
    with status_db.begin() as connection:
        connection.execute(
            status._attempts.update()
            .where(status._attempts.c.username == "alice")
            .values(
                purge_incomplete=False,
                completed_at=start + timedelta(seconds=1),
            )
        )
    status.record_backup_result("alice", True)
    status._recent.clear()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def _old_backup_that_cannot_be_removed(service, monkeypatch):
    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    monkeypatch.setattr(
        service,
        "_remove_backup_files",
        MagicMock(side_effect=PermissionError()),
    )
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    # Next login's scheduled backup finds today's verified backup and
    # returns early, recording no new attempt.
    monkeypatch.setattr(
        service,
        "_find_verified_backup",
        lambda paths: (Path("existing.db"), 100),
    )
    return old


def test_purge_after_engine_disposal_survives_daily_reuse_and_restart(
    service, status_db, monkeypatch
):
    """#7443 B4: change_password() disposes the user's engine before the
    purge runs, so the open-engine status path is unavailable. The purge
    result must still be persisted, using the password the purge holds."""
    _old_backup_that_cannot_be_removed(service, monkeypatch)

    @contextmanager
    def password_session():
        with Session(status_db) as db:
            yield db

    opened_with_password = MagicMock(side_effect=password_session)
    monkeypatch.setattr(
        service, "_password_status_session", opened_with_password
    )
    with monkeypatch.context() as disposed:
        disposed.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        assert service.purge_and_refresh().success is True
    opened_with_password.assert_called_once_with()
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is True

    assert service.create_backup().success is True
    status._recent.clear()  # server restart
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_daily_reuse_persists_a_purge_observed_while_disconnected(
    service, status_db, monkeypatch
):
    """#7443 B4: if even the purge's own connection fails, the daily-reuse
    early return at the next login writes the pending observation before a
    restart can discard it."""
    _old_backup_that_cannot_be_removed(service, monkeypatch)
    monkeypatch.setattr(
        service,
        "_password_status_session",
        MagicMock(side_effect=RuntimeError()),
    )
    with monkeypatch.context() as disposed:
        disposed.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        assert service.purge_and_refresh().success is True
    # Precondition: nothing could be persisted while disconnected.
    assert not inspect(status_db).has_table(status._attempts.name)

    assert service.create_backup().success is True
    status._recent.clear()  # server restart
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_pending_purge_survives_a_newer_ordinary_success_from_another_worker(
    status_db, monkeypatch
):
    """#7443 R1: worker A observes an incomplete purge while the database is
    closed; worker B then persists a newer ordinary success. When A writes
    its older observation, the attempt stays B's but the purge flag stays."""
    start = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [start, start + timedelta(seconds=5)]
    monkeypatch.setattr(status, "datetime", clock)
    worker_a = status._recent
    with monkeypatch.context() as disconnected:
        disconnected.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        status.record_backup_result("alice", True, purge_incomplete=True)

    monkeypatch.setattr(status, "_recent", OrderedDict())  # worker B
    status.record_backup_result("alice", True)

    monkeypatch.setattr(status, "_recent", worker_a)
    status.get_backup_status("alice")  # A writes its pending observation

    monkeypatch.setattr(status, "_recent", OrderedDict())  # any worker
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["error_code"] == "purge_incomplete"
    assert attempt["completed_at"] == (start + timedelta(seconds=5)).isoformat()


def test_directory_with_a_backup_name_does_not_hold_the_purge_warning(
    service, monkeypatch
):
    """#7443 R2: the purge never deletes a directory, so counting one as a
    remaining old-password backup would keep the warning up forever."""
    decoy = service.backup_dir / "ldr_backup_20260101_000000.db"
    decoy.mkdir()
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert decoy.is_dir()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def _assert_purge_incomplete_recorded(status_db):
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is True
    status._recent.clear()
    report = status.get_backup_status("alice")["last_attempt"]
    assert report["success"] is False
    assert "Old-password backups may remain" in report["error"]


def test_purge_counts_old_backups_it_cannot_inspect(
    service, status_db, monkeypatch
):
    """#7443 B1: in a directory that can be listed but not searched, every
    lstat fails with EACCES. On Python 3.14 the Path.is_* helpers turn that
    into False, which made every old backup look absent and recorded the
    purge as verified clean while the old-password files remained."""
    from local_deep_research.database.backup import backup_service

    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    real_lstat = os.lstat

    def unsearchable(path, *args, **kwargs):
        if Path(path).parent == service.backup_dir:
            raise PermissionError(errno.EACCES, "Permission denied")
        return real_lstat(path, *args, **kwargs)

    monkeypatch.setattr(backup_service.os, "lstat", unsearchable)
    # Removing an entry also needs search permission on its directory.
    monkeypatch.setattr(
        service,
        "_remove_backup_files",
        MagicMock(side_effect=PermissionError(errno.EACCES, "denied")),
    )
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert old.exists()
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is True


@pytest.mark.nonroot
@pytest.mark.parametrize("mode", [0o400, 0o600])
def test_purge_in_a_real_unsearchable_directory_is_incomplete(
    service, status_db, monkeypatch, mode
):
    """#7443 B1, against the real filesystem: names listable, entries not."""
    if os.name != "posix" or os.geteuid() == 0:
        pytest.skip("permission bits are not enforced for root or on Windows")
    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    service.backup_dir.chmod(mode)
    try:
        assert service.purge_and_refresh().success is True
    finally:
        service.backup_dir.chmod(0o700)
    assert old.exists()
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is True


def test_purge_error_before_the_backup_is_recorded_as_incomplete(
    service, status_db, monkeypatch
):
    """#7443 B1: on Python 3.12/3.13 an inspection error escapes the purge
    before the fresh backup. The user's engine is already disposed, so the
    incomplete purge must still be written through the password session."""
    (service.backup_dir / "ldr_backup_20260101_000000.db").write_bytes(b"x")
    monkeypatch.setattr(
        service,
        "_is_purgeable",
        MagicMock(side_effect=PermissionError(errno.EACCES, "denied")),
    )

    @contextmanager
    def password_session():
        with Session(status_db) as db:
            yield db

    opened_with_password = MagicMock(side_effect=password_session)
    monkeypatch.setattr(
        service, "_password_status_session", opened_with_password
    )
    with monkeypatch.context() as disposed:
        disposed.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        with pytest.raises(PermissionError):
            service.purge_and_refresh()
    opened_with_password.assert_called_once_with()
    _assert_purge_incomplete_recorded(status_db)


def test_purge_tie_or_step_back_keeps_incomplete_in_the_database(
    status_db, monkeypatch
):
    """#7443: on an equal purge timestamp, or a clock that stepped back,
    "incomplete" must win over "clean" in the stored merge."""
    start = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [start, start, start - timedelta(seconds=1)]
    monkeypatch.setattr(status, "datetime", clock)
    status.record_backup_result("alice", True, purge_incomplete=False)
    status.record_backup_result("alice", True, purge_incomplete=True)
    status._recent.clear()
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )
    status.record_backup_result("alice", True, purge_incomplete=False)
    status._recent.clear()
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_purge_step_back_keeps_incomplete_in_the_local_observation(
    status_db, monkeypatch
):
    """#7443: the same rule for the in-memory observation, used while the
    encrypted database is closed."""
    start = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [start, start - timedelta(seconds=1)]
    monkeypatch.setattr(status, "datetime", clock)
    monkeypatch.setattr(
        status,
        "_encrypted_status_session",
        MagicMock(side_effect=RuntimeError()),
    )
    status.record_backup_result("alice", True, purge_incomplete=False)
    status.record_backup_result("alice", True, purge_incomplete=True)
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_real_password_status_session_on_a_keyed_database(
    tmp_path, monkeypatch
):
    """#7443: the real _password_status_session body, on a real SQLCipher
    database: it writes with the right password, writes nothing with a
    wrong one, and never creates a missing database."""
    from local_deep_research.database.sqlcipher_compat import (
        get_sqlcipher_module,
    )

    try:
        get_sqlcipher_module()
    except ImportError:
        pytest.skip("SQLCipher driver not installed")
    from local_deep_research.database.backup import backup_service
    from local_deep_research.database.sqlcipher_utils import (
        create_sqlcipher_connection,
    )

    monkeypatch.setenv("LDR_DATA_DIR", str(tmp_path))
    monkeypatch.setattr(status, "_recent", OrderedDict())
    monkeypatch.setattr(
        status,
        "_encrypted_status_session",
        MagicMock(side_effect=RuntimeError()),
    )
    monkeypatch.setattr(
        backup_service,
        "get_user_backup_directory",
        lambda username: tmp_path / "backups",
    )
    monkeypatch.setattr(
        backup_service, "get_encrypted_database_path", lambda: tmp_path
    )
    right = BackupService("alice", "right-password")
    connection = create_sqlcipher_connection(
        str(right.db_path), "right-password", creation_mode=True
    )
    connection.execute("CREATE TABLE marker (id INTEGER)")
    connection.commit()
    connection.close()

    def stored_purge_flags():
        conn = create_sqlcipher_connection(str(right.db_path), "right-password")
        try:
            tables = conn.execute(
                "SELECT name FROM sqlite_master WHERE name = ?",
                (status._attempts.name,),
            ).fetchall()
            if not tables:
                return []
            return conn.execute(
                "SELECT purge_incomplete FROM user_backup_attempt_status"
            ).fetchall()
        finally:
            conn.close()

    wrong = BackupService("alice", "wrong-password")
    status.record_backup_result(
        "alice",
        True,
        purge_incomplete=True,
        direct_session=wrong._password_status_session,
    )
    assert stored_purge_flags() == []

    status.record_backup_result(
        "alice",
        True,
        purge_incomplete=True,
        direct_session=right._password_status_session,
    )
    assert stored_purge_flags() == [(1,)]

    missing = BackupService("bob", "any-password")
    status.record_backup_result(
        "bob",
        True,
        purge_incomplete=True,
        direct_session=missing._password_status_session,
    )
    assert not missing.db_path.exists()


@pytest.mark.parametrize("deferred_write", ["status_read", "daily_reuse"])
def test_deferred_write_does_not_revive_a_newer_clean_purge(
    service, status_db, monkeypatch, deferred_write
):
    """#7443: worker A stores an incomplete purge, then fails to store an
    ordinary attempt; worker B stores a newer verified clean purge. A's
    later deferred write must not resend its stale stored purge state,
    which the step-back rule would let win over B's clean purge."""
    start = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [
        start,
        start + timedelta(seconds=5),
        start + timedelta(seconds=10),
    ]
    monkeypatch.setattr(status, "datetime", clock)
    status.record_backup_result("alice", True, purge_incomplete=True)
    with monkeypatch.context() as offline:
        offline.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        status.record_backup_result("alice", False)
    worker_a = status._recent

    monkeypatch.setattr(status, "_recent", OrderedDict())  # worker B
    status.record_backup_result("alice", True, purge_incomplete=False)

    monkeypatch.setattr(status, "_recent", worker_a)
    if deferred_write == "status_read":
        status.get_backup_status("alice")
    else:
        monkeypatch.setattr(
            service,
            "_find_verified_backup",
            lambda paths: (Path("existing.db"), 100),
        )
        assert service.create_backup().success is True

    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is False
    assert row["purge_checked_at"] == start + timedelta(seconds=10)


def test_unwritten_purge_behind_a_written_attempt_is_still_flushed(
    status_db, monkeypatch
):
    """#7443: an observation is pending while EITHER fact is unwritten. A
    written attempt merged over an unwritten purge state must not make the
    purge state look written."""
    with monkeypatch.context() as offline:
        offline.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        status.record_backup_result("alice", True, purge_incomplete=True)
    key = status._status_key("alice")
    # A newer attempt that is already stored (e.g. read back from the
    # database) is merged over the cached, unwritten purge state.
    status._remember(
        key,
        {
            "completed_at": datetime.now(UTC) + timedelta(seconds=1),
            "success": True,
            "error_code": None,
            "persisted": True,
            "purge_incomplete": False,
            "purge_checked_at": None,
            "purge_persisted": True,
        },
    )
    status.persist_pending_backup_status("alice")
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is True


def test_purge_result_uses_the_password_session_before_the_engine(
    service, status_db, monkeypatch
):
    """#7443: the purge runs under the rekey sidecar, which the open-engine
    status path waits on; the password session must be tried first."""

    @contextmanager
    def password_session():
        with Session(status_db) as db:
            yield db

    monkeypatch.setattr(
        service,
        "_password_status_session",
        MagicMock(side_effect=password_session),
    )
    engine_path = MagicMock(side_effect=AssertionError("engine status path"))
    monkeypatch.setattr(status, "_encrypted_status_session", engine_path)
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    engine_path.assert_not_called()
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is False


def test_backup_appearing_after_the_first_listing_keeps_the_purge_incomplete(
    service, monkeypatch
):
    """#7443: only the post-purge re-listing sees a file written after the
    deletion pass enumerated the directory."""
    from local_deep_research.database.backup import backup_service

    late = service.backup_dir / "ldr_backup_20260101_000000.db"
    real_listing = backup_service.list_backup_files
    listings = []

    def listing(directory, *, include_auxiliary=False):
        listings.append(directory)
        if len(listings) == 1:
            return []  # The deletion pass saw an empty directory...
        late.write_bytes(b"old-key-backup")  # ...then a file appeared.
        return real_listing(directory, include_auxiliary=include_auxiliary)

    monkeypatch.setattr(backup_service, "list_backup_files", listing)
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert len(listings) == 2
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_failed_unlink_keeps_the_purge_incomplete_on_its_own(
    service, monkeypatch
):
    """#7443: a failed deletion is incomplete even when the re-listing
    (here made to come back empty) would not show the file."""
    from local_deep_research.database.backup import backup_service

    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    real_listing = backup_service.list_backup_files
    listings = []

    def listing(directory, *, include_auxiliary=False):
        listings.append(directory)
        if len(listings) == 1:
            return real_listing(directory, include_auxiliary=include_auxiliary)
        return []

    monkeypatch.setattr(backup_service, "list_backup_files", listing)
    monkeypatch.setattr(
        service,
        "_remove_backup_files",
        MagicMock(side_effect=PermissionError(errno.EACCES, "denied")),
    )
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert len(listings) == 2
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def _listings(monkeypatch, first, second):
    """Make the purge's two directory listings behave as given."""
    from local_deep_research.database.backup import backup_service

    real_listing = backup_service.list_backup_files
    calls = []

    def listing(directory, *, include_auxiliary=False):
        calls.append(directory)
        outcome = first if len(calls) == 1 else second
        if isinstance(outcome, BaseException):
            raise outcome
        if outcome == "real":
            return real_listing(directory, include_auxiliary=include_auxiliary)
        return outcome

    monkeypatch.setattr(backup_service, "list_backup_files", listing)
    return calls


def test_unreadable_post_purge_listing_keeps_the_purge_incomplete(
    service, monkeypatch
):
    """#7443 B2: the deletion pass saw nothing, the old file is still there,
    and only the re-listing's error says the purge cannot be confirmed."""
    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    calls = _listings(monkeypatch, [], PermissionError(errno.EACCES, "denied"))
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    result = service.purge_and_refresh()
    assert result.success is True
    assert result.purge_incomplete is True
    assert len(calls) == 2
    assert old.exists()
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_unreadable_first_listing_alone_keeps_the_purge_incomplete(
    service, monkeypatch
):
    """#7443 B2: the first listing fails and the re-listing comes back empty;
    only the first listing's error proves nothing was confirmed removed."""
    calls = _listings(monkeypatch, PermissionError(errno.EACCES, "denied"), [])
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    result = service.purge_and_refresh()
    assert result.purge_incomplete is True
    assert len(calls) == 2
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_unparseable_stored_row_is_replaced_by_the_next_write(status_db):
    """#7443 R9: one corrupt value must not block every later status write.
    The stored purge flag survives the replacement."""
    from sqlalchemy import text

    status.record_backup_result("alice", True, purge_incomplete=True)
    with status_db.begin() as connection:
        connection.execute(
            text(
                "UPDATE user_backup_attempt_status SET completed_at = "
                "'not a date'"
            )
        )
    status._recent.clear()
    status.record_backup_result("alice", False, status.BackupError.VERIFICATION)
    status._recent.clear()
    report = status.get_backup_status("alice")
    assert report["status_available"] is True
    assert report["last_attempt"]["error_code"] == "verification"
    assert "Old-password backups may remain" in report["last_attempt"]["error"]


def test_report_flags_a_pending_purge_behind_another_failure_code(status_db):
    """#7443: a failed attempt keeps its own error code while a purge is
    pending, so the report must carry the purge state explicitly."""
    status.record_backup_result(
        "alice",
        False,
        status.BackupError.PERMISSION_DENIED,
        purge_incomplete=True,
    )
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["error_code"] == "permission_denied"
    assert attempt["purge_incomplete"] is True

    status.record_backup_result("alice", False, status.BackupError.UNKNOWN)
    status.record_backup_result("alice", True, purge_incomplete=False)
    status.record_backup_result("alice", False, status.BackupError.UNKNOWN)
    attempt = status.get_backup_status("alice")["last_attempt"]
    assert attempt["error_code"] == "unknown"
    assert attempt["purge_incomplete"] is False


def _corrupt(engine, assignments):
    from sqlalchemy import text

    with engine.begin() as connection:
        connection.execute(
            text(f"UPDATE user_backup_attempt_status SET {assignments}")
        )


def _stored_purge(engine):
    with engine.connect() as connection:
        return connection.execute(
            select(status._attempts.c.purge_incomplete)
        ).scalar_one()


def _carry_unwritten_purge(monkeypatch, purge_incomplete):
    """Observe a purge while the database is closed (cache only)."""
    with monkeypatch.context() as offline:
        offline.setattr(
            status,
            "_encrypted_status_session",
            MagicMock(side_effect=RuntimeError()),
        )
        status.record_backup_result(
            "alice", True, purge_incomplete=purge_incomplete
        )


@pytest.mark.parametrize(
    ("stored", "carried", "expected"),
    [
        # An unreadable flag with no purge state to replace it: incomplete.
        ("'x'", None, True),
        # Falsy text/blob and out-of-range integers are not verified flags.
        ("''", None, True),
        ("x''", None, True),
        ("2", None, True),
        ("-1", None, True),
        # An unreadable flag replaced by the clean purge this write carries.
        ("'x'", False, False),
        ("''", False, False),
        # A readable flag survives the repair as it was stored.
        ("0", None, False),
        ("1", None, True),
    ],
)
def test_repair_of_an_unreadable_row_keeps_or_replaces_the_purge_flag(
    status_db, monkeypatch, stored, carried, expected
):
    """#7443 R4: each branch of the purge-flag repair is pinned."""
    status.record_backup_result("alice", True, purge_incomplete=False)
    _corrupt(
        status_db,
        f"completed_at = 'not a date', purge_incomplete = {stored}",
    )
    status._recent.clear()
    if carried is not None:
        _carry_unwritten_purge(monkeypatch, carried)
    status.record_backup_result("alice", True)
    assert _stored_purge(status_db) is expected


def test_repair_keeps_a_newer_merged_purge_over_an_older_carried_one(
    status_db, monkeypatch
):
    """#7443 R2: worker A stored "incomplete" at T5; worker B carries an
    older clean purge from T3. The upsert keeps A's state; repairing a
    corrupt attempt column must not then replace it with B's."""
    start = datetime.now(UTC)
    clock = MagicMock()
    clock.now.side_effect = [
        start + timedelta(seconds=3),
        start + timedelta(seconds=5),
        start + timedelta(seconds=6),
    ]
    monkeypatch.setattr(status, "datetime", clock)
    _carry_unwritten_purge(monkeypatch, False)  # worker B, at T3
    worker_b = status._recent
    monkeypatch.setattr(status, "_recent", OrderedDict())  # worker A
    status.record_backup_result("alice", True, purge_incomplete=True)
    _corrupt(status_db, "completed_at = 'not a date'")
    monkeypatch.setattr(status, "_recent", worker_b)
    status.record_backup_result("alice", True)  # B writes, at T6
    with status_db.connect() as connection:
        row = connection.execute(select(status._attempts)).mappings().one()
    assert row["purge_incomplete"] is True
    assert row["purge_checked_at"] == start + timedelta(seconds=5)


def test_repair_lets_a_carried_purge_replace_an_unreadable_timestamp(
    status_db, monkeypatch
):
    """#7443 R3: the merge cannot order against an unreadable purge
    timestamp, so a verified clean purge this write carries decides."""
    status.record_backup_result("alice", True, purge_incomplete=True)
    _corrupt(status_db, "purge_checked_at = 'zzz'")
    status._recent.clear()
    status.record_backup_result("alice", True, purge_incomplete=False)
    assert _stored_purge(status_db) is False
    status._recent.clear()
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True


def _offline(monkeypatch):
    """Make every open-engine status write and read fail."""
    monkeypatch.setattr(
        status, "_encrypted_status_session", MagicMock(side_effect=OSError())
    )


def _cached_users():
    return [username for _root, username in status._recent]


def test_bounded_cache_evicts_written_entries_before_pending_ones(
    status_db, monkeypatch
):
    """#8048: an unwritten purge warning outlives newer entries that are
    already in the database or hold only an unwritten attempt."""
    monkeypatch.setattr(status, "_RECENT_LIMIT", 2)
    with monkeypatch.context() as offline:
        _offline(offline)
        status.record_backup_result("alice", True, purge_incomplete=True)
    status.record_backup_result("bob", True)  # Written, so evicted first.
    _offline(monkeypatch)
    status.record_backup_result("carol", False)
    assert _cached_users() == ["alice", "carol"]
    status.record_backup_result("dave", False)  # Unwritten attempts next.
    assert _cached_users() == ["alice", "dave"]
    assert (
        status.get_backup_status("alice")["last_attempt"]["error_code"]
        == "purge_incomplete"
    )


def test_bounded_cache_keeps_the_newest_pending_purges(status_db, monkeypatch):
    """#8048: when every entry holds an unwritten purge, the bound still
    holds and the oldest of them goes first."""
    monkeypatch.setattr(status, "_RECENT_LIMIT", 2)
    _offline(monkeypatch)
    for username in ("alice", "bob", "carol"):
        status.record_backup_result(username, True, purge_incomplete=True)
    assert _cached_users() == ["bob", "carol"]


_SECRET = "private-detail-8048"


def _assert_logged_type_name_only(caplog, line, type_name):
    assert f"{line} ({type_name})" in caplog.text
    assert _SECRET not in caplog.text


def test_direct_session_failure_logs_only_the_exception_type(
    status_db, loguru_caplog_full
):
    """#8048: the status log lines name the exception type, never its text,
    which can hold a path or a database value."""

    @contextmanager
    def direct():
        raise OSError(_SECRET)
        yield

    with loguru_caplog_full.at_level("DEBUG"):
        status.record_backup_result("alice", False, direct_session=direct)
    _assert_logged_type_name_only(
        loguru_caplog_full, "Direct backup status session unusable", "OSError"
    )


def test_unsaved_status_logs_only_the_exception_type(
    status_db, monkeypatch, loguru_caplog_full
):
    monkeypatch.setattr(
        status,
        "_encrypted_status_session",
        MagicMock(side_effect=OSError(_SECRET)),
    )
    with loguru_caplog_full.at_level("DEBUG"):
        status.record_backup_result("alice", True, purge_incomplete=True)
        status.persist_pending_backup_status("alice")
        status.get_backup_status("alice")
    for line in (
        "Could not save encrypted backup status",
        "Pending backup status not yet saved",
        "Could not read encrypted backup status",
    ):
        _assert_logged_type_name_only(loguru_caplog_full, line, "OSError")


def test_unformattable_status_logs_only_the_exception_type(
    status_db, monkeypatch, loguru_caplog_full
):
    monkeypatch.setattr(
        status, "_report", MagicMock(side_effect=KeyError(_SECRET))
    )
    with loguru_caplog_full.at_level("DEBUG"):
        status.get_backup_status("alice")
    _assert_logged_type_name_only(
        loguru_caplog_full, "Could not format backup status", "KeyError"
    )


def test_row_repair_logs_only_the_exception_type(status_db, loguru_caplog_full):
    """The parse error of a corrupt row quotes the stored value."""
    status.record_backup_result("alice", True)
    _corrupt(status_db, f"completed_at = '{_SECRET}'")
    status._recent.clear()
    with loguru_caplog_full.at_level("DEBUG"):
        status.record_backup_result("alice", False)
    _assert_logged_type_name_only(
        loguru_caplog_full,
        "Repairing an unreadable backup status row",
        "ValueError",
    )


@pytest.mark.parametrize("kind", ["symlink", "outside"])
def test_purge_containment_recheck_holds_without_is_purgeable(
    service, tmp_path, monkeypatch, kind
):
    """#8048: _is_purgeable already rejects a symlink or an entry outside
    the backup directory. With it stubbed to accept everything, the
    containment re-check in the purge loop must still leave both in place."""
    from local_deep_research.database.backup import backup_service

    outside = tmp_path / "outside"
    outside.mkdir()
    target = outside / "ldr_backup_20260101_000000.db"
    target.write_bytes(b"not-a-backup")
    if kind == "symlink":
        entry = service.backup_dir / "ldr_backup_20260101_000001.db"
        try:
            entry.symlink_to(target)
        except OSError:
            pytest.skip("symlinks are not available")
    else:
        entry = target
        real_listing = backup_service.list_backup_files

        def listing(directory, *, include_auxiliary=False):
            found = real_listing(directory, include_auxiliary=include_auxiliary)
            return [*found, target]

        monkeypatch.setattr(backup_service, "list_backup_files", listing)
    monkeypatch.setattr(service, "_is_purgeable", lambda path: True)

    assert service._purge_old_backup_files() is True
    assert entry.exists(follow_symlinks=False)
    assert target.read_bytes() == b"not-a-backup"


def test_purge_removes_a_symlinked_salt_without_touching_its_target(
    service, tmp_path, monkeypatch
):
    """#8048: a salt companion that is a symlink is removed as a link; the
    file it points to is left alone."""
    old = service.backup_dir / "ldr_backup_20260101_000000.db"
    old.write_bytes(b"old-key-backup")
    target = tmp_path / "elsewhere.salt"
    target.write_bytes(b"keep")
    salt = service.backup_dir / "ldr_backup_20260101_000000.db.salt"
    try:
        salt.symlink_to(target)
    except OSError:
        pytest.skip("symlinks are not available")
    monkeypatch.setattr(
        service, "_export_backup", lambda **kwargs: BackupResult(success=True)
    )
    assert service.purge_and_refresh().success is True
    assert not old.exists()
    assert not salt.exists(follow_symlinks=False)
    assert target.read_bytes() == b"keep"
    assert status.get_backup_status("alice")["last_attempt"]["success"] is True