Files
javis_bot/tests/test_diary_import.py
javis-bot 1745fcd04c test: bring stale weather, enrichment cache and diary import tests up to date
- Weather: the tool deliberately returns one Korean sentence about now
  (c522e1b), so the tests check the place, condition, rounded temperature and
  feels-like, and that no forecast, Fahrenheit or degree sign is left for the
  model to echo.
- Enrichment cache: the conversational fast-path skips enrichment when no
  data tool is routed, so the test routes one to reach the extractor.
- Diary import: mock PyQt6, requests and psutil only when they are not
  installed. The MagicMock left in sys.modules for an installed PyQt6 broke
  every later GUI test file in the same run.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 16:13:52 +09:00

275 lines
10 KiB
Python

"""Tests for diary-to-graph import feature.
Covers:
- Database.get_all_conversation_summaries() method
- /api/graph/import-diary streaming endpoint (requires flask)
"""
import importlib.util
import json
import sqlite3
import sys
import types
from datetime import datetime, timezone
from unittest.mock import MagicMock, patch
import pytest
# Mock modules that may not be available in the test environment
_MOCK_MODULES = [
"PyQt6", "PyQt6.QtWidgets", "PyQt6.QtCore", "PyQt6.QtGui",
"PyQt6.QtWebEngineWidgets", "PyQt6.sip",
"requests", "requests.exceptions",
"psutil",
]
def _is_installed(name):
# Mock only what is missing: a MagicMock left in sys.modules for an
# installed PyQt6 breaks every later test file that imports the real one.
try:
return importlib.util.find_spec(name) is not None
except (ImportError, ValueError):
return False
for _mod in _MOCK_MODULES:
if _mod not in sys.modules and not _is_installed(_mod):
sys.modules[_mod] = MagicMock()
# Ensure requests.exceptions.Timeout is a proper exception class
sys.modules["requests"].exceptions.Timeout = type("Timeout", (Exception,), {})
from src.jarvis.memory.db import Database
# ── Database method tests ─────────────────────────────────────────────
@pytest.fixture
def db_with_summaries(tmp_path):
"""Provide a database pre-populated with conversation summaries."""
db = Database(str(tmp_path / "test.db"), sqlite_vss_path=None)
# Insert some summaries in non-chronological order to test ordering
summaries = [
("2025-03-15", "User discussed work projects and deadlines.", "work,planning", "jarvis"),
("2025-01-10", "User talked about favourite coffee shops.", "food,coffee", "jarvis"),
("2025-06-22", "User mentioned upcoming holiday plans.", "travel,holiday", "jarvis"),
("2025-02-01", "User shared fitness routine details.", "health,fitness", "jarvis"),
]
for date_utc, summary, topics, source_app in summaries:
ts_utc = datetime.now(timezone.utc).isoformat()
db.conn.execute(
"""INSERT INTO conversation_summaries (date_utc, ts_utc, summary, topics, source_app)
VALUES (?, ?, ?, ?, ?)""",
(date_utc, ts_utc, summary, topics, source_app),
)
db.conn.commit()
yield db
db.close()
@pytest.mark.unit
class TestGetAllConversationSummaries:
"""Tests for Database.get_all_conversation_summaries()."""
def test_returns_all_summaries(self, db_with_summaries):
"""Should return every summary in the database."""
rows = db_with_summaries.get_all_conversation_summaries()
assert len(rows) == 4
def test_ordered_by_date_ascending(self, db_with_summaries):
"""Summaries should be ordered oldest-first for chronological import."""
rows = db_with_summaries.get_all_conversation_summaries()
dates = [row["date_utc"] for row in rows]
assert dates == sorted(dates)
assert dates[0] == "2025-01-10"
assert dates[-1] == "2025-06-22"
def test_empty_database(self, db):
"""Should return an empty list when no summaries exist."""
rows = db.get_all_conversation_summaries()
assert rows == []
def test_returns_expected_fields(self, db_with_summaries):
"""Each row should have the standard conversation_summaries fields."""
rows = db_with_summaries.get_all_conversation_summaries()
row = rows[0]
assert "date_utc" in row.keys()
assert "summary" in row.keys()
assert "topics" in row.keys()
assert "source_app" in row.keys()
def test_contains_summary_text(self, db_with_summaries):
"""Summaries should contain the actual text that was stored."""
rows = db_with_summaries.get_all_conversation_summaries()
texts = [row["summary"] for row in rows]
assert any("coffee" in t for t in texts)
assert any("fitness" in t for t in texts)
# ── Import endpoint tests ─────────────────────────────────────────────
try:
import flask as _flask # noqa: F401
_HAS_FLASK = True
except ImportError:
_HAS_FLASK = False
@pytest.mark.unit
@pytest.mark.skipif(not _HAS_FLASK, reason="Flask not available")
class TestImportDiaryEndpoint:
"""Tests for /api/graph/import-diary streaming endpoint."""
@pytest.fixture(autouse=True)
def setup_app(self, tmp_path):
"""Set up Flask test client with a temporary database."""
from src.desktop_app.memory_viewer import app, get_graph_store
self.db_path = str(tmp_path / "test.db")
# Create database with summaries
self.db = Database(self.db_path, sqlite_vss_path=None)
self.db.conn.execute(
"""INSERT INTO conversation_summaries (date_utc, ts_utc, summary, topics, source_app)
VALUES (?, ?, ?, ?, ?)""",
("2025-03-15", "2025-03-15T12:00:00Z", "User likes dark roast coffee.", "food", "jarvis"),
)
self.db.conn.execute(
"""INSERT INTO conversation_summaries (date_utc, ts_utc, summary, topics, source_app)
VALUES (?, ?, ?, ?, ?)""",
("2025-03-16", "2025-03-16T12:00:00Z", "User works at Acme Corp.", "work", "jarvis"),
)
self.db.conn.commit()
app.config["TESTING"] = True
self.client = app.test_client()
yield
self.db.close()
def _parse_ndjson(self, data: bytes) -> list[dict]:
"""Parse newline-delimited JSON from response data."""
lines = data.decode("utf-8").strip().split("\n")
return [json.loads(line) for line in lines if line.strip()]
@patch("src.desktop_app.memory_viewer._get_db_path")
@patch("src.desktop_app.memory_viewer.load_settings")
@patch("src.jarvis.memory.graph_ops.call_llm_direct")
def test_import_streams_progress(self, mock_llm, mock_settings, mock_db_path):
"""Should stream start, progress, and complete messages."""
mock_db_path.return_value = self.db_path
cfg = MagicMock()
cfg.ollama_base_url = "http://localhost:11434"
cfg.ollama_chat_model = "test-model"
cfg.llm_chat_timeout_sec = 10.0
cfg.llm_thinking_enabled = False
mock_settings.return_value = cfg
# LLM returns facts for extraction, NONE for placement (writes to root)
mock_llm.side_effect = [
'["Likes dark roast coffee"]', # extract facts from summary 1
"NONE", # traverse for fact 1 (no children, goes to root)
'["Works at Acme Corp"]', # extract facts from summary 2
"NONE", # traverse for fact 2
]
resp = self.client.post("/api/graph/import-diary")
assert resp.status_code == 200
messages = self._parse_ndjson(resp.data)
types = [m["type"] for m in messages]
assert "start" in types
assert "progress" in types
assert "complete" in types
start_msg = next(m for m in messages if m["type"] == "start")
assert start_msg["total"] == 2
complete_msg = next(m for m in messages if m["type"] == "complete")
assert complete_msg["processed"] == 2
@patch("src.desktop_app.memory_viewer._get_db_path")
@patch("src.desktop_app.memory_viewer.load_settings")
def test_import_empty_diary(self, mock_settings, mock_db_path, tmp_path):
"""Should handle empty diary gracefully."""
empty_db_path = str(tmp_path / "empty.db")
empty_db = Database(empty_db_path, sqlite_vss_path=None)
mock_db_path.return_value = empty_db_path
cfg = MagicMock()
mock_settings.return_value = cfg
resp = self.client.post("/api/graph/import-diary")
messages = self._parse_ndjson(resp.data)
assert len(messages) == 1
assert messages[0]["type"] == "complete"
assert messages[0]["processed"] == 0
empty_db.close()
@patch("src.desktop_app.memory_viewer._get_db_path")
@patch("src.desktop_app.memory_viewer.load_settings")
@patch("src.jarvis.memory.graph_ops.call_llm_direct")
def test_import_continues_on_per_summary_error(self, mock_llm, mock_settings, mock_db_path):
"""If one summary fails, the import should continue with the rest."""
mock_db_path.return_value = self.db_path
cfg = MagicMock()
cfg.ollama_base_url = "http://localhost:11434"
cfg.ollama_chat_model = "test-model"
cfg.llm_chat_timeout_sec = 10.0
cfg.llm_thinking_enabled = False
mock_settings.return_value = cfg
# First summary extraction fails, second succeeds
mock_llm.side_effect = [
None, # extraction fails for summary 1
'["Works at Acme Corp"]', # extract facts from summary 2
"NONE", # traverse
]
resp = self.client.post("/api/graph/import-diary")
messages = self._parse_ndjson(resp.data)
progress_msgs = [m for m in messages if m["type"] == "progress"]
assert len(progress_msgs) == 2 # Both summaries processed
complete_msg = next(m for m in messages if m["type"] == "complete")
assert complete_msg["processed"] == 2
@pytest.mark.unit
@pytest.mark.skipif(not _HAS_FLASK, reason="Flask not available")
class TestImportDialogueDismissal:
"""Regression: after diary import succeeds, loadStats must not re-show the modal."""
def test_html_contains_diary_import_done_guard(self):
"""The loadStats check should be gated by diaryImportDone flag."""
from src.desktop_app.memory_viewer import app
app.config["TESTING"] = True
client = app.test_client()
resp = client.get("/")
html = resp.data.decode("utf-8")
# The flag must be declared
assert "let diaryImportDone = false;" in html
# The flag must be set on import completion
assert "diaryImportDone = true;" in html
# The loadStats check must include the guard
assert "&& !diaryImportDone" in html
# The gate must be based on stored knowledge (total_tokens), not node count.
# Guards against a regression to the old `totalNodes <= 1` condition that kept
# re-prompting after a successful import filled the root node.
assert "totalTokens === 0" in html
assert "totalNodes <= 1" not in html