~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 web/auth/session_manager.py
Tests cover:
- SessionManager class initialization with mocked security defaults
- Session creation, validation, and destruction
- Session cleanup and expiration using datetime mocking
- User session management and session info formatting
"""
import datetime
from datetime import UTC
from unittest.mock import patch
import pytest
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
MOCK_SESSION_TIMEOUT_HOURS = 2
MOCK_REMEMBER_ME_DAYS = 30
# Patch target for the security helper used inside session_manager.py
_SECURITY_DEFAULT_PATCH = (
"local_deep_research.web.auth.session_manager.get_security_default"
)
def _security_default_side_effect(key, default):
"""Return controlled timeout values for tests."""
mapping = {
"security.session_timeout_hours": MOCK_SESSION_TIMEOUT_HOURS,
"security.session_remember_me_days": MOCK_REMEMBER_ME_DAYS,
}
return mapping.get(key, default)
@pytest.fixture()
def manager():
"""Create a SessionManager with mocked security defaults."""
with patch(
_SECURITY_DEFAULT_PATCH, side_effect=_security_default_side_effect
):
from local_deep_research.web.auth.session_manager import (
SessionManager,
)
return SessionManager()
# ===========================================================================
# Initialization
# ===========================================================================
class TestSessionManagerInit:
"""Tests for SessionManager initialization."""
def test_init_creates_empty_sessions_dict(self, manager):
"""Should initialize with an empty sessions dict."""
assert manager.sessions == {}
def test_init_sets_session_timeout_from_security_defaults(self, manager):
"""Should set session_timeout based on mocked security default."""
assert manager.session_timeout == datetime.timedelta(
hours=MOCK_SESSION_TIMEOUT_HOURS
)
def test_init_sets_remember_me_timeout_from_security_defaults(
self, manager
):
"""Should set remember_me_timeout based on mocked security default."""
assert manager.remember_me_timeout == datetime.timedelta(
days=MOCK_REMEMBER_ME_DAYS
)
def test_init_calls_get_security_default(self):
"""Should call get_security_default for both timeout settings."""
with patch(_SECURITY_DEFAULT_PATCH) as mock_get:
mock_get.return_value = 1
from local_deep_research.web.auth.session_manager import (
SessionManager,
)
SessionManager()
assert mock_get.call_count == 2
call_keys = [c.args[0] for c in mock_get.call_args_list]
assert "security.session_timeout_hours" in call_keys
assert "security.session_remember_me_days" in call_keys
def test_init_uses_custom_timeout_values(self):
"""Should honour non-default timeout values from security settings."""
custom_hours = 8
custom_days = 7
def custom_side_effect(key, default):
if key == "security.session_timeout_hours":
return custom_hours
if key == "security.session_remember_me_days":
return custom_days
return default
with patch(_SECURITY_DEFAULT_PATCH, side_effect=custom_side_effect):
from local_deep_research.web.auth.session_manager import (
SessionManager,
)
mgr = SessionManager()
assert mgr.session_timeout == datetime.timedelta(hours=custom_hours)
assert mgr.remember_me_timeout == datetime.timedelta(days=custom_days)
# ===========================================================================
# Session creation
# ===========================================================================
class TestCreateSession:
"""Tests for create_session method."""
def test_returns_string_token(self, manager):
"""Should return a session ID that is a non-empty string."""
session_id = manager.create_session("alice")
assert isinstance(session_id, str)
assert len(session_id) > 0
def test_returns_unique_tokens(self, manager):
"""Should generate unique session IDs across multiple calls."""
ids = {manager.create_session(f"user{i}") for i in range(50)}
assert len(ids) == 50
def test_stores_session_data(self, manager):
"""Should store session entry in the sessions dict."""
sid = manager.create_session("bob")
assert sid in manager.sessions
data = manager.sessions[sid]
assert data["username"] == "bob"
assert data["remember_me"] is False
assert isinstance(data["created_at"], datetime.datetime)
assert isinstance(data["last_access"], datetime.datetime)
def test_default_remember_me_is_false(self, manager):
"""Should default remember_me to False."""
sid = manager.create_session("carol")
assert manager.sessions[sid]["remember_me"] is False
def test_remember_me_true(self, manager):
"""Should store remember_me=True when requested."""
sid = manager.create_session("dave", remember_me=True)
assert manager.sessions[sid]["remember_me"] is True
def test_timestamps_are_utc_aware(self, manager):
"""Should set created_at and last_access as UTC-aware datetimes."""
sid = manager.create_session("eve")
data = manager.sessions[sid]
assert data["created_at"].tzinfo is not None
assert data["last_access"].tzinfo is not None
def test_multiple_sessions_same_user(self, manager):
"""Should allow multiple sessions for the same username."""
sid1 = manager.create_session("frank")
sid2 = manager.create_session("frank")
assert sid1 != sid2
assert sid1 in manager.sessions
assert sid2 in manager.sessions
assert manager.sessions[sid1]["username"] == "frank"
assert manager.sessions[sid2]["username"] == "frank"
# ===========================================================================
# Session validation
# ===========================================================================
class TestValidateSession:
"""Tests for validate_session method."""
def test_returns_username_for_valid_session(self, manager):
"""Should return the username for a freshly created session."""
sid = manager.create_session("grace")
assert manager.validate_session(sid) == "grace"
def test_returns_none_for_unknown_session_id(self, manager):
"""Should return None for a session_id that was never created."""
assert manager.validate_session("totally-bogus-id") is None
def test_returns_none_for_expired_regular_session(self, manager):
"""Should return None when regular session has exceeded session_timeout."""
fixed_now = datetime.datetime(2026, 1, 1, 12, 0, 0, tzinfo=UTC)
expired_time = fixed_now - datetime.timedelta(
hours=MOCK_SESSION_TIMEOUT_HOURS, seconds=1
)
with patch(
"local_deep_research.web.auth.session_manager.datetime"
) as mock_dt:
mock_dt.datetime.now.return_value = fixed_now
mock_dt.timedelta = datetime.timedelta
mock_dt.UTC = UTC
sid = manager.create_session("hank")
# Manually set last_access to an expired time
manager.sessions[sid]["last_access"] = expired_time
result = manager.validate_session(sid)
assert result is None
def test_destroys_expired_session(self, manager):
"""Should remove the session from self.sessions when it expires."""
sid = manager.create_session("ivy")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
manager.validate_session(sid)
assert sid not in manager.sessions
def test_returns_none_for_expired_remember_me_session(self, manager):
"""Should return None for remember_me session past remember_me_timeout."""
sid = manager.create_session("jack", remember_me=True)
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(days=MOCK_REMEMBER_ME_DAYS + 1)
assert manager.validate_session(sid) is None
assert sid not in manager.sessions
def test_remember_me_survives_regular_timeout(self, manager):
"""A remember_me session should still be valid after regular timeout elapses."""
sid = manager.create_session("kate", remember_me=True)
# 3 hours ago exceeds the 2-hour regular timeout but not 30-day remember_me
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
result = manager.validate_session(sid)
assert result == "kate"
def test_updates_last_access_on_valid_session(self, manager):
"""Should update last_access to current time when session is valid."""
sid = manager.create_session("leo")
old_access = manager.sessions[sid]["last_access"]
# Nudge time forward slightly
with patch(
"local_deep_research.web.auth.session_manager.datetime"
) as mock_dt:
future = old_access + datetime.timedelta(minutes=10)
mock_dt.datetime.now.return_value = future
mock_dt.timedelta = datetime.timedelta
mock_dt.UTC = UTC
result = manager.validate_session(sid)
assert result == "leo"
assert manager.sessions[sid]["last_access"] == future
def test_does_not_update_last_access_for_unknown_session(self, manager):
"""Calling validate on unknown id should not create any session entry."""
manager.validate_session("nonexistent")
assert "nonexistent" not in manager.sessions
def test_expired_boundary_exact_timeout(self, manager):
"""Session at exactly the timeout boundary should still be valid (uses >)."""
fixed_now = datetime.datetime(2026, 6, 15, 12, 0, 0, tzinfo=UTC)
boundary_time = fixed_now - datetime.timedelta(
hours=MOCK_SESSION_TIMEOUT_HOURS
)
sid = manager.create_session("mia")
manager.sessions[sid]["last_access"] = boundary_time
with patch(
"local_deep_research.web.auth.session_manager.datetime"
) as mock_dt:
mock_dt.datetime.now.return_value = fixed_now
mock_dt.timedelta = datetime.timedelta
mock_dt.UTC = UTC
# Source code checks ``now - last_access > timeout``,
# so exactly equal should still be valid.
result = manager.validate_session(sid)
assert result == "mia"
# ===========================================================================
# Session destruction
# ===========================================================================
class TestDestroySession:
"""Tests for destroy_session method."""
def test_removes_session(self, manager):
"""Should remove the session from self.sessions."""
sid = manager.create_session("nina")
assert sid in manager.sessions
manager.destroy_session(sid)
assert sid not in manager.sessions
def test_noop_for_unknown_session_id(self, manager):
"""Should not raise when destroying an unknown session_id."""
manager.destroy_session("does-not-exist") # no exception
def test_does_not_affect_other_sessions(self, manager):
"""Destroying one session should leave others intact."""
sid1 = manager.create_session("oscar")
sid2 = manager.create_session("oscar")
manager.destroy_session(sid1)
assert sid1 not in manager.sessions
assert sid2 in manager.sessions
# ===========================================================================
# Cleanup expired sessions
# ===========================================================================
class TestCleanupExpiredSessions:
"""Tests for cleanup_expired_sessions method."""
def test_removes_expired_regular_sessions(self, manager):
"""Should remove regular sessions that have exceeded session_timeout."""
sid = manager.create_session("quinn")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
manager.cleanup_expired_sessions()
assert sid not in manager.sessions
def test_keeps_valid_regular_sessions(self, manager):
"""Should keep regular sessions that have not expired."""
sid = manager.create_session("rosa")
manager.cleanup_expired_sessions()
assert sid in manager.sessions
def test_removes_only_expired_sessions(self, manager):
"""Should remove expired sessions while keeping valid ones."""
expired_sid = manager.create_session("stale_user")
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
valid_sid = manager.create_session("fresh_user")
manager.cleanup_expired_sessions()
assert expired_sid not in manager.sessions
assert valid_sid in manager.sessions
def test_removes_multiple_expired_sessions(self, manager):
"""Should remove all expired sessions in a single cleanup pass."""
expired_ids = []
for i in range(5):
sid = manager.create_session(f"expired_{i}")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
expired_ids.append(sid)
valid_sid = manager.create_session("keeper")
manager.cleanup_expired_sessions()
for eid in expired_ids:
assert eid not in manager.sessions
assert valid_sid in manager.sessions
def test_respects_remember_me_timeout(self, manager):
"""Should keep remember_me sessions that exceed regular timeout but not remember_me_timeout."""
sid = manager.create_session("tina", remember_me=True)
# 3 hours ago: past regular timeout but within remember_me timeout
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
manager.cleanup_expired_sessions()
assert sid in manager.sessions
def test_removes_expired_remember_me_sessions(self, manager):
"""Should remove remember_me sessions that exceed remember_me_timeout."""
sid = manager.create_session("uma", remember_me=True)
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(days=MOCK_REMEMBER_ME_DAYS + 1)
manager.cleanup_expired_sessions()
assert sid not in manager.sessions
def test_handles_empty_sessions(self, manager):
"""Should not raise when there are no sessions."""
manager.cleanup_expired_sessions() # no exception
assert manager.sessions == {}
def test_mixed_regular_and_remember_me(self, manager):
"""Should correctly handle a mix of regular and remember_me sessions."""
# Expired regular
s1 = manager.create_session("u1")
manager.sessions[s1]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
# Valid remember_me (same age as s1 but has longer timeout)
s2 = manager.create_session("u2", remember_me=True)
manager.sessions[s2]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
# Expired remember_me
s3 = manager.create_session("u3", remember_me=True)
manager.sessions[s3]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(days=MOCK_REMEMBER_ME_DAYS + 1)
# Valid regular
s4 = manager.create_session("u4")
manager.cleanup_expired_sessions()
assert s1 not in manager.sessions # expired regular
assert s2 in manager.sessions # still valid remember_me
assert s3 not in manager.sessions # expired remember_me
assert s4 in manager.sessions # still valid regular
# The Flask ``socket_service.SocketIOService`` this used to patch was deleted
# by the migration, so these three tests errored on an unresolvable patch
# target -- meaning the idle-expiry socket-teardown behaviour they exist to
# guard had NO working coverage at exactly the time that teardown was itself
# broken (it imported the same dead module). Retargeted onto the ASGI layer's
# module-level ``disconnect_session``.
_DISCONNECT_SESSION_PATCH = (
"local_deep_research.web.services.socketio_asgi.disconnect_session"
)
class TestExpiredSessionSocketTeardown:
"""Both expiry paths must disconnect expired sessions' sockets.
A socket is authorised once at handshake and then frozen, so without an
explicit teardown an expired session's tab keeps receiving the user's
events (including settings_changed, which carries secret values).
"""
def test_cleanup_disconnects_expired_session_sockets(self, manager):
"""Each expired session id is passed to disconnect_session."""
expired_sid = manager.create_session("alice", remember_me=False)
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
# A still-valid session must NOT be torn down.
valid_sid = manager.create_session("bob", remember_me=False)
with patch(_DISCONNECT_SESSION_PATCH) as disconnect:
manager.cleanup_expired_sessions()
assert expired_sid not in manager.sessions
assert valid_sid in manager.sessions
disconnect.assert_called_once_with(expired_sid)
def test_inline_validation_disconnects_only_the_expired_session(
self, manager
):
expired_sid = manager.create_session("alice")
valid_sid = manager.create_session("bob")
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
disconnected = []
def observe_disconnect(session_id):
disconnected.append((session_id, manager._lock.locked()))
with patch(_DISCONNECT_SESSION_PATCH, side_effect=observe_disconnect):
assert manager.validate_session(expired_sid) is None
assert manager.validate_session(valid_sid) == "bob"
manager.cleanup_expired_sessions()
assert expired_sid not in manager.sessions
assert valid_sid in manager.sessions
# Teardown is outside the non-reentrant session lock and happens only
# once; the later sweep cannot rediscover a session removed inline.
assert disconnected == [(expired_sid, False)]
def test_inline_expiry_survives_socket_teardown_failure(self, manager):
expired_sid = manager.create_session("alice")
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
with patch(
_DISCONNECT_SESSION_PATCH, side_effect=RuntimeError("no loop")
):
assert manager.validate_session(expired_sid) is None
assert expired_sid not in manager.sessions
def test_cleanup_survives_socket_service_uninitialized(self, manager):
"""If the socket service isn't initialised, cleanup still succeeds."""
expired_sid = manager.create_session("alice", remember_me=False)
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
with patch(
_DISCONNECT_SESSION_PATCH, side_effect=RuntimeError("no loop")
):
manager.cleanup_expired_sessions() # must not raise
assert expired_sid not in manager.sessions
def test_disconnect_failure_does_not_skip_later_expired_sessions(
self, manager
):
"""Each expired socket teardown is isolated from its siblings.
A stale socket for one session must not leave every later expired
session connected merely because its disconnect callback raised.
"""
first_sid = manager.create_session("alice", remember_me=False)
second_sid = manager.create_session("bob", remember_me=False)
expired_at = datetime.datetime.now(UTC) - datetime.timedelta(
hours=MOCK_SESSION_TIMEOUT_HOURS + 1
)
manager.sessions[first_sid]["last_access"] = expired_at
manager.sessions[second_sid]["last_access"] = expired_at
calls = []
def _disconnect(session_id):
calls.append(session_id)
if session_id == first_sid:
raise RuntimeError("first socket is already gone")
with patch(_DISCONNECT_SESSION_PATCH, side_effect=_disconnect):
manager.cleanup_expired_sessions()
assert calls == [first_sid, second_sid]
assert first_sid not in manager.sessions
assert second_sid not in manager.sessions
def test_socket_layer_import_failure_is_best_effort(self, manager):
"""Session expiry must work in non-web processes without Socket.IO."""
import sys
expired_sid = manager.create_session("alice", remember_me=False)
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
socket_module = "local_deep_research.web.services.socketio_asgi"
with (
patch.dict(sys.modules, {socket_module: None}),
patch(
"local_deep_research.web.auth.session_manager.logger"
) as mock_logger,
):
manager.cleanup_expired_sessions()
assert expired_sid not in manager.sessions
mock_logger.opt.return_value.warning.assert_called_once_with(
"Failed to resolve socket layer for expired-session teardown"
)
def test_cleanup_does_not_disconnect_when_nothing_expired(self, manager):
"""No expired sessions → the socket service is never consulted."""
manager.create_session("alice", remember_me=False)
with patch(_DISCONNECT_SESSION_PATCH) as disconnect:
manager.cleanup_expired_sessions()
disconnect.assert_not_called()
# ===========================================================================
# Active sessions count
# ===========================================================================
class TestGetActiveSessionsCount:
"""Tests for get_active_sessions_count method."""
def test_returns_zero_when_empty(self, manager):
"""Should return 0 when there are no sessions."""
assert manager.get_active_sessions_count() == 0
def test_returns_correct_count(self, manager):
"""Should return the number of active sessions."""
for i in range(4):
manager.create_session(f"user{i}")
assert manager.get_active_sessions_count() == 4
def test_triggers_cleanup_before_counting(self, manager):
"""Should clean up expired sessions before counting."""
for i in range(3):
manager.create_session(f"active_{i}")
expired_sid = manager.create_session("stale")
manager.sessions[expired_sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
count = manager.get_active_sessions_count()
assert count == 3
assert expired_sid not in manager.sessions
def test_count_after_all_expired(self, manager):
"""Should return 0 when all sessions have expired."""
for i in range(3):
sid = manager.create_session(f"user{i}")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
assert manager.get_active_sessions_count() == 0
# ===========================================================================
# User sessions
# ===========================================================================
class TestGetUserSessions:
"""Tests for get_user_sessions method."""
def test_returns_empty_list_when_no_sessions(self, manager):
"""Should return an empty list when the user has no sessions."""
assert manager.get_user_sessions("nobody") == []
def test_returns_only_matching_user_sessions(self, manager):
"""Should return sessions only for the specified username."""
manager.create_session("alice")
manager.create_session("alice")
manager.create_session("bob")
alice_sessions = manager.get_user_sessions("alice")
assert len(alice_sessions) == 2
bob_sessions = manager.get_user_sessions("bob")
assert len(bob_sessions) == 1
def test_does_not_return_other_users_sessions(self, manager):
"""Should never include sessions belonging to other users."""
manager.create_session("charlie")
manager.create_session("diana")
result = manager.get_user_sessions("charlie")
assert len(result) == 1
def test_truncates_session_id(self, manager):
"""Should truncate session_id to first 8 characters followed by '...'."""
sid = manager.create_session("eve")
result = manager.get_user_sessions("eve")
assert len(result) == 1
truncated_id = result[0]["session_id"]
assert truncated_id == sid[:8] + "..."
assert len(truncated_id) == 11 # 8 chars + 3 dots
def test_returns_expected_keys(self, manager):
"""Should return dicts with session_id, created_at, last_access, remember_me."""
manager.create_session("frank", remember_me=True)
result = manager.get_user_sessions("frank")
assert len(result) == 1
info = result[0]
assert set(info.keys()) == {
"session_id",
"created_at",
"last_access",
"remember_me",
}
assert info["remember_me"] is True
assert isinstance(info["created_at"], datetime.datetime)
assert isinstance(info["last_access"], datetime.datetime)
def test_multiple_sessions_same_user(self, manager):
"""Should list all sessions when a user has multiple active sessions."""
sid1 = manager.create_session("grace")
sid2 = manager.create_session("grace")
result = manager.get_user_sessions("grace")
assert len(result) == 2
returned_ids = {r["session_id"] for r in result}
assert returned_ids == {sid1[:8] + "...", sid2[:8] + "..."}
def test_returns_remember_me_flag_per_session(self, manager):
"""Each session entry should reflect its own remember_me setting."""
manager.create_session("hana", remember_me=False)
manager.create_session("hana", remember_me=True)
result = manager.get_user_sessions("hana")
flags = {r["remember_me"] for r in result}
assert flags == {True, False}
class TestDestroyAllUserSessions:
"""Tests for destroy_all_user_sessions."""
def test_destroys_all_sessions_for_user(self, manager):
"""Should destroy every session belonging to the target user."""
manager.create_session("alice", remember_me=False)
manager.create_session("alice", remember_me=False)
manager.create_session("bob", remember_me=False)
count = manager.destroy_all_user_sessions("alice")
assert count == 2
assert manager.get_user_sessions("alice") == []
# Bob's session should be untouched
assert len(manager.get_user_sessions("bob")) == 1
def test_returns_zero_for_unknown_user(self, manager):
"""Should return 0 and not raise when user has no sessions."""
count = manager.destroy_all_user_sessions("nobody")
assert count == 0
def test_returns_zero_after_double_call(self, manager):
"""Calling twice should be idempotent."""
manager.create_session("alice", remember_me=False)
manager.destroy_all_user_sessions("alice")
count = manager.destroy_all_user_sessions("alice")
assert count == 0
class TestTouchSession:
"""touch_session refreshes the idle timer on socket activity."""
def test_refreshes_last_access(self, manager):
from datetime import UTC
sid = manager.create_session("alice", remember_me=False)
old = datetime.datetime.now(UTC) - datetime.timedelta(hours=1)
manager.sessions[sid]["last_access"] = old
manager.touch_session(sid)
assert manager.sessions[sid]["last_access"] > old
def test_missing_or_none_session_is_noop(self, manager):
manager.touch_session("does-not-exist")
manager.touch_session(None)
assert "does-not-exist" not in manager.sessions
def test_does_not_delete_expired_session(self, manager):
from datetime import UTC
sid = manager.create_session("bob", remember_me=False)
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(days=99)
manager.touch_session(sid)
# Unlike validate_session, touch must NOT delete an expired session.
assert sid in manager.sessions
# ===========================================================================
# Logging must never execute while _lock is held (see the WARNING in
# SessionManager.__init__: touch_session re-enters _lock via
# emit_to_subscribers, and this is a plain Lock, not an RLock).
# ===========================================================================
class TestLoggingOutsideLock:
"""Regression tests for the validate_session/destroy_session log calls.
Both methods used to call ``logger.debug`` from inside their
``with self._lock`` block. That is a latent self-deadlock: if any
future caller binds a ``research_id`` and reaches these methods, the
synchronous frontend_progress_sink -> emit_to_subscribers ->
touch_session -> _lock chain would re-enter the same (non-reentrant)
lock on the same thread.
"""
def test_validate_session_expired_logs_after_lock_released(self, manager):
"""The expiry debug log must fire only after _lock is released."""
sid = manager.create_session("wendy")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
lock_states = []
with patch(
"local_deep_research.web.auth.session_manager.logger"
) as mock_logger:
mock_logger.debug.side_effect = lambda *a, **k: lock_states.append(
manager._lock.locked()
)
result = manager.validate_session(sid)
assert result is None
assert lock_states == [False]
def test_destroy_session_logs_after_lock_released(self, manager):
"""The destroy debug log must fire only after _lock is released."""
sid = manager.create_session("xena")
lock_states = []
with patch(
"local_deep_research.web.auth.session_manager.logger"
) as mock_logger:
mock_logger.debug.side_effect = lambda *a, **k: lock_states.append(
manager._lock.locked()
)
manager.destroy_session(sid)
assert lock_states == [False]
def test_destroy_session_of_unknown_id_does_not_log(self, manager):
"""No session removed -> no log call, and _lock still released."""
with patch(
"local_deep_research.web.auth.session_manager.logger"
) as mock_logger:
manager.destroy_session("does-not-exist")
mock_logger.debug.assert_not_called()
def test_destroy_all_user_sessions_logs_after_lock_released(self, manager):
manager.create_session("multi")
manager.create_session("multi")
lock_states = []
with patch(
"local_deep_research.web.auth.session_manager.logger"
) as mock_logger:
mock_logger.debug.side_effect = lambda *a, **k: lock_states.append(
manager._lock.locked()
)
removed = manager.destroy_all_user_sessions("multi")
assert removed == 2
assert lock_states == [False]
def test_expired_session_summary_logs_after_lock_released(self, manager):
sid = manager.create_session("expired")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
lock_states = []
with (
patch(_DISCONNECT_SESSION_PATCH),
patch(
"local_deep_research.web.auth.session_manager.logger"
) as mock_logger,
):
mock_logger.info.side_effect = lambda *a, **k: lock_states.append(
manager._lock.locked()
)
manager.cleanup_expired_sessions()
assert lock_states == [False]
def test_validate_session_expired_log_message_unchanged(
self, manager, loguru_caplog
):
"""Moving the log outside the lock must not change its content."""
sid = manager.create_session("yara")
manager.sessions[sid]["last_access"] = datetime.datetime.now(
UTC
) - datetime.timedelta(hours=MOCK_SESSION_TIMEOUT_HOURS + 1)
loguru_caplog.set_level("DEBUG")
manager.validate_session(sid)
assert f"Session {sid[:8]}... expired for yara" in loguru_caplog.text
def test_destroy_session_log_message_unchanged(
self, manager, loguru_caplog
):
"""Moving the log outside the lock must not change its content."""
sid = manager.create_session("zack")
loguru_caplog.set_level("DEBUG")
manager.destroy_session(sid)
assert (
f"Destroyed session {sid[:8]}... for user zack"
in loguru_caplog.text
)