~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
"""
Property-based fuzz tests for chat components using Hypothesis.
These tests verify that chat functions don't crash on arbitrary input
and handle edge cases gracefully.
"""
import pytest
from hypothesis import given, settings, strategies as st, assume, HealthCheck
from unittest.mock import MagicMock, patch
from contextlib import contextmanager
# =============================================================================
# Custom Strategies for Chat Testing
# =============================================================================
def message_roles():
"""Generate valid message roles."""
return st.sampled_from(["user", "assistant"])
def message_types():
"""Generate valid message types.
The schema removed "step" from ChatMessageType (steps live in
chat_progress_steps with their own enum-less schema); the chat
context layer filters out any "step" rows before they reach here.
"""
return st.sampled_from(["query", "followup", "response"])
def safe_text(max_size=200):
"""Generate text without problematic Unicode."""
return st.text(
alphabet=st.characters(
blacklist_categories=("Cs",), # Exclude surrogates
blacklist_characters=["\x00"], # Exclude null bytes
),
max_size=max_size,
)
def message_dict():
"""Generate a message dictionary."""
return st.fixed_dictionaries(
{
"id": st.text(
min_size=5, max_size=20, alphabet="abcdef0123456789-"
),
"role": message_roles(),
"content": safe_text(max_size=100),
"message_type": message_types(),
"research_id": st.one_of(
st.none(),
st.text(min_size=5, max_size=20, alphabet="abcdef0123456789-"),
),
}
)
def accumulated_context_dict():
"""Generate an accumulated context dictionary."""
return st.fixed_dictionaries(
{
"key_entities": st.lists(safe_text(max_size=50), max_size=20),
"topics": st.lists(safe_text(max_size=30), max_size=10),
"summary": safe_text(max_size=200),
}
)
# =============================================================================
# ChatContextManager Fuzz Tests
# =============================================================================
class TestChatContextManagerFuzz:
"""Fuzz tests for ChatContextManager."""
@given(
messages=st.lists(message_dict(), max_size=10),
accumulated=st.one_of(st.none(), accumulated_context_dict()),
)
@settings(max_examples=50, suppress_health_check=[HealthCheck.too_slow])
def test_build_context_handles_arbitrary_messages(
self, messages, accumulated
):
"""Test that build_research_context never crashes on arbitrary input."""
from local_deep_research.chat.context import ChatContextManager
try:
manager = ChatContextManager(
session_id="test-session",
messages=messages,
accumulated_context=accumulated,
)
context = manager.build_research_context()
# Verify result structure
assert isinstance(context, dict)
assert "session_id" in context
assert "is_multi_turn" in context
except Exception as e:
pytest.fail(
f"build_research_context crashed: {type(e).__name__}: {e}"
)
@given(accumulated=accumulated_context_dict())
@settings(max_examples=50, suppress_health_check=[HealthCheck.too_slow])
def test_accumulated_context_handles_arbitrary_data(self, accumulated):
"""Test that accumulated context with arbitrary data is handled."""
from local_deep_research.chat.context import ChatContextManager
try:
manager = ChatContextManager(
session_id="test-session",
messages=[],
accumulated_context=accumulated,
)
# Test key entity extraction
entities = manager._get_key_entities()
assert isinstance(entities, list)
assert len(entities) <= 20 # Should be limited
# Test topics extraction
topics = manager._get_topics()
assert isinstance(topics, list)
assert len(topics) <= 10 # Should be limited
except Exception as e:
pytest.fail(f"Context handling crashed: {type(e).__name__}: {e}")
@given(content=safe_text(max_size=500))
@settings(max_examples=50, suppress_health_check=[HealthCheck.too_slow])
def test_create_summary_handles_arbitrary_content(self, content):
"""Test that summary creation handles arbitrary content."""
from local_deep_research.chat.context import ChatContextManager
try:
manager = ChatContextManager("test-session", [], {})
summary = manager._create_summary(content)
# Should return a string
assert isinstance(summary, str)
# Should be limited in length
assert len(summary) <= 400 # 300 + "..."
except Exception as e:
pytest.fail(f"Summary creation crashed: {type(e).__name__}: {e}")
@given(content=safe_text(max_size=200))
@settings(max_examples=30, suppress_health_check=[HealthCheck.too_slow])
def test_extract_context_updates_handles_arbitrary_input(self, content):
"""Test that context update extraction handles arbitrary input."""
from local_deep_research.chat.context import ChatContextManager
try:
manager = ChatContextManager("test-session", [], {})
updates = manager.extract_context_updates(content)
# Verify structure
assert isinstance(updates, dict)
assert "new_entities" in updates
assert "new_topics" in updates
assert "summary_addition" in updates
except Exception as e:
pytest.fail(
f"Context update extraction crashed: {type(e).__name__}: {e}"
)
# =============================================================================
# ChatService Fuzz Tests
# =============================================================================
class TestChatServiceFuzz:
"""Fuzz tests for ChatService."""
@given(query=st.one_of(st.none(), safe_text(max_size=200)))
@settings(max_examples=50, suppress_health_check=[HealthCheck.too_slow])
def test_title_generation_handles_any_string(self, query):
"""Test that title generation handles any input string."""
from local_deep_research.chat.service import ChatService
try:
service = ChatService(username="test_user")
title = service._generate_title(query)
# Should return a string
assert isinstance(title, str)
# Should have reasonable length
assert len(title) <= 150 # 100 + "..."
except Exception as e:
pytest.fail(f"Title generation crashed: {type(e).__name__}: {e}")
@given(
content=safe_text(max_size=100),
role=message_roles(),
message_type=message_types(),
)
@settings(max_examples=30, suppress_health_check=[HealthCheck.too_slow])
def test_add_message_handles_unicode(self, content, role, message_type):
"""Test that add_message handles various Unicode content."""
from local_deep_research.chat.service import ChatService
# Skip empty content for valid messages
assume(len(content.strip()) > 0)
added_messages = []
@contextmanager
def mock_get_user_db_session(username, password=None):
mock_session = MagicMock()
# Existing empty chat: the counter advances to one and the
# retained-message query has no sequence yet.
mock_session.execute.return_value.scalar_one_or_none.return_value = 1
mock_session.query.return_value.filter.return_value.scalar.return_value = None
mock_session.new = added_messages
mock_session.add.side_effect = added_messages.append
mock_session.commit = MagicMock()
yield mock_session
with patch(
"local_deep_research.chat.service.get_user_db_session",
mock_get_user_db_session,
):
try:
service = ChatService(username="test_user")
message_id = service.add_message(
session_id="test-session",
role=role,
content=content,
message_type=message_type,
)
# Should return a UUID string
assert isinstance(message_id, str)
assert len(message_id) > 0
assert len(added_messages) == 1
assert added_messages[0].content == content
assert added_messages[0].sequence_number == 1
except ValueError:
# Session not found is expected in some cases
pass
except Exception as e:
pytest.fail(f"add_message crashed: {type(e).__name__}: {e}")
# =============================================================================
# Chat API Fuzz Tests (Parametrized for performance)
# =============================================================================
# Test data for API fuzzing - these are checked without Hypothesis
# to avoid the fixture overhead with each hypothesis iteration
SPECIAL_CONTENT_CASES = [
"Normal message",
"", # Empty
" " * 100, # Whitespace
"Unicode: Привет 你好 🎉",
"<script>alert('XSS')</script>",
"'\"<>&", # HTML special chars
"Line1\nLine2\rLine3",
pytest.param("A" * 9999, id="near-message-limit-9999"),
"\x00\x01\x02", # Control chars
]
UNICODE_TITLE_CASES = [
"Normal Title",
"",
"Привет мир",
"你好世界",
"🎉🔥💯",
"<script>",
pytest.param("A" * 499, id="near-title-limit-499"),
]
PAGINATION_CASES = [
(-1, 0),
(0, 0),
(1, 0),
(100, 0),
(101, 0),
(20, -1),
(20, 0),
(20, 1000),
]
STATUS_CASES = [
"active",
"archived",
"all",
"invalid",
"",
"' OR '1'='1",
"<script>",
]
class TestChatAPIFuzz:
"""Fuzz tests for Chat API endpoints using parametrized tests."""
@pytest.mark.parametrize("content", SPECIAL_CONTENT_CASES)
def test_send_message_handles_special_characters(
self, content, authenticated_client
):
"""Test that send message handles special characters in content."""
import json
# Create a session first
create_response = authenticated_client.post(
"/api/chat/sessions",
json={"initial_query": "Test"},
content_type="application/json",
)
# Session creation is the precondition, NOT the system under
# fuzz. Skipping on a non-200 here would silently mask any
# regression in POST /api/chat/sessions (CI would go green for
# every parametrized case). Assert so a broken precondition
# fails loudly.
assert create_response.status_code == 200, (
f"session creation precondition failed: "
f"{create_response.status_code} {create_response.data!r}"
)
session_id = json.loads(create_response.data)["session_id"]
# Send message with test content
response = authenticated_client.post(
f"/api/chat/sessions/{session_id}/messages",
json={"content": content, "trigger_research": False},
content_type="application/json",
)
# Should not crash. 200 = accepted, 400 = validation error.
# 500 here would be an unhandled-exception regression on user input.
assert response.status_code in [200, 400]
@pytest.mark.parametrize("title", UNICODE_TITLE_CASES)
def test_session_title_update_handles_unicode(
self, title, authenticated_client
):
"""Test that session title update handles Unicode strings."""
import json
# Create a session
create_response = authenticated_client.post(
"/api/chat/sessions",
json={"initial_query": "Test"},
content_type="application/json",
)
# Precondition assert — see test_send_message_handles_special_characters
# for the rationale (skip would mask session-create regression).
assert create_response.status_code == 200, (
f"session creation precondition failed: "
f"{create_response.status_code} {create_response.data!r}"
)
session_id = json.loads(create_response.data)["session_id"]
# Update with test title
response = authenticated_client.patch(
f"/api/chat/sessions/{session_id}",
json={"title": title},
content_type="application/json",
)
# Should not crash. 200 = accepted, 400 = validation error.
# 500 here would be an unhandled-exception regression on user input.
assert response.status_code in [200, 400]
@pytest.mark.parametrize("limit,offset", PAGINATION_CASES)
def test_pagination_handles_edge_cases(
self, limit, offset, authenticated_client
):
"""Test that pagination parameters handle edge cases."""
import json
response = authenticated_client.get(
f"/api/chat/sessions?limit={limit}&offset={offset}"
)
# Should not crash - may clamp values to valid range
assert response.status_code in [200, 400]
if response.status_code == 200:
data = json.loads(response.data)
assert "sessions" in data
@pytest.mark.parametrize("status", STATUS_CASES)
def test_list_sessions_handles_invalid_status(
self, status, authenticated_client
):
"""Test that list sessions handles invalid status values."""
import json
response = authenticated_client.get(
f"/api/chat/sessions?status={status}"
)
# Should not crash - invalid status should default to "active"
assert response.status_code == 200
data = json.loads(response.data)
assert data["success"] is True
# =============================================================================
# Prompt Context Fuzz Tests
# =============================================================================
class TestPromptContextFuzz:
"""Fuzz tests for findings extraction."""
@given(messages=st.lists(message_dict(), min_size=5, max_size=20))
@settings(max_examples=20, suppress_health_check=[HealthCheck.too_slow])
def test_findings_extraction_handles_many_messages(self, messages):
"""Test that findings extraction handles many messages."""
from local_deep_research.chat.context import ChatContextManager
try:
manager = ChatContextManager("test-session", messages, {})
findings = manager._extract_findings_from_history()
# Should return a string
assert isinstance(findings, str)
except Exception as e:
pytest.fail(f"Findings extraction crashed: {type(e).__name__}: {e}")
# =============================================================================
# Edge Case Tests
# =============================================================================
class TestEdgeCases:
"""Tests for specific edge cases that could cause issues."""
def test_empty_messages_list(self):
"""Test handling of empty messages list."""
from local_deep_research.chat.context import ChatContextManager
manager = ChatContextManager("test-session", [], {})
context = manager.build_research_context()
assert context["is_multi_turn"] is False
assert context["turn_count"] == 0
def test_none_messages_list(self):
"""Test handling of None messages."""
from local_deep_research.chat.context import ChatContextManager
manager = ChatContextManager("test-session", None, {})
context = manager.build_research_context()
assert context["is_multi_turn"] is False
def test_none_accumulated_context(self):
"""Test handling of None accumulated context."""
from local_deep_research.chat.context import ChatContextManager
manager = ChatContextManager("test-session", [], None)
entities = manager._get_key_entities()
topics = manager._get_topics()
assert entities == []
assert topics == []
def test_very_long_content_truncation(self):
"""Test that very long content is properly truncated."""
from local_deep_research.chat.context import ChatContextManager
# Create message with very long content
long_content = "A" * 10000
messages = [
{
"id": "msg-1",
"role": "assistant",
"content": long_content,
"message_type": "response",
"research_id": "research-1",
}
]
manager = ChatContextManager("test-session", messages, {})
findings = manager.build_research_context()["accumulated_findings"]
# Should be significantly shorter than original
assert len(findings) < len(long_content)
def test_special_characters_in_entities(self):
"""Test handling of special characters in entities."""
from local_deep_research.chat.context import ChatContextManager
accumulated = {
"key_entities": [
"entity<script>",
"entity'with'quotes",
'entity"double',
"entity\nnewline",
],
"topics": ["topic<tag>", "topic;semicolon"],
"summary": "Summary with <html> tags",
}
manager = ChatContextManager("test-session", [], accumulated)
context = manager.build_research_context()
# Should not crash and should include entities
assert len(context["key_entities"]) > 0