~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
"""Tests for security/file_integrity/integrity_manager.py."""
import pytest
import tempfile
from pathlib import Path
from unittest.mock import Mock, patch, MagicMock
class TestFileIntegrityManagerConstants:
"""Tests for FileIntegrityManager constants."""
def test_max_failures_per_file_is_reasonable(self):
"""Test that MAX_FAILURES_PER_FILE is set to a reasonable value."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
assert FileIntegrityManager.MAX_FAILURES_PER_FILE == 100
assert FileIntegrityManager.MAX_FAILURES_PER_FILE > 0
def test_max_total_failures_is_reasonable(self):
"""Test that MAX_TOTAL_FAILURES is set to a reasonable value."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
assert FileIntegrityManager.MAX_TOTAL_FAILURES == 10000
assert FileIntegrityManager.MAX_TOTAL_FAILURES > 0
class TestFileIntegrityManagerInit:
"""Tests for FileIntegrityManager initialization."""
def test_init_stores_username_and_password(self):
"""Test that init stores username and password."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("myuser", "mypass")
assert manager.username == "myuser"
assert manager.password == "mypass"
def test_init_creates_empty_verifiers_list(self):
"""Test that init creates an empty verifiers list."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
assert manager.verifiers == []
class TestNormalizePath:
"""Tests for _normalize_path method."""
def test_normalize_path_returns_string(self):
"""Test that _normalize_path returns a string."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
result = manager._normalize_path(Path("/tmp/test.txt"))
assert isinstance(result, str)
def test_normalize_path_resolves_to_absolute(self):
"""Test that _normalize_path resolves to absolute path."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
# Create actual temp file to test resolution
with tempfile.NamedTemporaryFile(delete=False) as f:
file_path = Path(f.name)
try:
result = manager._normalize_path(file_path)
assert result.startswith("/")
finally:
file_path.unlink()
class TestRegisterVerifier:
"""Tests for register_verifier method."""
def test_register_verifier_adds_to_list(self):
"""Test that register_verifier adds verifier to list."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class TestVerifier(BaseFileVerifier):
def should_verify(self, file_path):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
verifier = TestVerifier()
manager.register_verifier(verifier)
assert verifier in manager.verifiers
def test_register_multiple_verifiers(self):
"""Test that multiple verifiers can be registered."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class Verifier1(BaseFileVerifier):
def should_verify(self, file_path):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
class Verifier2(BaseFileVerifier):
def should_verify(self, file_path):
return True
def get_file_type(self):
return FileType.FAISS_INDEX
def allows_modifications(self):
return False
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
manager.register_verifier(Verifier1())
manager.register_verifier(Verifier2())
assert len(manager.verifiers) == 2
class TestGetVerifierForFile:
"""Tests for _get_verifier_for_file method."""
def test_returns_none_when_no_verifiers(self):
"""Test that None is returned when no verifiers registered."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
result = manager._get_verifier_for_file(Path("/some/file.txt"))
assert result is None
def test_returns_matching_verifier(self):
"""Test that the matching verifier is returned."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class TestVerifier(BaseFileVerifier):
def should_verify(self, file_path):
return file_path.suffix == ".pdf"
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
verifier = TestVerifier()
manager.register_verifier(verifier)
result = manager._get_verifier_for_file(Path("/test/file.pdf"))
assert result is verifier
class TestNeedsVerification:
"""Tests for _needs_verification method."""
def test_returns_true_for_missing_file(self):
"""Test that True is returned for missing files."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
mock_record = Mock()
mock_record.last_verified_at = None
result = manager._needs_verification(
mock_record, Path("/nonexistent/file.txt")
)
assert result is True
def test_returns_true_when_never_verified(self):
"""Test that True is returned when file was never verified."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
mock_record = Mock()
mock_record.last_verified_at = None
with tempfile.NamedTemporaryFile(delete=False) as f:
file_path = Path(f.name)
try:
result = manager._needs_verification(mock_record, file_path)
assert result is True
finally:
file_path.unlink()
class TestUpdateStats:
"""Tests for _update_stats method."""
def test_increments_total_verifications(self):
"""Test that total_verifications is incremented."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
mock_record = Mock()
mock_record.total_verifications = 5
mock_record.consecutive_successes = 0
mock_record.consecutive_failures = 0
manager._update_stats(mock_record, passed=True, session=mock_ctx)
assert mock_record.total_verifications == 6
def test_updates_consecutive_successes_on_pass(self):
"""Test that consecutive_successes is incremented on pass."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
mock_record = Mock()
mock_record.total_verifications = 0
mock_record.consecutive_successes = 3
mock_record.consecutive_failures = 1
manager._update_stats(mock_record, passed=True, session=mock_ctx)
assert mock_record.consecutive_successes == 4
assert mock_record.consecutive_failures == 0
def test_updates_consecutive_failures_on_fail(self):
"""Test that consecutive_failures is incremented on fail."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
manager = FileIntegrityManager("testuser")
mock_record = Mock()
mock_record.total_verifications = 0
mock_record.consecutive_successes = 5
mock_record.consecutive_failures = 0
manager._update_stats(mock_record, passed=False, session=mock_ctx)
assert mock_record.consecutive_failures == 1
assert mock_record.consecutive_successes == 0
class TestVerifyFile:
"""Tests for verify_file method."""
def test_verify_file_returns_result(self):
"""Test that verify_file returns a result."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class TestVerifier(BaseFileVerifier):
def should_verify(self, file_path):
return file_path.suffix == ".pdf"
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
mock_ctx.query.return_value.filter.return_value.first.return_value = None
manager = FileIntegrityManager("testuser")
manager.register_verifier(TestVerifier())
with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as f:
f.write(b"test pdf content")
file_path = Path(f.name)
try:
result = manager.verify_file(file_path)
# verify_file should return a verification result
assert result is not None
except (ImportError, AttributeError) as e:
# Expected if optional dependencies missing
pytest.skip(f"Skipping due to missing dependency: {e}")
except (OSError, IOError) as e:
# File system errors are acceptable in test environment
pytest.skip(f"Skipping due to file system error: {e}")
except TypeError as e:
# Mock comparison issues can occur in complex verification flows
pytest.skip(f"Skipping due to mock comparison issue: {e}")
finally:
file_path.unlink()
class TestMaxFailuresLimits:
"""Tests for max failures limits."""
def test_max_failures_per_file_constant(self):
"""Test MAX_FAILURES_PER_FILE is set."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
assert hasattr(FileIntegrityManager, "MAX_FAILURES_PER_FILE")
assert FileIntegrityManager.MAX_FAILURES_PER_FILE > 0
def test_max_total_failures_constant(self):
"""Test MAX_TOTAL_FAILURES is set."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
assert hasattr(FileIntegrityManager, "MAX_TOTAL_FAILURES")
assert FileIntegrityManager.MAX_TOTAL_FAILURES > 0
def test_max_total_failures_greater_than_per_file(self):
"""Test MAX_TOTAL_FAILURES is greater than MAX_FAILURES_PER_FILE."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
assert (
FileIntegrityManager.MAX_TOTAL_FAILURES
>= FileIntegrityManager.MAX_FAILURES_PER_FILE
)
# ---------- helper to build a manager without hitting the real DB ----------
def _make_manager():
"""Create a FileIntegrityManager with mocked DB session."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_session:
mock_ctx = MagicMock()
mock_session.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_session.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
mgr = FileIntegrityManager("testuser", "testpass")
return mgr
class TestDoVerification:
"""Tests for _do_verification (the core tamper-detection method)."""
def test_returns_false_when_file_missing(self, tmp_path):
"""Missing file is detected."""
mgr = _make_manager()
record = Mock(checksum="abc123")
missing = tmp_path / "no_such_file"
passed, reason = mgr._do_verification(record, missing, MagicMock())
assert passed is False
assert reason == "file_missing"
def test_returns_false_when_no_verifier(self, tmp_path):
"""No registered verifier → failure."""
mgr = _make_manager()
f = tmp_path / "file.xyz"
f.write_text("data")
record = Mock(checksum="abc")
passed, reason = mgr._do_verification(record, f, MagicMock())
assert passed is False
assert reason == "no_verifier"
def test_returns_false_on_checksum_mismatch(self, tmp_path):
"""Tampered file detected via checksum mismatch."""
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
mgr = _make_manager()
v = StubVerifier()
v.calculate_checksum = Mock(return_value="new_checksum")
mgr.register_verifier(v)
f = tmp_path / "file.bin"
f.write_text("data")
record = Mock(checksum="old_checksum")
passed, reason = mgr._do_verification(record, f, MagicMock())
assert passed is False
assert reason == "checksum_mismatch"
def test_returns_true_on_match_and_updates_mtime(self, tmp_path):
"""Valid file passes and mtime is updated."""
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
mgr = _make_manager()
v = StubVerifier()
v.calculate_checksum = Mock(return_value="matching")
mgr.register_verifier(v)
f = tmp_path / "file.bin"
f.write_text("data")
record = Mock(checksum="matching", file_mtime=0.0)
passed, reason = mgr._do_verification(record, f, MagicMock())
assert passed is True
assert reason is None
# mtime should have been updated to the file's actual mtime
assert record.file_mtime == f.stat().st_mtime
def test_checksum_calculation_exception(self, tmp_path):
"""Exception during checksum calculation is handled."""
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
mgr = _make_manager()
v = StubVerifier()
v.calculate_checksum = Mock(side_effect=IOError("disk error"))
mgr.register_verifier(v)
f = tmp_path / "file.bin"
f.write_text("data")
record = Mock(checksum="x")
passed, reason = mgr._do_verification(record, f, MagicMock())
assert passed is False
assert "checksum_calculation_failed" in reason
class TestRecordFile:
"""Tests for record_file (baseline creation / update)."""
def test_creates_new_record(self, tmp_path):
"""New file baseline is created."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
f = tmp_path / "new.bin"
f.write_text("hello")
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_gs:
mock_ctx = MagicMock()
mock_gs.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_gs.return_value.__exit__ = Mock(return_value=False)
# Init: cleanup returns 0
mock_ctx.query.return_value.count.return_value = 0
mgr = FileIntegrityManager("user", "pass")
v = StubVerifier()
v.calculate_checksum = Mock(return_value="abc123")
mgr.register_verifier(v)
# record_file path: no existing record
mock_ctx.query.return_value.filter_by.return_value.first.return_value = None
mgr.record_file(f)
# session.add should have been called with a new record
mock_ctx.add.assert_called_once()
mock_ctx.commit.assert_called()
def test_updates_existing_record(self, tmp_path):
"""Existing record is updated."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
f = tmp_path / "existing.bin"
f.write_text("updated content")
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_gs:
mock_ctx = MagicMock()
mock_gs.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_gs.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
mgr = FileIntegrityManager("user", "pass")
v = StubVerifier()
v.calculate_checksum = Mock(return_value="newchecksum")
mgr.register_verifier(v)
# Simulate existing record
existing = Mock()
existing.checksum = "oldchecksum"
mock_ctx.query.return_value.filter_by.return_value.first.return_value = existing
mgr.record_file(f)
assert existing.checksum == "newchecksum"
mock_ctx.commit.assert_called()
def test_resets_stale_verification_streaks(self, tmp_path):
"""Re-recording clears the streaks left by the previous baseline.
record_file installs the file's CURRENT checksum as the new
baseline, so the pass/fail streaks accumulated against the old
checksum describe a file that no longer exists. Kept, they are
charged to the new bytes: an index rebuilt after a quarantine
still reports the failure count of the one that was thrown away
(#4197 follow-up). Nothing in the codebase evaluates those
streaks against a threshold -- the only reader is get_file_stats,
which no production caller uses -- so the claim here is about
statistics describing the right bytes, not about a guard that
trips.
Only the streak pair is reset — total_verifications,
last_verified_at and last_verification_passed are history about
the path and must survive.
"""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
f = tmp_path / "recovered.bin"
f.write_text("rebuilt content")
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_gs:
mock_ctx = MagicMock()
mock_gs.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_gs.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
mgr = FileIntegrityManager("user", "pass")
v = StubVerifier()
v.calculate_checksum = Mock(return_value="freshchecksum")
mgr.register_verifier(v)
# The quarantined index had failed three verifications (and,
# before that, verified clean twice) against the OLD checksum;
# both streaks are stale once the bytes are rebuilt, while the
# historical columns keep describing the path.
existing = Mock()
existing.checksum = "corruptchecksum"
existing.consecutive_failures = 3
existing.consecutive_successes = 2
existing.total_verifications = 9
existing.last_verified_at = "sentinel-last-verified"
existing.last_verification_passed = False
mock_ctx.query.return_value.filter_by.return_value.first.return_value = existing
mgr.record_file(f)
assert existing.checksum == "freshchecksum"
assert existing.consecutive_failures == 0
assert existing.consecutive_successes == 0
assert existing.total_verifications == 9
assert existing.last_verified_at == "sentinel-last-verified"
assert existing.last_verification_passed is False
def test_raises_file_not_found(self, tmp_path):
"""Missing file raises FileNotFoundError."""
mgr = _make_manager()
with pytest.raises(FileNotFoundError):
mgr.record_file(tmp_path / "nope.bin")
def test_raises_no_verifier(self, tmp_path):
"""No matching verifier raises ValueError."""
mgr = _make_manager()
f = tmp_path / "file.xyz"
f.write_text("data")
with pytest.raises(ValueError, match="No verifier"):
mgr.record_file(f)
class TestUpdateChecksum:
"""Tests for update_checksum — the legitimate-modification re-baseline
path. ``update_checksum`` mirrors ``record_file``'s re-baseline
semantics, so it must apply the same streak reset (#7019)."""
def test_resets_stale_verification_streaks(self, tmp_path):
"""Re-baselining via update_checksum clears the streaks left by
the previous baseline, the parity shape #7014 added to
record_file.
update_checksum installs the file's CURRENT checksum as the new
baseline, so the pass/fail streaks accumulated against the old
checksum describe a file that no longer exists. Kept, they are
charged to the new bytes. The same argument #7014 applied to
record_file applies here — the only difference is the entry
point (legitimate modification vs initial recording) — so the
pair must be reset; the historical columns keep describing the
path and must survive.
"""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
f = tmp_path / "legitimate-mod.bin"
f.write_text("modified content")
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_gs:
mock_ctx = MagicMock()
mock_gs.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_gs.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = 0
mgr = FileIntegrityManager("user", "pass")
v = StubVerifier()
v.calculate_checksum = Mock(return_value="freshbaseline")
mgr.register_verifier(v)
# The pre-existing row was verified three times against
# the OLD baseline (and clean twice before that); both
# streaks are stale once the bytes are legitimately
# modified, while the historical columns keep describing
# the path.
existing = Mock()
existing.checksum = "oldbaseline"
existing.algorithm = "md5"
existing.consecutive_failures = 3
existing.consecutive_successes = 2
existing.total_verifications = 9
existing.last_verified_at = "sentinel-last-verified"
existing.last_verification_passed = False
mock_ctx.query.return_value.filter_by.return_value.first.return_value = existing
mgr.update_checksum(f)
assert existing.checksum == "freshbaseline"
# The digest was recomputed with the registered verifier, so
# the algorithm must be re-stamped to match (record_file
# parity): the old "md5" name must not survive under a
# sha256 digest.
assert existing.algorithm == "sha256"
assert existing.consecutive_failures == 0
assert existing.consecutive_successes == 0
assert existing.total_verifications == 9
assert existing.last_verified_at == "sentinel-last-verified"
assert existing.last_verification_passed is False
class TestLogFailure:
"""Tests for _log_failure (audit trail)."""
def test_creates_failure_record(self, tmp_path):
"""Failure record is added to session."""
from local_deep_research.security.file_integrity.base_verifier import (
BaseFileVerifier,
FileType,
)
class StubVerifier(BaseFileVerifier):
def should_verify(self, fp):
return True
def get_file_type(self):
return FileType.PDF
def allows_modifications(self):
return False
mgr = _make_manager()
v = StubVerifier()
v.calculate_checksum = Mock(return_value="actual_hash")
mgr.register_verifier(v)
f = tmp_path / "tampered.bin"
f.write_text("bad")
mock_session = MagicMock()
mock_session.query.return_value.filter_by.return_value.count.return_value = 0
record = Mock(id=1, checksum="expected_hash")
mgr._log_failure(record, f, "checksum_mismatch", mock_session)
mock_session.add.assert_called_once()
added_obj = mock_session.add.call_args[0][0]
assert added_obj.failure_reason == "checksum_mismatch"
assert added_obj.expected_checksum == "expected_hash"
assert added_obj.actual_checksum == "actual_hash"
class TestCleanupOldFailures:
"""Tests for _cleanup_old_failures (per-file)."""
def test_deletes_excess_failures(self):
"""Old failures beyond MAX_FAILURES_PER_FILE are deleted."""
mgr = _make_manager()
mock_session = MagicMock()
# Simulate 105 failures (limit is 100)
mock_session.query.return_value.filter_by.return_value.count.return_value = 105
old_failures = [Mock() for _ in range(5)]
mock_session.query.return_value.filter_by.return_value.order_by.return_value.limit.return_value.all.return_value = old_failures
record = Mock(id=1)
mgr._cleanup_old_failures(record, mock_session)
assert mock_session.delete.call_count == 5
class TestCleanupAllOldFailures:
"""Tests for cleanup_all_old_failures (global)."""
def test_under_limit_returns_zero(self):
"""No cleanup when under limit."""
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
) as mock_gs:
mock_ctx = MagicMock()
mock_gs.return_value.__enter__ = Mock(return_value=mock_ctx)
mock_gs.return_value.__exit__ = Mock(return_value=False)
mock_ctx.query.return_value.count.return_value = (
50 # well under 10000
)
mgr = FileIntegrityManager("user", "pass")
result = mgr.cleanup_all_old_failures()
assert result == 0
class TestIntegrityWriteNestedMode:
"""The _integrity_write helper routes the DB write correctly (#11 fix).
Standalone callers commit immediately; reentrant callers (the vector store
during apply(), which holds the caller's just-flushed, uncommitted rows on
the SAME thread-local session) run in a SAVEPOINT and DON'T commit, so a
failure can't discard the caller's rows and the record commits with the
caller's outer transaction. (Real SQLite savepoint isolation is exercised
end-to-end by the app's other begin_nested() call sites.)
"""
def _mgr(self):
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
):
return FileIntegrityManager("user", "pass")
def test_default_commits_no_savepoint(self):
mgr = self._mgr()
session = MagicMock()
with mgr._integrity_write(session, nested=False):
pass
session.commit.assert_called_once()
session.begin_nested.assert_not_called()
def test_nested_uses_savepoint_and_never_commits(self):
mgr = self._mgr()
session = MagicMock()
with mgr._integrity_write(session, nested=True):
pass
session.begin_nested.assert_called_once()
session.commit.assert_not_called()
def test_nested_failure_rolls_back_only_the_savepoint(self):
# A failure inside the nested write must propagate WITHOUT the helper
# committing or rolling back the caller's session — the savepoint
# context manager owns the scoped rollback.
mgr = self._mgr()
session = MagicMock()
with pytest.raises(RuntimeError):
with mgr._integrity_write(session, nested=True):
raise RuntimeError("transient integrity-write failure")
session.commit.assert_not_called()
session.rollback.assert_not_called()
class TestNestedWriteAvoidsFullRollback:
"""#7 regression: a failing nested integrity write must NOT let the
exception escape record_file's get_user_db_session block — otherwise that
context manager's except clause does a FULL session.rollback(), discarding
the caller's flushed rows (defeating the SAVEPOINT). The error must still
surface (so apply()'s retry/fail logic sees it)."""
def _mgr_with_verifier(self):
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
):
mgr = FileIntegrityManager("user", "pass")
verifier = MagicMock()
verifier.calculate_checksum.return_value = "abc"
verifier.get_algorithm.return_value = "sha256"
verifier.get_file_type.return_value = "faiss"
verifier.allows_modifications.return_value = False
mgr._get_verifier_for_file = Mock(return_value=verifier)
return mgr
def test_nested_failure_does_not_call_full_rollback(self, tmp_path):
import contextlib
f = tmp_path / "idx.faiss"
f.write_bytes(b"x")
mgr = self._mgr_with_verifier()
session = MagicMock()
session.query.return_value.filter_by.return_value.first.return_value = (
None # new-record path
)
# SAVEPOINT ctx manager that propagates (does not suppress) the error.
sp = MagicMock()
sp.__enter__ = Mock(return_value=None)
sp.__exit__ = Mock(return_value=False)
session.begin_nested.return_value = sp
# The write inside the SAVEPOINT fails.
session.add.side_effect = RuntimeError("integrity write failed")
full_rollbacks = []
@contextlib.contextmanager
def fake_gus(_u, _p):
try:
yield session
except Exception:
session.rollback() # the FULL rollback we must avoid
full_rollbacks.append(1)
raise
with (
# No live thread-local session for this (test-runner) thread --
# otherwise _session_for(nested=True) would use it instead of
# get_user_db_session, and this test would silently exercise the
# real thread-local session (whatever an earlier test in the
# full suite happened to leave behind on this thread) rather
# than the mocked session/fake_gus set up above. See
# TestSessionForNestedUsesLiveSession for that fallback path.
patch(
"local_deep_research.database.thread_local_session.get_current_thread_session",
return_value=None,
),
patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session",
fake_gus,
),
):
with pytest.raises(RuntimeError, match="integrity write failed"):
mgr.record_file(f, nested=True)
# The SAVEPOINT was used, and the outer full rollback NEVER fired.
session.begin_nested.assert_called_once()
assert full_rollbacks == []
session.commit.assert_not_called()
def test_standalone_failure_still_propagates_for_full_rollback(
self, tmp_path
):
import contextlib
f = tmp_path / "idx.faiss"
f.write_bytes(b"x")
mgr = self._mgr_with_verifier()
session = MagicMock()
session.query.return_value.filter_by.return_value.first.return_value = (
None
)
session.commit.side_effect = RuntimeError("commit failed")
full_rollbacks = []
@contextlib.contextmanager
def fake_gus(_u, _p):
try:
yield session
except Exception:
session.rollback()
full_rollbacks.append(1)
raise
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session",
fake_gus,
):
with pytest.raises(RuntimeError, match="commit failed"):
mgr.record_file(f, nested=False)
# Standalone: original behavior — the error propagates and the outer
# rollback DOES fire (nothing else is pending on that session).
assert full_rollbacks == [1]
class TestSessionForNestedUsesLiveSession:
"""#7 regression: in nested mode the integrity op must use the caller's
LIVE thread session (get_current_thread_session), NOT get_user_db_session —
re-entering the latter in a background context runs a re-acquisition
rollback that discards the caller's flushed-but-uncommitted rows."""
def _mgr(self):
from local_deep_research.security.file_integrity.integrity_manager import (
FileIntegrityManager,
)
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session"
):
return FileIntegrityManager("user", "pass")
def test_nested_uses_live_session_not_get_user_db_session(self):
import contextlib
mgr = self._mgr()
live = MagicMock(name="live_thread_session")
gus_calls = []
@contextlib.contextmanager
def fake_gus(_u, _p):
gus_calls.append(1)
yield MagicMock(name="reacquired")
with (
patch(
"local_deep_research.database.thread_local_session.get_current_thread_session",
return_value=live,
),
patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session",
fake_gus,
),
):
with mgr._session_for(nested=True) as s:
assert s is live
# get_user_db_session (the rollback-prone re-acquisition) was NOT used.
assert gus_calls == []
def test_standalone_uses_get_user_db_session(self):
import contextlib
mgr = self._mgr()
gus_calls = []
sentinel = MagicMock(name="normal_session")
@contextlib.contextmanager
def fake_gus(_u, _p):
gus_calls.append(1)
yield sentinel
with patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session",
fake_gus,
):
with mgr._session_for(nested=False) as s:
assert s is sentinel
assert gus_calls == [1]
def test_nested_falls_back_when_no_live_session(self):
import contextlib
mgr = self._mgr()
gus_calls = []
sentinel = MagicMock(name="fallback_session")
@contextlib.contextmanager
def fake_gus(_u, _p):
gus_calls.append(1)
yield sentinel
with (
patch(
"local_deep_research.database.thread_local_session.get_current_thread_session",
return_value=None,
),
patch(
"local_deep_research.security.file_integrity.integrity_manager.get_user_db_session",
fake_gus,
),
):
with mgr._session_for(nested=True) as s:
assert s is sentinel
assert gus_calls == [1]