~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 chat-mode research termination — partial-content persistence,
final socket emit, and idempotency under mid-stream interrupts.
These tests target the helper directly with mocked ChatService and the
SocketIOService. End-to-end termination through the worker thread is
covered by the chat e2e suite.
"""
from local_deep_research.web.services import research_service # noqa: E402
from unittest.mock import create_autospec, patch, MagicMock
SESSION_ID = "00000000-0000-0000-0000-000000000001"
RESEARCH_ID = "00000000-0000-0000-0000-000000000002"
USERNAME = "alice"
def _import_helper():
from local_deep_research.web.services.research_service import (
_save_partial_chat_message_on_terminate,
_STOPPED_BEFORE_OUTPUT_MARKER,
_STOPPED_FOOTER,
)
return (
_save_partial_chat_message_on_terminate,
_STOPPED_BEFORE_OUTPUT_MARKER,
_STOPPED_FOOTER,
)
class TestPartialPersistOnTerminate:
"""`_save_partial_chat_message_on_terminate` behaviour."""
def test_persists_partial_with_stopped_footer(self):
helper, _marker, footer = _import_helper()
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter",
create_autospec(
research_service._socket_emitter, spec_set=True
),
) as mock_sock,
):
instance = MagicMock()
mock_svc.return_value = instance
helper(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"partial answer text",
)
mock_svc.assert_called_once_with(USERNAME)
instance.add_message.assert_called_once()
kwargs = instance.add_message.call_args.kwargs
assert kwargs["session_id"] == SESSION_ID
assert kwargs["role"] == "assistant"
assert kwargs["message_type"] == "response"
assert kwargs["research_id"] == RESEARCH_ID
assert kwargs["content"].startswith("partial answer text")
assert footer.strip() in kwargs["content"]
# Socket.IO final-chunk emit must fire so the bubble drops the
# streaming class on the client.
mock_sock.emit_to_subscribers.assert_called_once()
event_args = mock_sock.emit_to_subscribers.call_args.args
assert event_args[0] == "response_chunk"
assert event_args[1] == RESEARCH_ID
payload = event_args[2]
assert payload["is_final"] is True
def test_flushes_citation_carry_on_termination(self):
from local_deep_research.web.services.research_service import (
_make_chat_stream_callback,
)
streaming_state = {
"chunks_sent": 0,
"chunks": [],
"_bytes": 0,
"_truncated": False,
}
sock = MagicMock()
formatter = MagicMock()
formatter.apply_inline_hyperlinks.side_effect = lambda text, sources: (
text
)
callback = _make_chat_stream_callback(
RESEARCH_ID,
streaming_state,
sock,
USERNAME,
source_resolver=lambda: [{"url": "https://example.com"}],
formatter=formatter,
)
with patch(
"local_deep_research.web.routes.globals.is_termination_requested",
return_value=False,
):
callback("Answer before [12")
# The raw chunk is retained for termination persistence.
assert streaming_state["chunks"] == ["Answer before [12"]
# The incomplete citation is withheld from the live stream.
emitted_chunks = [
call.args[2]["chunk"]
for call in sock.emit_to_subscribers.call_args_list
if call.args and call.args[0] == "response_chunk"
]
assert "Answer before " in "".join(emitted_chunks)
assert "[12" not in "".join(emitted_chunks)
helper, _marker, footer = _import_helper()
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter",
sock,
),
):
instance = MagicMock()
mock_svc.return_value = instance
helper(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"".join(streaming_state["chunks"]),
streaming_state=streaming_state,
)
content = instance.add_message.call_args.kwargs["content"]
assert content == "Answer before [12" + footer
assert footer.strip() in content
events = [
call.args[2]
for call in sock.emit_to_subscribers.call_args_list
if call.args and call.args[0] == "response_chunk"
]
assert events[-2]["chunk"] == "[12"
assert events[-2]["is_final"] is False
assert events[-1]["chunk"] == ""
assert events[-1]["is_final"] is True
def test_persists_marker_when_no_chunks_streamed(self):
helper, marker, _footer = _import_helper()
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter"
),
):
instance = MagicMock()
mock_svc.return_value = instance
helper(SESSION_ID, RESEARCH_ID, USERNAME, "")
assert instance.add_message.call_args.kwargs["content"] == marker
def test_truncated_marker_appended_when_buffer_capped(self):
helper, _marker, _footer = _import_helper()
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter"
),
):
instance = MagicMock()
mock_svc.return_value = instance
helper(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"a long but truncated stream",
truncated=True,
)
content = instance.add_message.call_args.kwargs["content"]
assert "truncated" in content.lower()
def test_skips_silently_when_no_chat_session_id(self):
helper, _marker, _footer = _import_helper()
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter",
create_autospec(
research_service._socket_emitter, spec_set=True
),
) as mock_sock,
):
helper(None, RESEARCH_ID, USERNAME, "anything")
mock_svc.assert_not_called()
mock_sock.emit_to_subscribers.assert_not_called()
def test_idempotent_via_streaming_state_flag(self):
"""Two calls with the same streaming_state must persist exactly one
chat row — guards against the in-callback path and the outer
except handler both firing on a mid-stream interrupt."""
helper, _marker, _footer = _import_helper()
state = {"chunks": [], "_persisted": False}
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter",
create_autospec(
research_service._socket_emitter, spec_set=True
),
) as mock_sock,
):
instance = MagicMock()
mock_svc.return_value = instance
helper(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"first call",
streaming_state=state,
)
helper(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"second call",
streaming_state=state,
)
assert state["_persisted"] is True
assert instance.add_message.call_count == 1
assert mock_sock.emit_to_subscribers.call_count == 1
def test_swallows_chat_service_failures(self):
"""Persistence failures must NOT crash — termination cleanup is
best-effort."""
helper, _marker, _footer = _import_helper()
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.web.services.research_service._socket_emitter"
),
):
mock_svc.side_effect = RuntimeError("DB exploded")
# Should not raise.
helper(SESSION_ID, RESEARCH_ID, USERNAME, "anything")
class TestNoDuplicateRowOnLateTermination:
"""Corner case: termination flag flips between the success-path response
write (``_save_chat_message_and_context``) and the trailing
``progress_callback("Research completed successfully", 100)``.
The trailing callback's termination check would otherwise call
``_save_partial_chat_message_on_terminate`` and write a SECOND
response row. The fix: ``_save_chat_message_and_context`` sets
``streaming_state["_persisted"] = True`` after writing the success
row, and the helper short-circuits on that flag.
"""
def test_late_terminate_does_not_write_duplicate_row(self):
"""Simulate the production sequence: success-path writes the row,
then a late terminate fires. Only one row total."""
from local_deep_research.web.services.research_service import (
_save_chat_message_and_context,
_save_partial_chat_message_on_terminate,
)
streaming_state = {
"chunks_sent": 3,
"chunks": ["abc", "def", "ghi"],
"_bytes": 9,
"_truncated": False,
}
with (
patch("local_deep_research.chat.service.ChatService") as mock_svc,
patch(
"local_deep_research.chat.context.ChatContextManager"
) as mock_ctx,
patch(
"local_deep_research.web.services.research_service._socket_emitter"
),
):
success_chat = MagicMock()
mock_svc.return_value = success_chat
mock_ctx.return_value.extract_context_updates.return_value = {}
# 1) Success path runs first — writes the response row.
sock = MagicMock()
_save_chat_message_and_context(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"the full answer",
streaming_enabled=True,
streaming_state=streaming_state,
socket_service=sock,
)
# Sanity: success-path wrote exactly one row + flipped the flag.
assert success_chat.add_message.call_count == 1
assert streaming_state["_persisted"] is True
# 2) Trailing progress_callback detects termination and calls
# the helper. The flag must short-circuit it.
_save_partial_chat_message_on_terminate(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"".join(streaming_state["chunks"]),
streaming_state=streaming_state,
)
# Still exactly one add_message — no duplicate row.
assert success_chat.add_message.call_count == 1
def test_late_terminate_emits_no_duplicate_final_chunk(self):
"""The success path emits its own ``is_final`` chunk; the helper
must not emit a second one when short-circuited."""
from local_deep_research.web.services.research_service import (
_save_chat_message_and_context,
_save_partial_chat_message_on_terminate,
)
streaming_state = {
"chunks_sent": 1,
"chunks": ["x"],
"_bytes": 1,
"_truncated": False,
}
success_sock = MagicMock()
with (
patch("local_deep_research.chat.service.ChatService"),
patch("local_deep_research.chat.context.ChatContextManager"),
patch(
"local_deep_research.web.services.research_service._socket_emitter"
) as mock_terminate_sock,
):
_save_chat_message_and_context(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"answer",
streaming_enabled=True,
streaming_state=streaming_state,
socket_service=success_sock,
)
# Success path emitted its own final chunk.
assert success_sock.emit_to_subscribers.call_count == 1
_save_partial_chat_message_on_terminate(
SESSION_ID,
RESEARCH_ID,
USERNAME,
"x",
streaming_state=streaming_state,
)
# The helper's research_service._socket_emitter must NOT have been used —
# the short-circuit fired before any emit.
mock_terminate_sock.emit_to_subscribers.assert_not_called()