~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
"""
Extended Tests for Database Manager
Phase 21: Database & Encryption - Database Manager Tests
Tests encrypted database management, connection pooling, and thread safety.
"""
import pytest
from unittest.mock import patch, MagicMock
from pathlib import Path
from local_deep_research.database.rekey_lock import RekeyEpochState
class TestDatabaseEncryption:
"""Tests for database encryption functionality"""
@patch("local_deep_research.database.encrypted_db.get_sqlcipher_module")
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_encryption_key_validation_valid(
self, mock_data_dir, mock_sqlcipher
):
"""Test valid encryption key is accepted"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
assert manager._is_valid_encryption_key("valid_password") is True
assert manager._is_valid_encryption_key("a") is True
assert manager._is_valid_encryption_key("complex!@#$%") is True
@patch("local_deep_research.database.encrypted_db.get_sqlcipher_module")
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_encryption_key_validation_invalid(
self, mock_data_dir, mock_sqlcipher
):
"""Test invalid encryption keys are rejected"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
assert manager._is_valid_encryption_key(None) is False
assert manager._is_valid_encryption_key("") is False
@patch("local_deep_research.database.encrypted_db.get_sqlcipher_module")
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_database_creation_invalid_password(
self, mock_data_dir, mock_sqlcipher
):
"""Test database creation fails with invalid password"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
with pytest.raises(ValueError, match="Invalid encryption key"):
manager.create_user_database("testuser", "")
with pytest.raises(ValueError, match="Invalid encryption key"):
manager.create_user_database("testuser", None)
@patch("local_deep_research.database.encrypted_db.get_sqlcipher_module")
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_database_open_invalid_password(
self, mock_data_dir, mock_sqlcipher
):
"""Test opening database fails with invalid password"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
with pytest.raises(ValueError, match="Invalid encryption key"):
manager.open_user_database("testuser", "")
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_sqlcipher_unavailable_fallback(self, mock_data_dir):
"""Test fallback when SQLCipher not available"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.dict("os.environ", {"LDR_ALLOW_UNENCRYPTED": "true"}):
with patch.object(
DatabaseManager,
"_check_encryption_available",
return_value=False,
):
manager = DatabaseManager()
assert manager.has_encryption is False
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_encryption_check_available(self, mock_data_dir):
"""Test encryption availability check"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
# With encryption available
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
assert manager.has_encryption is True
class TestConnectionPooling:
"""Tests for connection pooling functionality"""
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_pool_kwargs_static_pool(self, mock_data_dir):
"""Test pool kwargs for static pool (testing mode)"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.dict("os.environ", {"TESTING": "true"}):
with patch.object(
DatabaseManager,
"_check_encryption_available",
return_value=True,
):
manager = DatabaseManager()
kwargs = manager._get_pool_kwargs()
assert kwargs == {}
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_pool_kwargs_queue_pool(self, mock_data_dir):
"""Test pool kwargs for queue pool (production mode)"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.dict("os.environ", {}, clear=True):
with patch.object(
DatabaseManager,
"_check_encryption_available",
return_value=True,
):
manager = DatabaseManager()
manager._use_static_pool = False
kwargs = manager._get_pool_kwargs()
assert "pool_size" in kwargs
assert kwargs["pool_size"] == 20
assert kwargs["max_overflow"] == 40
assert kwargs["pool_timeout"] == 10
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_connection_storage(self, mock_data_dir):
"""Test connections are stored properly"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
# Mock engine
mock_engine = MagicMock()
manager.connections["testuser"] = mock_engine
assert "testuser" in manager.connections
assert manager.connections["testuser"] is mock_engine
class TestThreadSafety:
"""Tests for thread safety functionality"""
class TestDatabaseOperations:
"""Tests for database operations"""
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_get_session_no_connection(self, mock_data_dir):
"""Test get_session when no connection exists"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
result = manager.get_session("nonexistent_user")
assert result is None
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_get_session_with_connection(self, mock_data_dir):
"""Test get_session when connection exists"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
mock_engine = MagicMock()
epoch = "test-epoch"
manager._cache_connection(
"testuser",
manager._make_connection_cache_entry(
mock_engine, "password", epoch
),
)
# This will try to create a real session, mock the sessionmaker
with (
patch(
"local_deep_research.database.encrypted_db.read_rekey_epoch_state",
return_value=RekeyEpochState(epoch, None),
),
patch(
"local_deep_research.database.encrypted_db.sessionmaker"
) as mock_sm,
):
mock_session = MagicMock()
mock_sm.return_value = MagicMock(return_value=mock_session)
result = manager.get_session("testuser")
assert result is mock_session
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_close_user_database(self, mock_data_dir):
"""Test closing user database"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
mock_engine = MagicMock()
manager.connections["testuser"] = mock_engine
manager.close_user_database("testuser")
mock_engine.dispose.assert_called_once()
assert "testuser" not in manager.connections
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_get_memory_usage(self, mock_data_dir):
"""Test memory usage statistics"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
manager.connections["user1"] = MagicMock()
manager.connections["user2"] = MagicMock()
usage = manager.get_memory_usage()
assert usage["active_connections"] == 2
assert "thread_engines" not in usage
assert "estimated_memory_mb" in usage
class TestDatabaseIntegrity:
"""Tests for database integrity checking"""
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_check_integrity_no_connection(self, mock_data_dir):
"""Test integrity check when no connection exists"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
result = manager.check_database_integrity("nonexistent")
assert result is False
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_check_integrity_success(self, mock_data_dir):
"""Test successful integrity check"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
mock_engine = MagicMock()
mock_conn = MagicMock()
mock_engine.connect.return_value.__enter__ = MagicMock(
return_value=mock_conn
)
mock_engine.connect.return_value.__exit__ = MagicMock(
return_value=False
)
# Mock successful integrity checks
mock_conn.execute.side_effect = [
MagicMock(
fetchone=MagicMock(return_value=("ok",))
), # quick_check
MagicMock(
fetchone=MagicMock(return_value=(0, 0, 0))
), # wal_checkpoint(PASSIVE) - nothing left behind
iter([]), # cipher_integrity_check - no failures
]
epoch = "test-epoch"
manager._cache_connection(
"testuser",
manager._make_connection_cache_entry(
mock_engine, "password", epoch
),
)
with patch(
"local_deep_research.database.encrypted_db.read_rekey_epoch_state",
return_value=RekeyEpochState(epoch, None),
):
result = manager.check_database_integrity("testuser")
assert result is True
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_check_integrity_failure(self, mock_data_dir):
"""Test failed integrity check"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
mock_engine = MagicMock()
mock_conn = MagicMock()
mock_engine.connect.return_value.__enter__ = MagicMock(
return_value=mock_conn
)
mock_engine.connect.return_value.__exit__ = MagicMock(
return_value=False
)
# Mock failed integrity check
mock_conn.execute.return_value.fetchone.return_value = ("corrupt",)
# A trusted, epoch-validated entry: a bare ``connections[...]``
# plant has no epoch behind it, is detached on the first claim, and
# returns False before quick_check ever runs.
epoch = "test-epoch"
manager._cache_connection(
"testuser",
manager._make_connection_cache_entry(
mock_engine, "password", epoch
),
)
with patch(
"local_deep_research.database.encrypted_db.read_rekey_epoch_state",
return_value=RekeyEpochState(epoch, None),
):
result = manager.check_database_integrity("testuser")
assert result is False
assert mock_conn.execute.called, (
"the check never reached quick_check -- measuring the wrong branch"
)
class TestPasswordChange:
"""Tests for password change functionality"""
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_change_password_no_encryption(self, mock_data_dir):
"""Test password change when encryption not available"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=False
):
with patch.dict("os.environ", {"LDR_ALLOW_UNENCRYPTED": "true"}):
manager = DatabaseManager()
# Documented boolean contract for the static unencrypted
# fallback mode (tests/security/test_db_connection_
# unencrypted_mode.py pins the same).
assert manager.change_password("user", "old", "new") is False
class TestUserExists:
"""Tests for user existence check"""
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_user_exists_true(self, mock_data_dir):
"""Test user exists returns true"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
# Mock the internal method call
with patch.object(
manager, "user_exists", return_value=True
) as mock_method:
result = mock_method("testuser")
assert result is True
@patch("local_deep_research.database.encrypted_db.get_data_directory")
def test_user_exists_false(self, mock_data_dir):
"""Test user exists returns false"""
from local_deep_research.database.encrypted_db import DatabaseManager
mock_data_dir.return_value = Path("/tmp/test_data")
with patch.object(
DatabaseManager, "_check_encryption_available", return_value=True
):
manager = DatabaseManager()
with patch.object(
manager, "user_exists", return_value=False
) as mock_method:
result = mock_method("nonexistent")
assert result is False
class TestUserDatabasePath:
"""Tests for database path generation"""
def test_get_user_db_path(self):
"""Test user database path generation"""
from local_deep_research.database.encrypted_db import DatabaseManager
# Use a temp directory that exists
import tempfile
temp_dir = Path(tempfile.gettempdir())
with patch(
"local_deep_research.database.encrypted_db.get_data_directory",
return_value=temp_dir,
):
with patch.object(
DatabaseManager,
"_check_encryption_available",
return_value=True,
):
with patch(
"local_deep_research.database.encrypted_db.get_user_database_filename",
return_value="user_test.db",
):
manager = DatabaseManager()
path = manager._get_user_db_path("testuser")
# Path should include the filename
assert "user_test.db" in str(path)
class TestGlobalInstance:
"""Tests for global database manager instance"""
@pytest.mark.skip(reason="documentation/placeholder test - not implemented")
def test_global_instance_exists(self):
"""Test global db_manager instance is available"""
# This will fail if the module can't be imported
# but we mock the initialization
pass # Just a placeholder - actual import tested elsewhere