~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
"""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