Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

45.1 KB
Raw Blame
"""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]