Merge remote-tracking branch 'origin/master' into ji
# Conflicts: # .gitignore # frontend-web/src/components/workspace/artifacts/context.tsx # frontend-web/src/components/workspace/messages/message-group.tsx # offline-backend-20260512/backend/CLAUDE.md # offline-backend-20260512/backend/README.md # offline-backend-20260512/backend/app/gateway/app.py # offline-backend-20260512/backend/app/gateway/deps.py # offline-backend-20260512/backend/app/gateway/routers/llmwiki.py
This commit is contained in:
commit
e818c24769
262 files changed
+29527
-5236
No files matched your search
@@ -26,7 +26,7 @@ from deerflow.persistence.tags.memory import MemoryTagStore
|
||||
from deerflow.services.position_sync import PositionSyncService
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@pytest.fixture
|
||||
def isolated_paths(tmp_path, monkeypatch):
|
||||
"""Redirect get_paths() at a fresh temp directory for the duration of one test."""
|
||||
monkeypatch.setenv("DEER_FLOW_HOME", str(tmp_path))
|
||||
@@ -119,20 +119,20 @@ async def _default_positions() -> MemoryPositionStore:
|
||||
}
|
||||
)
|
||||
return positions
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_agent_store_allows_duplicate_chinese_names_and_filters_visibility() -> None:
|
||||
store = MemoryAgentStore()
|
||||
chinese_name = "\u4e2d\u6587\u52a9\u624b"
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": chinese_name, "description": "built in"})
|
||||
await store.create({"id": "private-a", "name": chinese_name, "description": "private", "user_id": "user-a"})
|
||||
await store.create({"id": "published-b", "name": chinese_name, "description": "published", "user_id": "user-b", "published": True})
|
||||
|
||||
user_a_ids = {agent["id"] for agent in await store.list_visible("user-a")}
|
||||
assert user_a_ids == {"builtin-agent", "private-a", "published-b"}
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": chinese_name, "description": "built in"})
|
||||
await store.create({"id": "private-a", "name": chinese_name, "description": "private", "user_id": "user-a"})
|
||||
await store.create({"id": "published-b", "name": chinese_name, "description": "published", "user_id": "user-b", "published": True})
|
||||
|
||||
user_a_ids = {agent["id"] for agent in await store.list_visible("user-a")}
|
||||
assert user_a_ids == {"builtin-agent", "private-a", "published-b"}
|
||||
|
||||
user_c_ids = {agent["id"] for agent in await store.list_visible("user-c")}
|
||||
assert user_c_ids == {"builtin-agent", "published-b"}
|
||||
|
||||
@@ -271,254 +271,270 @@ async def test_manual_favorite_upgrades_existing_auto_builtin_favorite(sql_sessi
|
||||
async def test_agent_store_only_owner_can_update_or_delete() -> None:
|
||||
store = MemoryAgentStore()
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "private-a", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
assert await store.update("builtin-agent", "user-a", {"name": "Nope"}) is None
|
||||
assert await store.update("private-a", "user-b", {"name": "Nope"}) is None
|
||||
|
||||
updated = await store.update("private-a", "user-a", {"name": "Renamed"})
|
||||
assert updated is not None
|
||||
assert updated["name"] == "Renamed"
|
||||
|
||||
assert await store.delete("private-a", "user-b") is False
|
||||
assert await store.delete("private-a", "user-a") is True
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_builtin_only_targets_builtins() -> None:
|
||||
store = MemoryAgentStore()
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
# delete_builtin refuses to touch a user-owned agent
|
||||
assert await store.delete_builtin("owned-agent") is False
|
||||
assert await store.get_any("owned-agent") is not None
|
||||
|
||||
# delete_builtin succeeds on a built-in
|
||||
assert await store.delete_builtin("builtin-agent") is True
|
||||
assert await store.get_any("builtin-agent") is None
|
||||
|
||||
# And no-ops on a missing id
|
||||
assert await store.delete_builtin("does-not-exist") is False
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_builtin_only_targets_builtins() -> None:
|
||||
store = MemoryAgentStore()
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
# update_builtin succeeds on a built-in agent
|
||||
updated = await store.update_builtin("builtin-agent", {"name": "Renamed by admin"})
|
||||
assert updated is not None
|
||||
assert updated["name"] == "Renamed by admin"
|
||||
|
||||
# update_builtin refuses to touch a user-owned agent (returns None)
|
||||
assert await store.update_builtin("owned-agent", {"name": "Hijacked"}) is None
|
||||
|
||||
# And on a missing agent
|
||||
assert await store.update_builtin("does-not-exist", {"name": "Ghost"}) is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_editable_or_raise_admin_can_edit_builtin() -> None:
|
||||
"""Route helper: admin gets edit access to any agent; non-admin still 403."""
|
||||
from fastapi import HTTPException
|
||||
|
||||
from app.gateway.routers.agents import _get_editable_or_raise
|
||||
|
||||
store = MemoryAgentStore()
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
# Owner edits their own agent → returns ('owner', record)
|
||||
record, mode = await _get_editable_or_raise(
|
||||
store, "owned-agent", "user-a", is_admin=False
|
||||
)
|
||||
assert mode == "owner" and record["id"] == "owned-agent"
|
||||
|
||||
# Admin edits a built-in agent → returns ('admin', record)
|
||||
record, mode = await _get_editable_or_raise(
|
||||
store, "builtin-agent", "user-a", is_admin=True
|
||||
)
|
||||
assert mode == "admin" and record["id"] == "builtin-agent"
|
||||
|
||||
# Non-admin tries to edit a built-in → 403
|
||||
with pytest.raises(HTTPException) as exc:
|
||||
await _get_editable_or_raise(store, "builtin-agent", "user-a", is_admin=False)
|
||||
assert exc.value.status_code == 403
|
||||
|
||||
# Admin edits someone else's custom agent → returns ('admin', record).
|
||||
# Behavior changed: admins manage the full agent catalog (built-in + any
|
||||
# user's agents), not just built-ins. Non-admins are still owner-only.
|
||||
await store.create(
|
||||
{"id": "published-other", "name": "Pub", "user_id": "user-x", "published": True}
|
||||
)
|
||||
record, mode = await _get_editable_or_raise(
|
||||
store, "published-other", "user-a", is_admin=True
|
||||
)
|
||||
assert mode == "admin" and record["id"] == "published-other"
|
||||
|
||||
|
||||
def test_build_run_config_injects_custom_assistant_as_agent_id() -> None:
|
||||
config = build_run_config("thread-1", None, None, assistant_id="agent-123")
|
||||
|
||||
assert config["configurable"]["thread_id"] == "thread-1"
|
||||
assert config["configurable"]["agent_id"] == "agent-123"
|
||||
assert "agent_name" not in config["configurable"]
|
||||
|
||||
|
||||
def test_write_agent_config_persists_skills_into_config_yaml(isolated_paths) -> None:
|
||||
agent_id = "agent-001"
|
||||
_write_agent_config(
|
||||
agent_id,
|
||||
name="中文助手",
|
||||
description="desc",
|
||||
skills=["s1", "s2"],
|
||||
model="gpt-x",
|
||||
tool_groups=["tg-a"],
|
||||
)
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
|
||||
assert raw["id"] == agent_id
|
||||
assert raw["name"] == "中文助手"
|
||||
assert raw["description"] == "desc"
|
||||
assert raw["skills"] == ["s1", "s2"]
|
||||
assert raw["model"] == "gpt-x"
|
||||
assert raw["tool_groups"] == ["tg-a"]
|
||||
|
||||
|
||||
def test_load_config_extras_returns_values_written_to_yaml(isolated_paths) -> None:
|
||||
agent_id = "agent-002"
|
||||
_write_agent_config(
|
||||
agent_id,
|
||||
name="agent-002",
|
||||
description="",
|
||||
skills=["s1"],
|
||||
model=None,
|
||||
tool_groups=None,
|
||||
)
|
||||
|
||||
extras = _load_config_extras(agent_id)
|
||||
assert extras == {"skills": ["s1"], "model": None, "tool_groups": None, "common_questions": None, "template_name": None, "seat_skill_directive": None}
|
||||
|
||||
|
||||
def test_load_config_extras_missing_directory_returns_none_triple(isolated_paths) -> None:
|
||||
extras = _load_config_extras("does-not-exist")
|
||||
assert extras == {"skills": None, "model": None, "tool_groups": None, "common_questions": None, "template_name": None, "seat_skill_directive": None}
|
||||
|
||||
|
||||
def test_write_agent_config_persists_common_questions(isolated_paths) -> None:
|
||||
agent_id = "agent-cq-1"
|
||||
# Structured {title, prompt} questions round-trip as clean dict mappings.
|
||||
questions = [
|
||||
{"title": "能做什么", "prompt": "这个智能体能做什么?"},
|
||||
{"title": "上传文件", "prompt": "如何上传文件?"},
|
||||
]
|
||||
_write_agent_config(agent_id, name="助手", description="", common_questions=questions)
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
assert raw["common_questions"] == questions
|
||||
|
||||
extras = _load_config_extras(agent_id)
|
||||
assert [q.model_dump() for q in extras["common_questions"]] == questions
|
||||
|
||||
|
||||
def test_write_agent_config_coerces_legacy_string_questions(isolated_paths) -> None:
|
||||
"""Legacy ``list[str]`` configs coerce to {title, prompt} with title=content."""
|
||||
agent_id = "agent-cq-legacy"
|
||||
_write_agent_config(
|
||||
agent_id, name="助手", description="", common_questions=["如何上传文件?"]
|
||||
)
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
assert raw["common_questions"] == [
|
||||
{"title": "如何上传文件?", "prompt": "如何上传文件?"}
|
||||
]
|
||||
|
||||
|
||||
def test_write_agent_config_omits_common_questions_when_none(isolated_paths) -> None:
|
||||
agent_id = "agent-cq-2"
|
||||
_write_agent_config(agent_id, name="x", description="")
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
assert "common_questions" not in raw
|
||||
assert _load_config_extras(agent_id)["common_questions"] is None
|
||||
|
||||
|
||||
def test_write_agent_config_explicit_empty_common_questions_is_persisted(isolated_paths) -> None:
|
||||
agent_id = "agent-cq-3"
|
||||
_write_agent_config(agent_id, name="x", description="", common_questions=[])
|
||||
|
||||
assert _load_config_extras(agent_id)["common_questions"] == []
|
||||
|
||||
|
||||
def test_write_agent_config_explicit_empty_skills_is_persisted(isolated_paths) -> None:
|
||||
agent_id = "agent-003"
|
||||
_write_agent_config(agent_id, name="x", description="", skills=[])
|
||||
|
||||
extras = _load_config_extras(agent_id)
|
||||
assert extras["skills"] == []
|
||||
|
||||
|
||||
def test_write_agent_config_omits_skills_when_none(isolated_paths) -> None:
|
||||
agent_id = "agent-004"
|
||||
_write_agent_config(agent_id, name="x", description="")
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
|
||||
assert "skills" not in raw
|
||||
assert "model" not in raw
|
||||
assert "tool_groups" not in raw
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_backfill_listing_cache_mirrors_config_values() -> None:
|
||||
store = MemoryAgentStore()
|
||||
cfg = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=["g1"], model="m1")
|
||||
await _backfill_listing_cache(store, [("a1", cfg)])
|
||||
|
||||
extras = await store.get_extras_for(["a1"])
|
||||
assert extras["a1"]["skills"] == ["s1", "s2"]
|
||||
assert extras["a1"]["tool_groups"] == ["g1"]
|
||||
assert extras["a1"]["model"] == "m1"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_backfill_listing_cache_is_idempotent_and_skips_unchanged(monkeypatch) -> None:
|
||||
store = MemoryAgentStore()
|
||||
cfg = AgentConfig(id="a1", name="Agent", skills=["s1"], tool_groups=None, model=None)
|
||||
await _backfill_listing_cache(store, [("a1", cfg)])
|
||||
|
||||
# On a second run with identical config, no re-write should occur.
|
||||
calls = {"replace": 0, "set": 0}
|
||||
orig_replace = store.replace_skills
|
||||
orig_set = store.set_extras
|
||||
|
||||
async def _replace(agent_id, skills):
|
||||
calls["replace"] += 1
|
||||
await orig_replace(agent_id, skills)
|
||||
|
||||
async def _set(agent_id, *, tool_groups, model):
|
||||
calls["set"] += 1
|
||||
await orig_set(agent_id, tool_groups=tool_groups, model=model)
|
||||
|
||||
monkeypatch.setattr(store, "replace_skills", _replace)
|
||||
monkeypatch.setattr(store, "set_extras", _set)
|
||||
|
||||
await _backfill_listing_cache(store, [("a1", cfg)])
|
||||
assert calls == {"replace": 0, "set": 0}
|
||||
|
||||
# Changing the config triggers a re-write.
|
||||
cfg2 = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=None, model=None)
|
||||
await _backfill_listing_cache(store, [("a1", cfg2)])
|
||||
assert calls["replace"] == 1
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "private-a", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
assert await store.update("builtin-agent", "user-a", {"name": "Nope"}) is None
|
||||
assert await store.update("private-a", "user-b", {"name": "Nope"}) is None
|
||||
|
||||
updated = await store.update("private-a", "user-a", {"name": "Renamed"})
|
||||
assert updated is not None
|
||||
assert updated["name"] == "Renamed"
|
||||
|
||||
assert await store.delete("private-a", "user-b") is False
|
||||
assert await store.delete("private-a", "user-a") is True
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_delete_builtin_only_targets_builtins() -> None:
|
||||
store = MemoryAgentStore()
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
# delete_builtin refuses to touch a user-owned agent
|
||||
assert await store.delete_builtin("owned-agent") is False
|
||||
assert await store.get_any("owned-agent") is not None
|
||||
|
||||
# delete_builtin succeeds on a built-in
|
||||
assert await store.delete_builtin("builtin-agent") is True
|
||||
assert await store.get_any("builtin-agent") is None
|
||||
|
||||
# And no-ops on a missing id
|
||||
assert await store.delete_builtin("does-not-exist") is False
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_builtin_only_targets_builtins() -> None:
|
||||
store = MemoryAgentStore()
|
||||
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
# update_builtin succeeds on a built-in agent
|
||||
updated = await store.update_builtin("builtin-agent", {"name": "Renamed by admin"})
|
||||
assert updated is not None
|
||||
assert updated["name"] == "Renamed by admin"
|
||||
|
||||
# update_builtin refuses to touch a user-owned agent (returns None)
|
||||
assert await store.update_builtin("owned-agent", {"name": "Hijacked"}) is None
|
||||
|
||||
# And on a missing agent
|
||||
assert await store.update_builtin("does-not-exist", {"name": "Ghost"}) is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_editable_or_raise_admin_can_edit_builtin() -> None:
|
||||
"""Route helper: admin gets edit access to any agent; non-admin still 403."""
|
||||
from fastapi import HTTPException
|
||||
|
||||
from app.gateway.routers.agents import _get_editable_or_raise
|
||||
|
||||
store = MemoryAgentStore()
|
||||
await store.ensure_builtin({"id": "builtin-agent", "name": "Built in"})
|
||||
await store.create({"id": "owned-agent", "name": "Owned", "user_id": "user-a"})
|
||||
|
||||
# Owner edits their own agent → returns ('owner', record)
|
||||
record, mode = await _get_editable_or_raise(
|
||||
store, "owned-agent", "user-a", is_admin=False
|
||||
)
|
||||
assert mode == "owner" and record["id"] == "owned-agent"
|
||||
|
||||
# Admin edits a built-in agent → returns ('admin', record)
|
||||
record, mode = await _get_editable_or_raise(
|
||||
store, "builtin-agent", "user-a", is_admin=True
|
||||
)
|
||||
assert mode == "admin" and record["id"] == "builtin-agent"
|
||||
|
||||
# Non-admin tries to edit a built-in → 403
|
||||
with pytest.raises(HTTPException) as exc:
|
||||
await _get_editable_or_raise(store, "builtin-agent", "user-a", is_admin=False)
|
||||
assert exc.value.status_code == 403
|
||||
|
||||
# Admin edits someone else's custom agent → returns ('admin', record).
|
||||
# Behavior changed: admins manage the full agent catalog (built-in + any
|
||||
# user's agents), not just built-ins. Non-admins are still owner-only.
|
||||
await store.create(
|
||||
{"id": "published-other", "name": "Pub", "user_id": "user-x", "published": True}
|
||||
)
|
||||
record, mode = await _get_editable_or_raise(
|
||||
store, "published-other", "user-a", is_admin=True
|
||||
)
|
||||
assert mode == "admin" and record["id"] == "published-other"
|
||||
|
||||
|
||||
def test_build_run_config_injects_custom_assistant_as_agent_id() -> None:
|
||||
config = build_run_config("thread-1", None, None, assistant_id="agent-123")
|
||||
|
||||
assert config["configurable"]["thread_id"] == "thread-1"
|
||||
assert config["configurable"]["agent_id"] == "agent-123"
|
||||
assert "agent_name" not in config["configurable"]
|
||||
|
||||
|
||||
def test_write_agent_config_persists_skills_into_config_yaml(isolated_paths) -> None:
|
||||
agent_id = "agent-001"
|
||||
_write_agent_config(
|
||||
agent_id,
|
||||
name="中文助手",
|
||||
description="desc",
|
||||
skills=["s1", "s2"],
|
||||
model="gpt-x",
|
||||
tool_groups=["tg-a"],
|
||||
)
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
|
||||
assert raw["id"] == agent_id
|
||||
assert raw["name"] == "中文助手"
|
||||
assert raw["description"] == "desc"
|
||||
assert raw["skills"] == ["s1", "s2"]
|
||||
assert raw["model"] == "gpt-x"
|
||||
assert raw["tool_groups"] == ["tg-a"]
|
||||
|
||||
|
||||
def test_load_config_extras_returns_values_written_to_yaml(isolated_paths) -> None:
|
||||
agent_id = "agent-002"
|
||||
_write_agent_config(
|
||||
agent_id,
|
||||
name="agent-002",
|
||||
description="",
|
||||
skills=["s1"],
|
||||
model=None,
|
||||
tool_groups=None,
|
||||
)
|
||||
|
||||
extras = _load_config_extras(agent_id)
|
||||
assert extras == {
|
||||
"skills": ["s1"],
|
||||
"model": None,
|
||||
"tool_groups": None,
|
||||
"common_questions": None,
|
||||
"template_name": None,
|
||||
"seat_skill_directive": None,
|
||||
"llmwiki_knowledge_base_ids": None,
|
||||
}
|
||||
|
||||
|
||||
def test_load_config_extras_missing_directory_returns_none_triple(isolated_paths) -> None:
|
||||
extras = _load_config_extras("does-not-exist")
|
||||
assert extras == {
|
||||
"skills": None,
|
||||
"model": None,
|
||||
"tool_groups": None,
|
||||
"common_questions": None,
|
||||
"template_name": None,
|
||||
"seat_skill_directive": None,
|
||||
"llmwiki_knowledge_base_ids": None,
|
||||
}
|
||||
|
||||
|
||||
def test_write_agent_config_persists_common_questions(isolated_paths) -> None:
|
||||
agent_id = "agent-cq-1"
|
||||
# Structured {title, prompt} questions round-trip as clean dict mappings.
|
||||
questions = [
|
||||
{"title": "能做什么", "prompt": "这个智能体能做什么?"},
|
||||
{"title": "上传文件", "prompt": "如何上传文件?"},
|
||||
]
|
||||
_write_agent_config(agent_id, name="助手", description="", common_questions=questions)
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
assert raw["common_questions"] == questions
|
||||
|
||||
extras = _load_config_extras(agent_id)
|
||||
assert [q.model_dump() for q in extras["common_questions"]] == questions
|
||||
|
||||
|
||||
def test_write_agent_config_coerces_legacy_string_questions(isolated_paths) -> None:
|
||||
"""Legacy ``list[str]`` configs coerce to {title, prompt} with title=content."""
|
||||
agent_id = "agent-cq-legacy"
|
||||
_write_agent_config(
|
||||
agent_id, name="助手", description="", common_questions=["如何上传文件?"]
|
||||
)
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
assert raw["common_questions"] == [
|
||||
{"title": "如何上传文件?", "prompt": "如何上传文件?"}
|
||||
]
|
||||
|
||||
|
||||
def test_write_agent_config_omits_common_questions_when_none(isolated_paths) -> None:
|
||||
agent_id = "agent-cq-2"
|
||||
_write_agent_config(agent_id, name="x", description="")
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
assert "common_questions" not in raw
|
||||
assert _load_config_extras(agent_id)["common_questions"] is None
|
||||
|
||||
|
||||
def test_write_agent_config_explicit_empty_common_questions_is_persisted(isolated_paths) -> None:
|
||||
agent_id = "agent-cq-3"
|
||||
_write_agent_config(agent_id, name="x", description="", common_questions=[])
|
||||
|
||||
assert _load_config_extras(agent_id)["common_questions"] == []
|
||||
|
||||
|
||||
def test_write_agent_config_explicit_empty_skills_is_persisted(isolated_paths) -> None:
|
||||
agent_id = "agent-003"
|
||||
_write_agent_config(agent_id, name="x", description="", skills=[])
|
||||
|
||||
extras = _load_config_extras(agent_id)
|
||||
assert extras["skills"] == []
|
||||
|
||||
|
||||
def test_write_agent_config_omits_skills_when_none(isolated_paths) -> None:
|
||||
agent_id = "agent-004"
|
||||
_write_agent_config(agent_id, name="x", description="")
|
||||
|
||||
config_file = paths_module.get_paths().agent_dir(agent_id) / "config.yaml"
|
||||
raw = yaml.safe_load(config_file.read_text(encoding="utf-8"))
|
||||
|
||||
assert "skills" not in raw
|
||||
assert "model" not in raw
|
||||
assert "tool_groups" not in raw
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_backfill_listing_cache_mirrors_config_values() -> None:
|
||||
store = MemoryAgentStore()
|
||||
cfg = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=["g1"], model="m1")
|
||||
await _backfill_listing_cache(store, [("a1", cfg)])
|
||||
|
||||
extras = await store.get_extras_for(["a1"])
|
||||
assert extras["a1"]["skills"] == ["s1", "s2"]
|
||||
assert extras["a1"]["tool_groups"] == ["g1"]
|
||||
assert extras["a1"]["model"] == "m1"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_backfill_listing_cache_is_idempotent_and_skips_unchanged(monkeypatch) -> None:
|
||||
store = MemoryAgentStore()
|
||||
cfg = AgentConfig(id="a1", name="Agent", skills=["s1"], tool_groups=None, model=None)
|
||||
await _backfill_listing_cache(store, [("a1", cfg)])
|
||||
|
||||
# On a second run with identical config, no re-write should occur.
|
||||
calls = {"replace": 0, "set": 0}
|
||||
orig_replace = store.replace_skills
|
||||
orig_set = store.set_extras
|
||||
|
||||
async def _replace(agent_id, skills):
|
||||
calls["replace"] += 1
|
||||
await orig_replace(agent_id, skills)
|
||||
|
||||
async def _set(agent_id, *, tool_groups, model):
|
||||
calls["set"] += 1
|
||||
await orig_set(agent_id, tool_groups=tool_groups, model=model)
|
||||
|
||||
monkeypatch.setattr(store, "replace_skills", _replace)
|
||||
monkeypatch.setattr(store, "set_extras", _set)
|
||||
|
||||
await _backfill_listing_cache(store, [("a1", cfg)])
|
||||
assert calls == {"replace": 0, "set": 0}
|
||||
|
||||
# Changing the config triggers a re-write.
|
||||
cfg2 = AgentConfig(id="a1", name="Agent", skills=["s1", "s2"], tool_groups=None, model=None)
|
||||
await _backfill_listing_cache(store, [("a1", cfg2)])
|
||||
assert calls["replace"] == 1
|
||||
@@ -38,17 +38,27 @@ class _ChainStore:
|
||||
return self.chain
|
||||
|
||||
|
||||
class _AgentStore:
|
||||
def __init__(self, agents: dict[str, dict[str, object]] | None = None) -> None:
|
||||
self.agents = agents or {}
|
||||
|
||||
async def get_any(self, agent_id: str) -> dict[str, object] | None:
|
||||
return self.agents.get(agent_id)
|
||||
|
||||
|
||||
def _request(
|
||||
role: str,
|
||||
chain: dict[str, object] | None = None,
|
||||
*,
|
||||
email: str = "lqq@example.com",
|
||||
agents: dict[str, dict[str, object]] | None = None,
|
||||
):
|
||||
return SimpleNamespace(
|
||||
app=SimpleNamespace(
|
||||
state=SimpleNamespace(
|
||||
business_mapping_store=_MappingStore(),
|
||||
roundtable_chain_store=_ChainStore(chain),
|
||||
agent_store=_AgentStore(agents),
|
||||
)
|
||||
),
|
||||
state=SimpleNamespace(user=SimpleNamespace(id="admin-id", email=email, system_role=role)),
|
||||
@@ -130,3 +140,34 @@ async def test_global_mapping_rejects_a_private_chain() -> None:
|
||||
|
||||
assert error.value.status_code == 400
|
||||
assert request.app.state.business_mapping_store.calls == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_global_mapping_rejects_a_chain_with_an_unpublished_agent_seat() -> None:
|
||||
request = _request(
|
||||
"admin",
|
||||
{
|
||||
"id": "chain-8bf",
|
||||
"title": "岗位协同链",
|
||||
"is_public": True,
|
||||
"seats": [
|
||||
{"agent_id": "published", "name": "已发布智能体"},
|
||||
{"agent_id": "private", "name": "未发布智能体"},
|
||||
],
|
||||
},
|
||||
agents={
|
||||
"published": {"id": "published", "user_id": "owner", "published": True, "is_private": False},
|
||||
"private": {"id": "private", "user_id": "owner", "published": False, "is_private": False},
|
||||
},
|
||||
)
|
||||
|
||||
with pytest.raises(HTTPException) as error:
|
||||
await business_mapping_router.update_mapping(
|
||||
request,
|
||||
"8BF",
|
||||
business_mapping_router.BusinessMappingUpdateRequest(chain_id="chain-8bf"),
|
||||
)
|
||||
|
||||
assert error.value.status_code == 400
|
||||
assert "未发布智能体" in error.value.detail
|
||||
assert request.app.state.business_mapping_store.calls == []
|
||||
@@ -0,0 +1,154 @@
|
||||
"""Tests for compact/sidebar-summary menu overrides (简介模式菜单).
|
||||
|
||||
Overrides are stored per ``menu_type`` (A / B) so two website deployments can
|
||||
keep independent left-nav layouts. Saving type B must not wipe type A.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
import pytest_asyncio
|
||||
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
||||
|
||||
from deerflow.persistence.base import Base
|
||||
from deerflow.persistence.compact_menu_overrides import (
|
||||
MemoryCompactMenuOverrideStore,
|
||||
CompactMenuOverrideRepository,
|
||||
normalize_compact_menu_type,
|
||||
)
|
||||
from deerflow.persistence.compact_menu_overrides.keys import public_node_id, storage_node_id
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def store(tmp_path):
|
||||
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'compact-menu.db'}")
|
||||
async with engine.begin() as conn:
|
||||
import deerflow.persistence.compact_menu_overrides.model # noqa: F401
|
||||
|
||||
await conn.run_sync(Base.metadata.create_all)
|
||||
sf = async_sessionmaker(engine, expire_on_commit=False)
|
||||
return CompactMenuOverrideRepository(sf)
|
||||
|
||||
|
||||
def test_normalize_compact_menu_type():
|
||||
assert normalize_compact_menu_type(None) == "A"
|
||||
assert normalize_compact_menu_type("") == "A"
|
||||
assert normalize_compact_menu_type("a") == "A"
|
||||
assert normalize_compact_menu_type("default") == "A"
|
||||
assert normalize_compact_menu_type("B") == "B"
|
||||
assert normalize_compact_menu_type("alt") == "B"
|
||||
assert normalize_compact_menu_type("2") == "B"
|
||||
|
||||
|
||||
def test_storage_keys_keep_type_a_unprefixed():
|
||||
assert storage_node_id("A", "workspace-chats") == "workspace-chats"
|
||||
assert storage_node_id("B", "workspace-chats") == "B::workspace-chats"
|
||||
assert public_node_id("B::workspace-chats", "B") == "workspace-chats"
|
||||
assert public_node_id("workspace-chats", "A") == "workspace-chats"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_replace_all_roundtrips(store: CompactMenuOverrideRepository):
|
||||
out = await store.replace_all(
|
||||
[
|
||||
{"node_id": "workspace-chats", "placement": "settings", "sort_order": 1, "label": "会话"},
|
||||
{"node_id": "workspace-agents", "placement": "sidebar", "sort_order": 0, "label": None},
|
||||
],
|
||||
updated_by="admin-1",
|
||||
)
|
||||
assert len(out) == 2
|
||||
rows = {r["node_id"]: r for r in await store.list_overrides()}
|
||||
assert rows["workspace-chats"]["label"] == "会话"
|
||||
assert rows["workspace-chats"]["placement"] == "settings"
|
||||
assert rows["workspace-chats"]["menu_type"] == "A"
|
||||
assert rows["workspace-agents"]["updated_by"] == "admin-1"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_replace_all_is_full_replacement_within_type(store: CompactMenuOverrideRepository):
|
||||
await store.replace_all([{"node_id": "a"}, {"node_id": "b"}], menu_type="A")
|
||||
await store.replace_all([{"node_id": "c"}], menu_type="A")
|
||||
ids = {r["node_id"] for r in await store.list_overrides("A")}
|
||||
assert ids == {"c"}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_types_are_isolated(store: CompactMenuOverrideRepository):
|
||||
await store.replace_all(
|
||||
[{"node_id": "workspace-chats", "placement": "sidebar", "sort_order": 0, "label": "对话A"}],
|
||||
menu_type="A",
|
||||
)
|
||||
await store.replace_all(
|
||||
[{"node_id": "workspace-chats", "placement": "settings", "sort_order": 2, "label": "对话B"}],
|
||||
menu_type="B",
|
||||
)
|
||||
a_rows = await store.list_overrides("A")
|
||||
b_rows = await store.list_overrides("B")
|
||||
assert len(a_rows) == 1
|
||||
assert a_rows[0]["node_id"] == "workspace-chats"
|
||||
assert a_rows[0]["label"] == "对话A"
|
||||
assert a_rows[0]["placement"] == "sidebar"
|
||||
assert len(b_rows) == 1
|
||||
assert b_rows[0]["node_id"] == "workspace-chats"
|
||||
assert b_rows[0]["label"] == "对话B"
|
||||
assert b_rows[0]["placement"] == "settings"
|
||||
|
||||
await store.replace_all([], menu_type="B")
|
||||
assert await store.list_overrides("B") == []
|
||||
leftover = await store.list_overrides("A")
|
||||
assert len(leftover) == 1
|
||||
assert leftover[0]["label"] == "对话A"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_omitted_menu_type_reads_legacy_rows():
|
||||
"""Old pages that do not send menu_type still see the original compact menu."""
|
||||
mem = MemoryCompactMenuOverrideStore()
|
||||
mem._rows["workspace-chats"] = {
|
||||
"node_id": "workspace-chats",
|
||||
"placement": "settings",
|
||||
"sort_order": 1,
|
||||
"label": "旧对话",
|
||||
}
|
||||
rows = await mem.list_overrides(None)
|
||||
assert len(rows) == 1
|
||||
assert rows[0]["node_id"] == "workspace-chats"
|
||||
assert rows[0]["label"] == "旧对话"
|
||||
assert rows[0]["menu_type"] == "A"
|
||||
assert await mem.list_overrides("B") == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_sql_blank_menu_type_is_treated_as_original(store: CompactMenuOverrideRepository):
|
||||
from sqlalchemy import update
|
||||
|
||||
from deerflow.persistence.compact_menu_overrides.model import CompactMenuOverrideRow
|
||||
|
||||
await store.replace_all(
|
||||
[{"node_id": "legacy", "placement": "sidebar", "sort_order": 0, "label": "旧菜单"}],
|
||||
)
|
||||
async with store._sf() as session:
|
||||
await session.execute(update(CompactMenuOverrideRow).values(menu_type=""))
|
||||
await session.commit()
|
||||
|
||||
rows = await store.list_overrides(None)
|
||||
assert {r["node_id"] for r in rows} == {"legacy"}
|
||||
assert rows[0]["label"] == "旧菜单"
|
||||
assert await store.list_overrides("B") == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_memory_store_parity():
|
||||
mem = MemoryCompactMenuOverrideStore()
|
||||
await mem.replace_all(
|
||||
[{"node_id": "x", "placement": "settings", "sort_order": 3}],
|
||||
menu_type="B",
|
||||
updated_by="u",
|
||||
)
|
||||
await mem.replace_all([{"node_id": "y", "sort_order": 0}], menu_type="A")
|
||||
b_rows = await mem.list_overrides("B")
|
||||
assert b_rows[0]["node_id"] == "x"
|
||||
assert b_rows[0]["menu_type"] == "B"
|
||||
assert b_rows[0]["placement"] == "settings"
|
||||
a_ids = {r["node_id"] for r in await mem.list_overrides("A")}
|
||||
assert a_ids == {"y"}
|
||||
@@ -0,0 +1,83 @@
|
||||
"""Fault-tolerance coverage for Deep Research progress events."""
|
||||
|
||||
import pytest
|
||||
|
||||
from deerflow.agents.deep_research.adapters.event_sink import PersistingEventSink
|
||||
|
||||
|
||||
class _UnavailableEventRepository:
|
||||
async def append(self, **kwargs): # noqa: ANN003
|
||||
raise RuntimeError("database temporarily unavailable")
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_event_persistence_failure_keeps_job_live_and_emits_unique_fallback_event():
|
||||
published: list[dict] = []
|
||||
|
||||
async def publish(event: dict) -> None:
|
||||
published.append(event)
|
||||
|
||||
sink = PersistingEventSink(
|
||||
_UnavailableEventRepository(),
|
||||
session_id="drs_1",
|
||||
job_id="drj_1",
|
||||
on_event=publish,
|
||||
)
|
||||
|
||||
first = await sink.emit("phase_changed", phase="planning", payload={"to": "planning"})
|
||||
second = await sink.emit("queries_planned", phase="collecting", payload={"queries": ["AI"]})
|
||||
|
||||
assert (first.seq, second.seq) == (-1, -2)
|
||||
assert first.payload["eventPersistenceDegraded"] is True
|
||||
assert published[0]["liveId"] == "event-persistence-fallback:drj_1:1"
|
||||
assert published[1]["liveId"] == "event-persistence-fallback:drj_1:2"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_live_publish_failure_does_not_fail_event_delivery():
|
||||
class _EventRepository:
|
||||
async def append(self, **kwargs): # noqa: ANN003
|
||||
return {
|
||||
"seq": 1,
|
||||
"event_type": kwargs["event_type"],
|
||||
"phase": kwargs["phase"],
|
||||
"payload": kwargs["payload"],
|
||||
}
|
||||
|
||||
async def broken_publisher(event: dict) -> None: # noqa: ARG001
|
||||
raise RuntimeError("browser disconnected")
|
||||
|
||||
sink = PersistingEventSink(
|
||||
_EventRepository(),
|
||||
session_id="drs_1",
|
||||
job_id="drj_1",
|
||||
on_event=broken_publisher,
|
||||
)
|
||||
|
||||
event = await sink.emit("phase_changed", phase="planning")
|
||||
|
||||
assert event.seq == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_document_rewrite_milestone_is_a_supported_durable_event():
|
||||
"""Guard the artifact-rewrite job path against EventType regressions."""
|
||||
|
||||
class _EventRepository:
|
||||
async def append(self, **kwargs): # noqa: ANN003
|
||||
return {
|
||||
"seq": 1,
|
||||
"event_type": kwargs["event_type"],
|
||||
"phase": kwargs["phase"],
|
||||
"payload": kwargs["payload"],
|
||||
}
|
||||
|
||||
sink = PersistingEventSink(_EventRepository(), session_id="drs_1", job_id="drj_1")
|
||||
|
||||
event = await sink.emit(
|
||||
"document_rewrite",
|
||||
phase="planning",
|
||||
payload={"type": "requirements_started"},
|
||||
)
|
||||
|
||||
assert event.type == "document_rewrite"
|
||||
@@ -0,0 +1,72 @@
|
||||
"""Failure-ordering regression coverage for final Deep Research report writes."""
|
||||
|
||||
import pytest
|
||||
|
||||
from app.gateway import deep_research_job_executor as executor_module
|
||||
from app.gateway.deep_research_job_executor import DeepResearchJobExecutor
|
||||
from deerflow.agents.deep_research.events import DeepResearchEvent
|
||||
from deerflow.agents.deep_research.types import DeepResearchResult
|
||||
|
||||
|
||||
class _JobStore:
|
||||
def __init__(self, session_store) -> None:
|
||||
self._session_store = session_store
|
||||
self.progress_calls: list[dict] = []
|
||||
|
||||
async def update_progress(self, job_id: str, **fields): # noqa: ARG002
|
||||
assert self._session_store.report_updates, "report must be persisted before job completion"
|
||||
self.progress_calls.append(fields)
|
||||
return {"id": job_id, **fields}
|
||||
|
||||
|
||||
class _SessionStore:
|
||||
def __init__(self, *, available: bool = True) -> None:
|
||||
self.available = available
|
||||
self.report_updates: list[dict] = []
|
||||
|
||||
async def update(self, session_id: str, **fields): # noqa: ARG002
|
||||
if not self.available:
|
||||
raise RuntimeError("temporary session database failure")
|
||||
self.report_updates.append(fields)
|
||||
return {"id": session_id, **fields}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_report_is_persisted_before_job_is_marked_completed():
|
||||
sessions = _SessionStore()
|
||||
jobs = _JobStore(sessions)
|
||||
runner = DeepResearchJobExecutor(jobs, sessions, event_store=None)
|
||||
|
||||
await runner._mark_completed(
|
||||
"drj_1",
|
||||
"drs_1",
|
||||
"worker_1",
|
||||
DeepResearchResult(report_markdown="# 报告", source_ids=["src_1"]),
|
||||
)
|
||||
|
||||
assert sessions.report_updates[0]["report_markdown"] == "# 报告"
|
||||
assert jobs.progress_calls[0]["status"] == "completed"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_report_projection_failure_never_marks_job_completed(monkeypatch):
|
||||
monkeypatch.setattr(executor_module, "_REPORT_PROJECTION_RETRY_ATTEMPTS", 2)
|
||||
monkeypatch.setattr(executor_module, "_REPORT_PROJECTION_RETRY_DELAY_SECONDS", 0)
|
||||
sessions = _SessionStore(available=False)
|
||||
jobs = _JobStore(sessions)
|
||||
runner = DeepResearchJobExecutor(jobs, sessions, event_store=None)
|
||||
|
||||
with pytest.raises(RuntimeError, match="研究报告未能保存"):
|
||||
await runner._mark_completed(
|
||||
"drj_1",
|
||||
"drs_1",
|
||||
"worker_1",
|
||||
DeepResearchResult(report_markdown="# 报告"),
|
||||
)
|
||||
|
||||
assert jobs.progress_calls == []
|
||||
|
||||
|
||||
def test_terminal_timeline_events_are_valid_durable_event_types():
|
||||
assert DeepResearchEvent(type="job_completed", phase="done").type == "job_completed"
|
||||
assert DeepResearchEvent(type="job_failed", phase="done").type == "job_failed"
|
||||
@@ -0,0 +1,538 @@
|
||||
"""Persistence tests for deep-research sessions, jobs, events, sources, messages.
|
||||
|
||||
Uses in-memory SQLite + aiosqlite, mirroring ``test_ai_writing_session_repo``.
|
||||
Focuses on the durable-job mechanics that are load-bearing for correctness:
|
||||
|
||||
- Session CRUD + user isolation.
|
||||
- Job ``try_create_or_get_active`` idempotency (unique dedupe key).
|
||||
- Job lease claim / renew / release (atomic CAS).
|
||||
- Two-phase cancel (``request_cancel`` → ``finalize_cancel``).
|
||||
- Event seq monotonicity + ``list_after`` replay (SSE reconnect correctness).
|
||||
|
||||
Pattern: a plain ``async def _make_repos()`` helper (not a fixture) — matches
|
||||
the project convention for async DB setup in pytest-asyncio strict mode.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
import pytest
|
||||
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
||||
|
||||
|
||||
async def _make_repos():
|
||||
"""Create an in-memory SQLite repo set with all deep-research tables."""
|
||||
from deerflow.persistence.base import Base
|
||||
from deerflow.persistence.deep_research_events.model import DeepResearchEventRow # noqa: F401
|
||||
from deerflow.persistence.deep_research_events.sql import DeepResearchEventRepository
|
||||
from deerflow.persistence.deep_research_jobs.model import DeepResearchJobRow # noqa: F401
|
||||
from deerflow.persistence.deep_research_jobs.sql import DeepResearchJobRepository
|
||||
from deerflow.persistence.deep_research_messages.model import DeepResearchMessageRow # noqa: F401
|
||||
from deerflow.persistence.deep_research_messages.sql import DeepResearchMessageRepository
|
||||
from deerflow.persistence.deep_research_sessions.model import DeepResearchSessionRow # noqa: F401
|
||||
from deerflow.persistence.deep_research_sessions.sql import DeepResearchSessionRepository
|
||||
from deerflow.persistence.deep_research_sources.model import DeepResearchSourceRow # noqa: F401
|
||||
from deerflow.persistence.deep_research_sources.sql import DeepResearchSourceRepository
|
||||
|
||||
engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
||||
async with engine.begin() as conn:
|
||||
await conn.run_sync(Base.metadata.create_all)
|
||||
sf = async_sessionmaker(engine, expire_on_commit=False)
|
||||
return {
|
||||
"sessions": DeepResearchSessionRepository(sf),
|
||||
"jobs": DeepResearchJobRepository(sf),
|
||||
"events": DeepResearchEventRepository(sf),
|
||||
"sources": DeepResearchSourceRepository(sf),
|
||||
"messages": DeepResearchMessageRepository(sf),
|
||||
"_engine": engine,
|
||||
}
|
||||
|
||||
|
||||
# ── sessions ────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_session_create_and_get():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
created = await repos["sessions"].create(id="drs_1", user_id="u1", title="Test", query="AI research", mode="deep")
|
||||
assert created["id"] == "drs_1"
|
||||
assert created["status"] == "draft"
|
||||
|
||||
got = await repos["sessions"].get("drs_1", user_id="u1")
|
||||
assert got is not None
|
||||
assert got["query"] == "AI research"
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_deep_research_writes_never_depend_on_post_commit_refresh(monkeypatch):
|
||||
"""Control-plane writes must survive a MySQL replica-lag readback."""
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
async def fail_refresh(self, instance, *args, **kwargs): # noqa: ANN001, ARG001
|
||||
raise AssertionError("Deep Research writes must not call session.refresh")
|
||||
|
||||
monkeypatch.setattr(AsyncSession, "refresh", fail_refresh)
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
session = await repos["sessions"].create(
|
||||
id="drs_1", user_id="u1", title="Test", query="AI research"
|
||||
)
|
||||
assert session["id"] == "drs_1"
|
||||
assert await repos["sessions"].update("drs_1", user_id="u1", status="running")
|
||||
|
||||
job, created = await repos["jobs"].try_create_or_get_active(
|
||||
id="drj_1", session_id="drs_1", user_id="u1"
|
||||
)
|
||||
assert created is True
|
||||
assert job["id"] == "drj_1"
|
||||
|
||||
source = await repos["sources"].upsert(
|
||||
session_id="drs_1",
|
||||
id="src_1",
|
||||
user_id="u1",
|
||||
title="A",
|
||||
raw_content="source content",
|
||||
source="web",
|
||||
content_hash="hash_1",
|
||||
)
|
||||
assert source["id"] == "src_1"
|
||||
|
||||
message = await repos["messages"].append(
|
||||
id="msg_1",
|
||||
session_id="drs_1",
|
||||
user_id="u1",
|
||||
role="assistant",
|
||||
content="已开始撰写",
|
||||
)
|
||||
assert message["id"] == "msg_1"
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_session_user_isolation():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["sessions"].create(id="drs_1", user_id="u1", query="q1")
|
||||
assert await repos["sessions"].get("drs_1", user_id="u2") is None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_session_list_strips_heavy_columns():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["sessions"].create(id="drs_1", user_id="u1", query="q", config_snapshot={"mode": "deep"})
|
||||
items = await repos["sessions"].list_by_user(user_id="u1")
|
||||
assert len(items) == 1
|
||||
assert "report_markdown" not in items[0]
|
||||
assert "config_snapshot" not in items[0]
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_session_update_and_delete():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["sessions"].create(id="drs_1", user_id="u1", query="q")
|
||||
updated = await repos["sessions"].update("drs_1", user_id="u1", title="New Title")
|
||||
assert updated["title"] == "New Title"
|
||||
assert await repos["sessions"].delete("drs_1", user_id="u1") is True
|
||||
assert await repos["sessions"].get("drs_1", user_id="u1") is None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_count_active_by_user():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["sessions"].create(id="drs_1", user_id="u1", query="q", status="running")
|
||||
await repos["sessions"].create(id="drs_2", user_id="u1", query="q", status="completed")
|
||||
count = await repos["sessions"].count_active_by_user(user_id="u1")
|
||||
assert count == 1
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── jobs: idempotent create ─────────────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_try_create_returns_created_true():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
job, created = await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1", request_id="req_1")
|
||||
assert created is True
|
||||
assert job["status"] == "queued"
|
||||
assert job["active_dedupe_key"] is not None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_create_never_reads_back_after_commit(monkeypatch):
|
||||
"""A committed job must not fail when a MySQL replica briefly lags."""
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
async def fail_refresh(self, instance, *args, **kwargs): # noqa: ANN001, ARG001
|
||||
raise AssertionError("DeepResearchJobRepository must not call session.refresh")
|
||||
|
||||
monkeypatch.setattr(AsyncSession, "refresh", fail_refresh)
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
job, created = await repos["jobs"].try_create_or_get_active(
|
||||
id="drj_1",
|
||||
session_id="drs_1",
|
||||
user_id="u1",
|
||||
request_id="req_1",
|
||||
)
|
||||
assert created is True
|
||||
assert job["id"] == "drj_1"
|
||||
assert job["status"] == "queued"
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_try_create_idempotent_returns_existing():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
job1, created1 = await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1", request_id="req_1")
|
||||
job2, created2 = await repos["jobs"].try_create_or_get_active(id="drj_2", session_id="drs_1", user_id="u1", request_id="req_2")
|
||||
assert created1 is True
|
||||
assert created2 is False
|
||||
assert job2["id"] == job1["id"]
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_dedupe_released_on_terminal():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
job, _ = await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
assert job["active_dedupe_key"] is not None
|
||||
await repos["jobs"].update_progress("drj_1", lease_owner=None, user_id="u1", status="completed")
|
||||
job2, created2 = await repos["jobs"].try_create_or_get_active(id="drj_2", session_id="drs_1", user_id="u1")
|
||||
assert created2 is True
|
||||
assert job2["id"] == "drj_2"
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── jobs: lease mechanics ───────────────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_claim_succeeds_for_queued():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
lease_until = datetime.now(UTC) + timedelta(seconds=60)
|
||||
claimed = await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
|
||||
assert claimed is not None
|
||||
assert claimed["status"] == "running"
|
||||
assert claimed["lease_owner"] == "w1"
|
||||
assert claimed["attempt"] == 1
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_dispatcher_claims_queued_job_and_starts_report_worker():
|
||||
"""The claimed snapshot must reach the executor before the job can run."""
|
||||
from app.gateway.deep_research_job_dispatcher import DeepResearchJobDispatcher
|
||||
|
||||
class _Executor:
|
||||
def __init__(self) -> None:
|
||||
self.started: list[tuple[dict, str, str | None]] = []
|
||||
|
||||
def start_job(self, snapshot: dict, *, job_id: str, lease_owner: str | None) -> bool:
|
||||
self.started.append((snapshot, job_id, lease_owner))
|
||||
return True
|
||||
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(
|
||||
id="drj_1",
|
||||
session_id="drs_1",
|
||||
user_id="u1",
|
||||
input_snapshot={"query": "测试报告"},
|
||||
)
|
||||
runner = _Executor()
|
||||
dispatcher = DeepResearchJobDispatcher(repos["jobs"], runner, worker_id="worker_1")
|
||||
|
||||
started = await dispatcher.dispatch_once()
|
||||
|
||||
assert started == 1
|
||||
assert runner.started == [({"query": "测试报告"}, "drj_1", "worker_1")]
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_claim_fails_if_already_claimed():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
lease_until = datetime.now(UTC) + timedelta(seconds=60)
|
||||
first = await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
|
||||
assert first is not None
|
||||
second = await repos["jobs"].claim_job("drj_1", lease_owner="w2", lease_until=lease_until)
|
||||
assert second is None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_renew_lease_only_by_owner():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
lease_until = datetime.now(UTC) + timedelta(seconds=60)
|
||||
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
|
||||
assert await repos["jobs"].renew_lease("drj_1", lease_owner="w1", lease_until=lease_until) is True
|
||||
assert await repos["jobs"].renew_lease("drj_1", lease_owner="w2", lease_until=lease_until) is False
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_expired_lease_reclaimable():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
expired = datetime.now(UTC) - timedelta(seconds=10)
|
||||
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=expired)
|
||||
now = datetime.now(UTC)
|
||||
claimable = await repos["jobs"].list_claimable(now=now)
|
||||
assert "drj_1" in claimable
|
||||
reclaimed = await repos["jobs"].claim_job("drj_1", lease_owner="w2", lease_until=now + timedelta(seconds=60))
|
||||
assert reclaimed is not None
|
||||
assert reclaimed["lease_owner"] == "w2"
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── jobs: two-phase cancel ──────────────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_cancel_two_phase():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
lease_until = datetime.now(UTC) + timedelta(seconds=60)
|
||||
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
|
||||
|
||||
requested = await repos["jobs"].request_cancel("drj_1", user_id="u1")
|
||||
assert requested is not None
|
||||
assert requested["cancel_requested"] is True
|
||||
|
||||
finalized = await repos["jobs"].finalize_cancel("drj_1")
|
||||
assert finalized is not None
|
||||
assert finalized["status"] == "cancelled"
|
||||
assert finalized["active_dedupe_key"] is None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_cancel_idempotent():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
first = await repos["jobs"].request_cancel("drj_1", user_id="u1")
|
||||
assert first is not None
|
||||
await repos["jobs"].finalize_cancel("drj_1")
|
||||
second = await repos["jobs"].request_cancel("drj_1", user_id="u1")
|
||||
assert second is None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── jobs: progress update with lease gate ───────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_job_update_progress_lease_gated():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["jobs"].try_create_or_get_active(id="drj_1", session_id="drs_1", user_id="u1")
|
||||
lease_until = datetime.now(UTC) + timedelta(seconds=60)
|
||||
await repos["jobs"].claim_job("drj_1", lease_owner="w1", lease_until=lease_until)
|
||||
|
||||
updated = await repos["jobs"].update_progress("drj_1", lease_owner="w1", phase="collecting", progress=50)
|
||||
assert updated is not None
|
||||
assert updated["phase"] == "collecting"
|
||||
assert updated["progress"] == 50
|
||||
|
||||
rejected = await repos["jobs"].update_progress("drj_1", lease_owner="w2", phase="writing")
|
||||
assert rejected is None
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── events: monotonic seq + replay ──────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_event_seq_monotonic():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
repo = repos["events"]
|
||||
e1 = await repo.append(session_id="drs_1", job_id="drj_1", event_type="phase_changed", payload={"to": "planning"})
|
||||
e2 = await repo.append(session_id="drs_1", job_id="drj_1", event_type="source_added", payload={"id": "s1"})
|
||||
e3 = await repo.append(session_id="drs_1", job_id="drj_1", event_type="source_added", payload={"id": "s2"})
|
||||
assert e1["seq"] == 1
|
||||
assert e2["seq"] == 2
|
||||
assert e3["seq"] == 3
|
||||
assert await repo.last_seq("drj_1") == 3
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_event_append_never_reads_back_after_commit(monkeypatch):
|
||||
"""Event persistence must work when a post-commit read hits a lagging replica."""
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
async def fail_refresh(self, instance, *args, **kwargs): # noqa: ANN001, ARG001
|
||||
raise AssertionError("DeepResearchEventRepository must not call session.refresh")
|
||||
|
||||
monkeypatch.setattr(AsyncSession, "refresh", fail_refresh)
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
event = await repos["events"].append(
|
||||
session_id="drs_1",
|
||||
job_id="drj_1",
|
||||
event_type="phase_changed",
|
||||
payload={"to": "planning"},
|
||||
)
|
||||
assert event["id"] is not None
|
||||
assert event["seq"] == 1
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_event_list_after_replay():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
repo = repos["events"]
|
||||
for i in range(5):
|
||||
await repo.append(session_id="drs_1", job_id="drj_1", event_type="heartbeat", payload={"i": i})
|
||||
replayed = await repo.list_after("drj_1", after=2)
|
||||
assert len(replayed) == 3
|
||||
assert [e["seq"] for e in replayed] == [3, 4, 5]
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_event_payload_round_trip():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
repo = repos["events"]
|
||||
await repo.append(
|
||||
session_id="drs_1",
|
||||
job_id="drj_1",
|
||||
event_type="plan_created",
|
||||
payload={"subtopics": ["AI", "ML"], "nested": {"a": 1}},
|
||||
)
|
||||
events = await repo.list_after("drj_1", after=0)
|
||||
assert events[0]["payload"]["subtopics"] == ["AI", "ML"]
|
||||
assert events[0]["payload"]["nested"]["a"] == 1
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_event_seq_independent_per_job():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
repo = repos["events"]
|
||||
await repo.append(session_id="drs_1", job_id="drj_1", event_type="heartbeat")
|
||||
await repo.append(session_id="drs_1", job_id="drj_1", event_type="heartbeat")
|
||||
await repo.append(session_id="drs_1", job_id="drj_2", event_type="heartbeat")
|
||||
assert await repo.last_seq("drj_1") == 2
|
||||
assert await repo.last_seq("drj_2") == 1
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── sources ─────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_source_upsert_and_list():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["sources"].upsert(
|
||||
session_id="drs_1",
|
||||
id="src_1",
|
||||
user_id="u1",
|
||||
title="Source A",
|
||||
url="https://example.com/a",
|
||||
raw_content="content A",
|
||||
source="web",
|
||||
source_type="web",
|
||||
content_hash="hash_a",
|
||||
)
|
||||
items = await repos["sources"].list_by_session("drs_1", user_id="u1")
|
||||
assert len(items) == 1
|
||||
assert items[0]["title"] == "Source A"
|
||||
assert "raw_content" not in items[0]
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_source_set_selected():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["sources"].upsert(
|
||||
session_id="drs_1",
|
||||
id="src_1",
|
||||
user_id="u1",
|
||||
title="A",
|
||||
raw_content="c",
|
||||
source="web",
|
||||
content_hash="h",
|
||||
)
|
||||
updated = await repos["sources"].set_selected("src_1", selected=True, reason="relevant", citation_key="1", user_id="u1")
|
||||
assert updated["selected"] is True
|
||||
assert updated["citation_key"] == "1"
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
|
||||
|
||||
# ── messages ────────────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_message_append_and_list():
|
||||
repos = await _make_repos()
|
||||
try:
|
||||
await repos["messages"].append(id="msg_1", session_id="drs_1", user_id="u1", role="user", content="question?")
|
||||
await repos["messages"].append(
|
||||
id="msg_2",
|
||||
session_id="drs_1",
|
||||
user_id="u1",
|
||||
role="assistant",
|
||||
content="answer",
|
||||
citation_source_ids=["src_1"],
|
||||
)
|
||||
msgs = await repos["messages"].list_by_session("drs_1", user_id="u1")
|
||||
assert len(msgs) == 2
|
||||
assert msgs[0]["role"] == "user"
|
||||
assert msgs[1]["citation_source_ids"] == ["src_1"]
|
||||
finally:
|
||||
await repos["_engine"].dispose()
|
||||
@@ -0,0 +1,583 @@
|
||||
"""Regression coverage for idempotent Deep Research job submission."""
|
||||
|
||||
import json
|
||||
from datetime import UTC, datetime
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
|
||||
from app.gateway import deep_research_report_rewrite as report_rewrite
|
||||
from app.gateway.routers import deep_research
|
||||
|
||||
|
||||
class _SessionStore:
|
||||
def __init__(self) -> None:
|
||||
self.updates: list[dict] = []
|
||||
|
||||
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
return {
|
||||
"id": session_id,
|
||||
"query": "测试主题",
|
||||
"title": "测试主题",
|
||||
"config_snapshot": {"mode": "basic"},
|
||||
}
|
||||
|
||||
async def count_active_by_user(self, *, user_id: str) -> int: # noqa: ARG002
|
||||
return 0
|
||||
|
||||
async def update(self, session_id: str, *, user_id: str, **fields): # noqa: ARG002
|
||||
self.updates.append(fields)
|
||||
return {"id": session_id, **fields}
|
||||
|
||||
|
||||
class _JobStore:
|
||||
async def get_active_for_session(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
return None
|
||||
|
||||
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
|
||||
# Simulate a retry after an earlier request committed the job but did
|
||||
# not finish responding to the browser.
|
||||
return {"id": "drj_existing", "status": "queued"}, False
|
||||
|
||||
|
||||
class _Dispatcher:
|
||||
def __init__(self) -> None:
|
||||
self.nudges = 0
|
||||
|
||||
def nudge(self) -> None:
|
||||
self.nudges += 1
|
||||
|
||||
|
||||
def _request(*, sessions, jobs, dispatcher, sources=None):
|
||||
return SimpleNamespace(
|
||||
app=SimpleNamespace(
|
||||
state=SimpleNamespace(
|
||||
deep_research_session_store=sessions,
|
||||
deep_research_job_store=jobs,
|
||||
deep_research_dispatcher=dispatcher,
|
||||
deep_research_source_store=sources,
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_retry_of_existing_queued_job_nudges_dispatcher(monkeypatch):
|
||||
"""An idempotent retry must recover a queued-but-not-yet-dispatched job."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
sessions = _SessionStore()
|
||||
dispatcher = _Dispatcher()
|
||||
request = _request(sessions=sessions, jobs=_JobStore(), dispatcher=dispatcher)
|
||||
|
||||
response = await deep_research.start_job(
|
||||
"drs_1",
|
||||
deep_research.StartJobRequest(entry="legacy"),
|
||||
request,
|
||||
)
|
||||
|
||||
assert response == {
|
||||
"jobId": "drj_existing",
|
||||
"sessionId": "drs_1",
|
||||
"status": "queued",
|
||||
"reused": True,
|
||||
}
|
||||
assert dispatcher.nudges == 1
|
||||
assert sessions.updates == [{"status": "running", "active_job_id": "drj_existing"}]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_queued_job_still_starts_when_session_projection_temporarily_fails(monkeypatch):
|
||||
"""A committed job is more important than its non-authoritative UI projection."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
class _ProjectionFailureSessionStore(_SessionStore):
|
||||
async def update(self, session_id: str, *, user_id: str, **fields): # noqa: ARG002
|
||||
raise RuntimeError("temporary database readback failure")
|
||||
|
||||
class _NewJobStore(_JobStore):
|
||||
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
|
||||
return {"id": "drj_new", "status": "queued"}, True
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
dispatcher = _Dispatcher()
|
||||
response = await deep_research.start_job(
|
||||
"drs_1",
|
||||
deep_research.StartJobRequest(entry="legacy"),
|
||||
_request(
|
||||
sessions=_ProjectionFailureSessionStore(),
|
||||
jobs=_NewJobStore(),
|
||||
dispatcher=dispatcher,
|
||||
),
|
||||
)
|
||||
|
||||
assert response["jobId"] == "drj_new"
|
||||
assert response["reused"] is False
|
||||
assert dispatcher.nudges == 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_chat_report_card_can_enable_images_after_collection(monkeypatch):
|
||||
"""The write-time card override must win over the collection-time default."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
class _ChatSessionStore(_SessionStore):
|
||||
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
return {
|
||||
"id": session_id,
|
||||
"query": "测试主题",
|
||||
"title": "测试主题",
|
||||
"runtime_thread_id": "collector-thread",
|
||||
"config_snapshot": {
|
||||
"mode": "basic",
|
||||
"collection_mode": "chat",
|
||||
"generate_images": False,
|
||||
"max_generated_images": 2,
|
||||
},
|
||||
}
|
||||
|
||||
class _CapturingJobStore(_JobStore):
|
||||
def __init__(self) -> None:
|
||||
self.created: dict | None = None
|
||||
|
||||
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
|
||||
self.created = kwargs
|
||||
return {"id": "drj_images", "status": "queued"}, True
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
sessions = _ChatSessionStore()
|
||||
jobs = _CapturingJobStore()
|
||||
response = await deep_research.start_job(
|
||||
"drs_1",
|
||||
deep_research.StartJobRequest(
|
||||
entry="chat",
|
||||
config={"generate_images": True, "max_generated_images": 3},
|
||||
),
|
||||
_request(sessions=sessions, jobs=jobs, dispatcher=_Dispatcher()),
|
||||
)
|
||||
|
||||
assert response["jobId"] == "drj_images"
|
||||
assert jobs.created is not None
|
||||
snapshot = jobs.created["input_snapshot"]["config"]
|
||||
assert snapshot["generate_images"] is True
|
||||
assert snapshot["max_generated_images"] == 3
|
||||
# The session snapshot is persisted too, so a reload/replay keeps the
|
||||
# write-time choice instead of reverting to the creation-time false.
|
||||
assert any(
|
||||
update.get("config_snapshot", {}).get("generate_images") is True
|
||||
for update in sessions.updates
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_report_variant_uses_normal_job_with_selected_sources(monkeypatch):
|
||||
"""Regeneration must queue the original report engine, never a rewrite job."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
class _VariantSessionStore(_SessionStore):
|
||||
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
return {
|
||||
"id": session_id,
|
||||
"query": "新能源汽车市场",
|
||||
"title": "新能源汽车市场 · 新结构报告",
|
||||
"status": "draft",
|
||||
"runtime_thread_id": "dr_variant_thread",
|
||||
"config_snapshot": {
|
||||
"mode": "basic",
|
||||
"collection_mode": "chat",
|
||||
"report_variant": True,
|
||||
"parent_session_id": "drs_parent",
|
||||
},
|
||||
}
|
||||
|
||||
class _SelectedSources:
|
||||
async def count_by_session(self, *args, **kwargs): # noqa: ANN002, ANN003
|
||||
return 12
|
||||
|
||||
class _CapturingJobStore(_JobStore):
|
||||
def __init__(self) -> None:
|
||||
self.created: dict | None = None
|
||||
|
||||
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
|
||||
self.created = kwargs
|
||||
return {"id": "drj_regenerate", "status": "queued"}, True
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
sessions = _VariantSessionStore()
|
||||
jobs = _CapturingJobStore()
|
||||
response = await deep_research.start_job(
|
||||
"drs_variant",
|
||||
deep_research.StartJobRequest(
|
||||
entry="regenerate",
|
||||
config={
|
||||
"custom_outline": "# 新结构\n\n## 第四章",
|
||||
"report_instruction": "统一表达并保留可核验事实。",
|
||||
},
|
||||
),
|
||||
_request(
|
||||
sessions=sessions,
|
||||
jobs=jobs,
|
||||
dispatcher=_Dispatcher(),
|
||||
sources=_SelectedSources(),
|
||||
),
|
||||
)
|
||||
|
||||
assert response["jobId"] == "drj_regenerate"
|
||||
snapshot = jobs.created["input_snapshot"]
|
||||
assert snapshot["entry"] == "regenerate"
|
||||
assert snapshot["config"]["custom_outline"].endswith("## 第四章")
|
||||
assert snapshot["config"]["report_instruction"] == "统一表达并保留可核验事实。"
|
||||
assert "report_variant" not in snapshot["config"]
|
||||
assert "parent_session_id" not in snapshot["config"]
|
||||
assert any(
|
||||
update.get("config_snapshot", {}).get("report_variant") is True
|
||||
for update in sessions.updates
|
||||
)
|
||||
assert any(
|
||||
update.get("config_snapshot", {}).get("parent_session_id") == "drs_parent"
|
||||
for update in sessions.updates
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_stream_stays_open_when_durable_replay_has_a_transient_failure(monkeypatch):
|
||||
"""A stream DB blip must yield a recoverable warning, not an ASGI error group."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
class _StreamJobStore:
|
||||
async def get(self, job_id: str, *, user_id: str): # noqa: ARG002
|
||||
return {"id": job_id, "session_id": "drs_1"}
|
||||
|
||||
async def get_unscoped(self, job_id: str): # noqa: ARG002
|
||||
return None
|
||||
|
||||
class _UnavailableEventStore:
|
||||
async def list_after(self, *args, **kwargs): # noqa: ANN002, ANN003
|
||||
raise RuntimeError("temporary replica failure")
|
||||
|
||||
async def is_connected() -> bool:
|
||||
return False
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
request = SimpleNamespace(
|
||||
app=SimpleNamespace(
|
||||
state=SimpleNamespace(
|
||||
deep_research_job_store=_StreamJobStore(),
|
||||
deep_research_event_store=_UnavailableEventStore(),
|
||||
)
|
||||
),
|
||||
is_disconnected=is_connected,
|
||||
)
|
||||
|
||||
response = await deep_research.stream_job("drj_1", request)
|
||||
chunk = await anext(response.body_iterator)
|
||||
await response.body_iterator.aclose()
|
||||
|
||||
assert "durable_replay_temporarily_unavailable" in chunk
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_full_report_rewrite_persists_selected_report_structure(monkeypatch):
|
||||
"""A selected structure must survive durable replay and constrain the worker."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
class _CompletedSessionStore(_SessionStore):
|
||||
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
return {
|
||||
"id": session_id,
|
||||
"query": "测试主题",
|
||||
"title": "测试主题",
|
||||
"status": "completed",
|
||||
"report_markdown": "# 原报告\n\n原有内容。",
|
||||
"config_snapshot": {"mode": "basic"},
|
||||
}
|
||||
|
||||
class _SourceStore:
|
||||
async def list_by_session(self, *args, **kwargs): # noqa: ANN002, ANN003
|
||||
# SQL-backed historical sources return native datetimes, whereas
|
||||
# the job snapshot is persisted as a JSON column.
|
||||
return [{"id": "src_1", "created_at": datetime(2026, 8, 21, tzinfo=UTC)}]
|
||||
|
||||
class _CapturingJobStore(_JobStore):
|
||||
def __init__(self) -> None:
|
||||
self.created: dict | None = None
|
||||
|
||||
async def try_create_or_get_active(self, **kwargs): # noqa: ANN003
|
||||
# Match the repository's JSON persistence boundary. This used to
|
||||
# raise TypeError for historical source rows with datetime fields.
|
||||
json.dumps(kwargs["input_snapshot"], ensure_ascii=False)
|
||||
self.created = kwargs
|
||||
return {"id": "drj_rewrite", "status": "queued"}, True
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
jobs = _CapturingJobStore()
|
||||
outline = "# 执行摘要\n\n# 一、核心发现\n\n# 二、行动建议"
|
||||
response = await deep_research.start_full_report_rewrite_job(
|
||||
"drs_1",
|
||||
deep_research.FullReportRewriteRequest(
|
||||
instruction="压缩重复段落,保持事实准确。",
|
||||
reportOutline=outline,
|
||||
operation="generate",
|
||||
),
|
||||
_request(
|
||||
sessions=_CompletedSessionStore(),
|
||||
jobs=jobs,
|
||||
dispatcher=_Dispatcher(),
|
||||
sources=_SourceStore(),
|
||||
),
|
||||
)
|
||||
|
||||
assert response["jobId"] == "drj_rewrite"
|
||||
assert jobs.created is not None
|
||||
snapshot = jobs.created["input_snapshot"]
|
||||
assert snapshot["operation"] == "generate"
|
||||
assert snapshot["report_outline"] == outline
|
||||
assert "【报告结构要求】" in snapshot["instruction"]
|
||||
assert "# 一、核心发现" in snapshot["instruction"]
|
||||
assert snapshot["sources"][0]["created_at"] == "2026-08-21T00:00:00+00:00"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_regeneration_forks_report_and_selected_sources(monkeypatch):
|
||||
"""Choosing another structure must never mutate the completed parent report."""
|
||||
|
||||
async def fake_require_user(request): # noqa: ANN001
|
||||
return "u1"
|
||||
|
||||
class _VariantSessionStore:
|
||||
def __init__(self) -> None:
|
||||
self.parent = {
|
||||
"id": "drs_parent",
|
||||
"user_id": "u1",
|
||||
"title": "新能源研究",
|
||||
"query": "新能源市场",
|
||||
"mode": "basic",
|
||||
"status": "completed",
|
||||
"report_markdown": (
|
||||
"# 原报告\n\n"
|
||||
"已保存引用 [来源:src_parent];"
|
||||
"流式引用 [[source:src_parent]];"
|
||||
"已取消的资料 [[source:src_unselected]]。"
|
||||
),
|
||||
"config_snapshot": {"mode": "basic", "custom_outline": "# 原结构"},
|
||||
"source_count": 1,
|
||||
}
|
||||
self.created: dict | None = None
|
||||
self.updated: dict | None = None
|
||||
self.deleted: list[str] = []
|
||||
|
||||
async def get(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
return self.parent if session_id == "drs_parent" else None
|
||||
|
||||
async def create(self, **fields): # noqa: ANN003
|
||||
self.created = fields
|
||||
return {**fields, "report_markdown": None, "source_count": 0}
|
||||
|
||||
async def update(self, session_id: str, *, user_id: str, **fields): # noqa: ARG002
|
||||
self.updated = {"session_id": session_id, **fields}
|
||||
return {
|
||||
"id": session_id,
|
||||
"user_id": "u1",
|
||||
"title": self.created["title"] if self.created else "",
|
||||
"query": "新能源市场",
|
||||
"mode": "basic",
|
||||
"status": self.created["status"] if self.created else "draft",
|
||||
"config_snapshot": self.created["config_snapshot"] if self.created else {},
|
||||
**fields,
|
||||
}
|
||||
|
||||
async def delete(self, session_id: str, *, user_id: str): # noqa: ARG002
|
||||
self.deleted.append(session_id)
|
||||
return True
|
||||
|
||||
class _VariantSourceStore:
|
||||
async def clone_selected_to_session(self, source_session_id: str, target_session_id: str, *, user_id: str): # noqa: ARG002
|
||||
assert source_session_id == "drs_parent"
|
||||
assert target_session_id.startswith("drs_")
|
||||
return {"src_parent": "src_variant"}
|
||||
|
||||
monkeypatch.setattr(deep_research, "_require_user", fake_require_user)
|
||||
async def fake_ensure_runtime_thread(request, session, user_id): # noqa: ANN001, ARG001
|
||||
await sessions.update(session["id"], user_id=user_id, runtime_thread_id="dr_variant_thread")
|
||||
|
||||
sessions = _VariantSessionStore()
|
||||
monkeypatch.setattr(deep_research, "_ensure_chat_runtime_thread", fake_ensure_runtime_thread)
|
||||
response = await deep_research.create_report_variant(
|
||||
"drs_parent",
|
||||
deep_research.CreateReportVariantRequest(reportOutline="# 新结构\n\n## 结论"),
|
||||
_request(
|
||||
sessions=sessions,
|
||||
jobs=_JobStore(),
|
||||
dispatcher=_Dispatcher(),
|
||||
sources=_VariantSourceStore(),
|
||||
),
|
||||
)
|
||||
|
||||
assert response.id != "drs_parent"
|
||||
assert response.title == "新能源研究 · 新结构报告"
|
||||
assert response.report_markdown is None
|
||||
assert response.status == "draft"
|
||||
assert response.config == {
|
||||
"mode": "basic",
|
||||
"custom_outline": "# 新结构\n\n## 结论",
|
||||
"report_variant": True,
|
||||
"parent_session_id": "drs_parent",
|
||||
}
|
||||
assert sessions.parent["report_markdown"] == (
|
||||
"# 原报告\n\n"
|
||||
"已保存引用 [来源:src_parent];"
|
||||
"流式引用 [[source:src_parent]];"
|
||||
"已取消的资料 [[source:src_unselected]]。"
|
||||
)
|
||||
assert sessions.updated is not None
|
||||
assert sessions.updated["source_count"] == 1
|
||||
assert sessions.deleted == []
|
||||
|
||||
|
||||
def test_normalise_citations_accepts_display_ready_and_legacy_markers() -> None:
|
||||
source_ids = {"drs_src_1234567890abcdef1234567890abcdef"}
|
||||
|
||||
result, cited = report_rewrite._normalise_citations( # noqa: SLF001
|
||||
"甲[来源:drs_src_1234567890abcdef1234567890abcdef];"
|
||||
"乙[[source:drs_src_1234567890abcdef1234567890abcdef]];"
|
||||
"丙[来源: drs_src_1234567890abcdef1234567890abcdef]。",
|
||||
source_ids,
|
||||
)
|
||||
|
||||
assert result == (
|
||||
"甲[来源:drs_src_1234567890abcdef1234567890abcdef];"
|
||||
"乙[来源:drs_src_1234567890abcdef1234567890abcdef];"
|
||||
"丙[来源:drs_src_1234567890abcdef1234567890abcdef]。"
|
||||
)
|
||||
assert cited == ["drs_src_1234567890abcdef1234567890abcdef"]
|
||||
|
||||
|
||||
def test_normalise_citations_repairs_unique_truncated_selected_id() -> None:
|
||||
full_id = "drs_src_ac653c4a6f364e59a30b044e98d32e2f"
|
||||
|
||||
result, cited = report_rewrite._normalise_citations( # noqa: SLF001
|
||||
"事实[来源:drs_src_ac653c4a6f364e59a30b044e98d32e]。",
|
||||
{full_id},
|
||||
)
|
||||
|
||||
assert result == f"事实[来源:{full_id}]。"
|
||||
assert cited == [full_id]
|
||||
|
||||
|
||||
def test_normalise_citations_still_rejects_unknown_source() -> None:
|
||||
with pytest.raises(ValueError, match="未选资料来源"):
|
||||
report_rewrite._normalise_citations( # noqa: SLF001
|
||||
"事实[来源:drs_src_ffffffffffffffffffffffffffffffff]。",
|
||||
{"drs_src_ac653c4a6f364e59a30b044e98d32e2f"},
|
||||
)
|
||||
|
||||
|
||||
def test_normalise_citations_removes_provider_truncated_marker_without_discarding_report() -> None:
|
||||
result, cited = report_rewrite._normalise_citations( # noqa: SLF001
|
||||
"# 参考资料\n\n已完成的正文。\n[来源:drs_src_ac653c4a6f364e59a30b044e98d32",
|
||||
{"drs_src_ac653c4a6f364e59a30b044e98d32e2f"},
|
||||
)
|
||||
|
||||
assert result == "# 参考资料\n\n已完成的正文。"
|
||||
assert cited == []
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_generate_operation_uses_selected_sources_not_inherited_report(monkeypatch) -> None:
|
||||
captured: dict = {}
|
||||
|
||||
class _CompletionBackend:
|
||||
def __init__(self, config) -> None: # noqa: ANN001
|
||||
captured["config"] = config
|
||||
|
||||
async def stream_complete(self, **kwargs): # noqa: ANN003
|
||||
captured.update(kwargs)
|
||||
return SimpleNamespace(
|
||||
text=(
|
||||
"# 新报告\n\n事实[来源:drs_src_1234567890abcdef1234567890abcdef]。\n\n"
|
||||
"<!-- DEERFLOW_REPORT_COMPLETE -->"
|
||||
),
|
||||
usage={},
|
||||
)
|
||||
|
||||
monkeypatch.setattr(report_rewrite, "DeerFlowCompletionBackend", _CompletionBackend)
|
||||
|
||||
async def _ignore(_delta: str) -> None:
|
||||
return None
|
||||
|
||||
result, cited, _usage = await report_rewrite.stream_full_report_rewrite(
|
||||
session={"config_snapshot": {"mode": "basic"}, "query": "新能源汽车"},
|
||||
report="# 不应进入模型的旧报告\n\n旧结构和旧措辞。",
|
||||
sources=[
|
||||
{
|
||||
"id": "drs_src_1234567890abcdef1234567890abcdef",
|
||||
"title": "已选资料",
|
||||
"raw_content": "可核验事实",
|
||||
}
|
||||
],
|
||||
instruction="按新结构生成",
|
||||
style="formal_analysis",
|
||||
model_name=None,
|
||||
on_delta=_ignore,
|
||||
operation="generate",
|
||||
)
|
||||
|
||||
prompt = "\n".join(str(message["content"]) for message in captured["messages"])
|
||||
assert "不应进入模型的旧报告" not in prompt
|
||||
assert "# 已选来源" in prompt
|
||||
assert captured["operation"] == "full_report_generate"
|
||||
assert captured["max_tokens"] == 8_192
|
||||
assert result.endswith("[来源:drs_src_1234567890abcdef1234567890abcdef]。")
|
||||
assert cited == ["drs_src_1234567890abcdef1234567890abcdef"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_report_generation_continues_when_first_segment_has_no_completion_marker(monkeypatch) -> None:
|
||||
calls: list[str] = []
|
||||
|
||||
class _CompletionBackend:
|
||||
def __init__(self, _config) -> None: # noqa: ANN001
|
||||
pass
|
||||
|
||||
async def stream_complete(self, **kwargs): # noqa: ANN003
|
||||
calls.append(str(kwargs["operation"]))
|
||||
if len(calls) == 1:
|
||||
return SimpleNamespace(text="# 新报告\n\n第一部分。", usage={"completion_tokens": 100})
|
||||
return SimpleNamespace(
|
||||
text="## 第二部分\n\n续写完成。\n\n<!-- DEERFLOW_REPORT_COMPLETE -->",
|
||||
usage={"completion_tokens": 50},
|
||||
)
|
||||
|
||||
monkeypatch.setattr(report_rewrite, "DeerFlowCompletionBackend", _CompletionBackend)
|
||||
|
||||
async def _ignore(_delta: str) -> None:
|
||||
return None
|
||||
|
||||
result, cited, usage = await report_rewrite.stream_full_report_rewrite(
|
||||
session={"config_snapshot": {"mode": "basic"}, "query": "新能源汽车"},
|
||||
report="# 旧报告",
|
||||
sources=[],
|
||||
instruction="按新结构生成",
|
||||
style="formal_analysis",
|
||||
model_name=None,
|
||||
on_delta=_ignore,
|
||||
operation="generate",
|
||||
)
|
||||
|
||||
assert calls == ["full_report_generate", "full_report_generate_continue"]
|
||||
assert result == "# 新报告\n\n第一部分。\n\n## 第二部分\n\n续写完成。"
|
||||
assert cited == []
|
||||
assert usage["completion_tokens"] == 150
|
||||
@@ -0,0 +1,396 @@
|
||||
"""Regression tests for owner-scoped enterprise-research task persistence."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
from types import SimpleNamespace
|
||||
|
||||
import pytest
|
||||
import pytest_asyncio
|
||||
from fastapi import FastAPI
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
||||
|
||||
from deerflow.persistence.base import Base
|
||||
from deerflow.persistence.enterprise_research import (
|
||||
EnterpriseResearchReportJobRepository,
|
||||
EnterpriseResearchTaskRepository,
|
||||
MemoryEnterpriseResearchReportJobStore,
|
||||
MemoryEnterpriseResearchTaskStore,
|
||||
make_enterprise_research_task_store,
|
||||
)
|
||||
|
||||
|
||||
@pytest_asyncio.fixture
|
||||
async def store(tmp_path):
|
||||
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'enterprise-research.db'}")
|
||||
async with engine.begin() as conn:
|
||||
import deerflow.persistence.enterprise_research.model # noqa: F401
|
||||
|
||||
await conn.run_sync(Base.metadata.create_all)
|
||||
return EnterpriseResearchTaskRepository(async_sessionmaker(engine, expire_on_commit=False))
|
||||
|
||||
|
||||
async def _create(store, *, task_id: str, user_id: str = "u1"):
|
||||
return await store.create_task(
|
||||
{
|
||||
"id": task_id,
|
||||
"user_id": user_id,
|
||||
"subject": "新能源汽车供应链风险",
|
||||
"focus": "关键原材料",
|
||||
"template_id": "topic",
|
||||
"knowledge_base_ids": ["kb-1"],
|
||||
"queries": ["新能源汽车供应链风险", "关键原材料"],
|
||||
"status": "draft",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_task_evidence_roundtrip_and_owner_isolation(store: EnterpriseResearchTaskRepository):
|
||||
created = await _create(store, task_id="ert-1")
|
||||
assert created["sources"] == []
|
||||
assert created["status"] == "draft"
|
||||
|
||||
updated = await store.update_task(
|
||||
"ert-1",
|
||||
"u1",
|
||||
{
|
||||
"status": "ready",
|
||||
"selected_source_ids": ["chunk-1"],
|
||||
"plan_markdown": "# 供应链风险研究计划",
|
||||
"sources": [
|
||||
{
|
||||
"chunk_id": "chunk-1",
|
||||
"title": "供应链报告",
|
||||
"content": "证据内容",
|
||||
"knowledge_base_id": "kb-1",
|
||||
}
|
||||
],
|
||||
},
|
||||
)
|
||||
assert updated is not None
|
||||
assert updated["status"] == "ready"
|
||||
assert updated["sources"][0]["chunk_id"] == "chunk-1"
|
||||
assert updated["selected_source_ids"] == ["chunk-1"]
|
||||
assert updated["plan_markdown"] == "# 供应链风险研究计划"
|
||||
assert await store.get_task("ert-1", "u2") is None
|
||||
assert await store.update_task("ert-1", "u2", {"status": "failed"}) is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_is_owner_scoped_and_delete_requires_owner(store: EnterpriseResearchTaskRepository):
|
||||
await _create(store, task_id="ert-u1", user_id="u1")
|
||||
await _create(store, task_id="ert-u2", user_id="u2")
|
||||
assert [task["id"] for task in await store.list_tasks("u1")] == ["ert-u1"]
|
||||
assert await store.delete_task("ert-u1", "u2") is False
|
||||
assert await store.delete_task("ert-u1", "u1") is True
|
||||
assert await store.get_task("ert-u1", "u1") is None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_memory_store_matches_sql_contract():
|
||||
store = make_enterprise_research_task_store(None)
|
||||
assert isinstance(store, MemoryEnterpriseResearchTaskStore)
|
||||
await _create(store, task_id="memory-1")
|
||||
assert (await store.get_task("memory-1", "u1"))["subject"] == "新能源汽车供应链风险"
|
||||
assert await store.delete_task("memory-1", "u1") is True
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_report_job_freezes_sources_and_is_owner_scoped(tmp_path):
|
||||
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'enterprise-report-job.db'}")
|
||||
async with engine.begin() as conn:
|
||||
import deerflow.persistence.enterprise_research.model # noqa: F401
|
||||
|
||||
await conn.run_sync(Base.metadata.create_all)
|
||||
jobs = EnterpriseResearchReportJobRepository(async_sessionmaker(engine, expire_on_commit=False))
|
||||
created = await jobs.create_job(
|
||||
{
|
||||
"id": "erj-1", "task_id": "ert-1", "user_id": "u1", "plan_snapshot": "# 计划",
|
||||
"sources": [{"chunk_id": "source-1", "content": "冻结证据"}],
|
||||
"action": "rewrite", "instruction": "优化结构", "original_report": "# 原报告",
|
||||
}
|
||||
)
|
||||
assert created["status"] == "queued"
|
||||
assert created["sources"][0]["content"] == "冻结证据"
|
||||
assert created["action"] == "rewrite"
|
||||
assert created["original_report"] == "# 原报告"
|
||||
deduplicated = await jobs.create_job(
|
||||
{
|
||||
"id": "erj-duplicate", "task_id": "ert-1", "user_id": "u1", "plan_snapshot": "# 其他计划",
|
||||
"sources": [], "action": "initial",
|
||||
}
|
||||
)
|
||||
assert deduplicated["id"] == "erj-1"
|
||||
assert await jobs.get_job("erj-1", "u2") is None
|
||||
assert (await jobs.get_active_for_task("ert-1", "u1"))["id"] == "erj-1"
|
||||
assert await jobs.claim_job("erj-1", "u1") is True
|
||||
assert await jobs.claim_job("erj-1", "u1") is False
|
||||
running = (await jobs.list_recoverable())[0]
|
||||
assert running["status"] == "running"
|
||||
assert await jobs.requeue_job("erj-1", "u1", expected_updated_at="stale-snapshot") is False
|
||||
assert await jobs.requeue_job("erj-1", "u1", expected_updated_at=running["updated_at"]) is True
|
||||
assert await jobs.requeue_job("erj-1", "u1", expected_updated_at=running["updated_at"]) is False
|
||||
assert await jobs.claim_job("erj-1", "u1") is True
|
||||
completed = await jobs.transition_job(
|
||||
"erj-1", "u1", expected_statuses={"running"},
|
||||
data={"status": "completed", "phase": "completed", "report_markdown": "# 报告"},
|
||||
)
|
||||
assert completed is not None and completed["report_markdown"] == "# 报告"
|
||||
assert await jobs.transition_job(
|
||||
"erj-1", "u1", expected_statuses={"running"}, data={"status": "cancelled"}
|
||||
) is None
|
||||
assert await jobs.get_active_for_task("ert-1", "u1") is None
|
||||
next_job = await jobs.create_job(
|
||||
{"id": "erj-2", "task_id": "ert-1", "user_id": "u1", "plan_snapshot": "# 新计划", "sources": []}
|
||||
)
|
||||
assert next_job["id"] == "erj-2"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_memory_report_job_store_has_matching_owner_contract():
|
||||
jobs = MemoryEnterpriseResearchReportJobStore()
|
||||
await jobs.create_job({"id": "memory-job", "task_id": "task", "user_id": "u1", "plan_snapshot": "x"})
|
||||
assert await jobs.get_job("memory-job", "u2") is None
|
||||
assert (await jobs.list_jobs("task", "u1"))[0]["id"] == "memory-job"
|
||||
assert await jobs.claim_job("memory-job", "u1") is True
|
||||
assert await jobs.claim_job("memory-job", "u1") is False
|
||||
running = await jobs.get_job("memory-job", "u1")
|
||||
assert running is not None
|
||||
assert await jobs.requeue_job("memory-job", "u1", expected_updated_at=running["updated_at"]) is True
|
||||
assert await jobs.claim_job("memory-job", "u1") is True
|
||||
completed = await jobs.transition_job(
|
||||
"memory-job", "u1", expected_statuses={"running"}, data={"status": "completed", "phase": "completed"}
|
||||
)
|
||||
assert completed is not None and completed["status"] == "completed"
|
||||
|
||||
|
||||
def test_evidence_snapshot_deduplicates_and_never_exposes_unmapped_remote_bases():
|
||||
from app.gateway.routers.enterprise_research import _dedupe_evidence
|
||||
|
||||
mappings = {"remote-kb-1": {"id": "local-kb-1", "name": "用户可见知识库", "weknora_id": "remote-kb-1"}}
|
||||
evidence = _dedupe_evidence(
|
||||
[
|
||||
{"chunk_id": "chunk-1", "content": "第一段", "knowledge_base_id": "remote-kb-1", "title": "文档 A"},
|
||||
{"chunk_id": "chunk-1", "content": "重复段", "knowledge_base_id": "remote-kb-1", "title": "文档 A"},
|
||||
{"chunk_id": "private-chunk", "content": "不应显示", "knowledge_base_id": "other-user-kb", "title": "私有文档"},
|
||||
],
|
||||
mappings,
|
||||
)
|
||||
assert len(evidence) == 1
|
||||
assert evidence[0]["knowledge_base_id"] == "local-kb-1"
|
||||
assert "other-user-kb" not in str(evidence)
|
||||
|
||||
|
||||
def test_report_executor_uses_distinct_initial_rewrite_and_followup_prompts():
|
||||
from app.gateway.enterprise_research_report_executor import EnterpriseResearchReportExecutor
|
||||
|
||||
base = {
|
||||
"plan_snapshot": "# 计划",
|
||||
"sources": [{"chunk_id": "source-1", "title": "内部资料", "content": "证据正文"}],
|
||||
"original_report": "# 原报告\n原始正文",
|
||||
"instruction": "压缩重复段落",
|
||||
"target_length": 3_000,
|
||||
"style": "analytical",
|
||||
}
|
||||
initial = EnterpriseResearchReportExecutor._messages({**base, "action": "initial"})
|
||||
rewrite = EnterpriseResearchReportExecutor._messages({**base, "action": "rewrite"})
|
||||
followup = EnterpriseResearchReportExecutor._messages({**base, "action": "followup"})
|
||||
|
||||
assert "完整 Markdown 报告" in initial[0]["content"]
|
||||
assert "原报告" not in initial[1]["content"]
|
||||
assert "全文改写" in rewrite[1]["content"] and "# 原报告" in rewrite[1]["content"]
|
||||
assert "不要重写整篇报告" in followup[0]["content"]
|
||||
assert "压缩重复段落" in followup[1]["content"]
|
||||
summary = EnterpriseResearchReportExecutor._summary(
|
||||
"# 新报告\n\n新正文", 2, "rewrite", original_report="# 旧报告\n\n旧正文", instruction="调整结构"
|
||||
)
|
||||
assert "原文" in summary and "标题节点 1→1" in summary and "调整结构" in summary
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_executor_recovery_requeues_exact_running_snapshot(monkeypatch):
|
||||
from app.gateway.enterprise_research_report_executor import EnterpriseResearchReportExecutor
|
||||
|
||||
tasks = MemoryEnterpriseResearchTaskStore()
|
||||
jobs = MemoryEnterpriseResearchReportJobStore()
|
||||
await jobs.create_job({"id": "recover-job", "task_id": "task", "user_id": "u1", "plan_snapshot": "# 计划"})
|
||||
assert await jobs.claim_job("recover-job", "u1") is True
|
||||
executor = EnterpriseResearchReportExecutor(tasks, jobs)
|
||||
started: list[tuple[str, str]] = []
|
||||
|
||||
async def remember(job_id: str, user_id: str) -> None:
|
||||
started.append((job_id, user_id))
|
||||
|
||||
monkeypatch.setattr(executor, "ensure_started", remember)
|
||||
await executor.recover_pending()
|
||||
|
||||
recovered = await jobs.get_job("recover-job", "u1")
|
||||
assert recovered is not None and recovered["status"] == "queued"
|
||||
assert started == [("recover-job", "u1")]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_enterprise_research_http_plan_job_dedupe_and_cancel(monkeypatch):
|
||||
import app.gateway.routers.enterprise_research as enterprise_router
|
||||
|
||||
tasks = MemoryEnterpriseResearchTaskStore()
|
||||
jobs = MemoryEnterpriseResearchReportJobStore()
|
||||
|
||||
class NoopExecutor:
|
||||
def __init__(self) -> None:
|
||||
self.started: list[tuple[str, str]] = []
|
||||
|
||||
async def ensure_started(self, job_id: str, user_id: str) -> None:
|
||||
self.started.append((job_id, user_id))
|
||||
|
||||
async def cancel(self, job_id: str, user_id: str):
|
||||
job = await jobs.get_job(job_id, user_id)
|
||||
if job is None:
|
||||
return None
|
||||
cancelled = await jobs.transition_job(
|
||||
job_id, user_id, expected_statuses={"queued", "running"},
|
||||
data={"status": "cancelled", "phase": "cancelled"},
|
||||
)
|
||||
await tasks.update_task(job["task_id"], user_id, {"active_report_job_id": None})
|
||||
return cancelled
|
||||
|
||||
async def anonymous_actor(_request):
|
||||
return None
|
||||
|
||||
monkeypatch.setattr(enterprise_router, "get_optional_user_from_request", anonymous_actor)
|
||||
app = FastAPI()
|
||||
app.include_router(enterprise_router.router)
|
||||
app.state.enterprise_research_task_store = tasks
|
||||
app.state.enterprise_research_report_job_store = jobs
|
||||
app.state.enterprise_research_report_executor = NoopExecutor()
|
||||
async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
|
||||
created = await client.post(
|
||||
"/api/enterprise-research/tasks",
|
||||
json={"subject": "企业风险", "queries": ["企业风险"], "knowledge_base_ids": []},
|
||||
)
|
||||
assert created.status_code == 201
|
||||
task_id = created.json()["id"]
|
||||
await tasks.update_task(
|
||||
task_id, "default",
|
||||
{
|
||||
"status": "ready", "selected_source_ids": ["source-1"],
|
||||
"sources": [{"chunk_id": "source-1", "title": "内部材料", "content": "已核验事实"}],
|
||||
},
|
||||
)
|
||||
plan = await client.post(f"/api/enterprise-research/tasks/{task_id}/plan/draft")
|
||||
assert plan.status_code == 200 and plan.json()["plan_markdown"]
|
||||
saved = await client.put(
|
||||
f"/api/enterprise-research/tasks/{task_id}/plan",
|
||||
json={"plan_markdown": "# 企业风险报告", "selected_source_ids": ["source-1"]},
|
||||
)
|
||||
assert saved.status_code == 200
|
||||
first = await client.post(
|
||||
f"/api/enterprise-research/tasks/{task_id}/report-jobs",
|
||||
json={"action": "initial", "style": "formal", "target_length": 2_000},
|
||||
)
|
||||
assert first.status_code == 201
|
||||
duplicate = await client.post(
|
||||
f"/api/enterprise-research/tasks/{task_id}/report-jobs",
|
||||
json={"action": "initial"},
|
||||
)
|
||||
assert duplicate.status_code == 201 and duplicate.json()["id"] == first.json()["id"]
|
||||
cancelled = await client.post(
|
||||
f"/api/enterprise-research/tasks/{task_id}/report-jobs/{first.json()['id']}/cancel"
|
||||
)
|
||||
assert cancelled.status_code == 200 and cancelled.json()["status"] == "cancelled"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_executor_stream_commit_separates_reasoning_and_followup(monkeypatch):
|
||||
import app.gateway.enterprise_research_report_executor as executor_module
|
||||
|
||||
tasks = MemoryEnterpriseResearchTaskStore()
|
||||
jobs = MemoryEnterpriseResearchReportJobStore()
|
||||
await _create(tasks, task_id="stream-task")
|
||||
await tasks.update_task(
|
||||
"stream-task", "u1",
|
||||
{"plan_markdown": "# 研究计划", "report_markdown": "# 旧报告", "report_summary": "旧摘要"},
|
||||
)
|
||||
|
||||
class FakeBackend:
|
||||
def __init__(self, _config) -> None:
|
||||
pass
|
||||
|
||||
async def stream_complete(self, *, messages, on_delta, on_reasoning, **_kwargs):
|
||||
is_followup = "不要重写整篇报告" in messages[0]["content"]
|
||||
text = "追问回答" if is_followup else "# 新报告\n正文 [资料:source-1]"
|
||||
await on_reasoning("模型内部思考")
|
||||
for delta in (text[:4], text[4:]):
|
||||
await on_delta(delta)
|
||||
return SimpleNamespace(text=text, model="fake-model")
|
||||
|
||||
monkeypatch.setattr(executor_module, "DeerFlowCompletionBackend", FakeBackend)
|
||||
executor = executor_module.EnterpriseResearchReportExecutor(tasks, jobs)
|
||||
await jobs.create_job(
|
||||
{
|
||||
"id": "initial-job", "task_id": "stream-task", "user_id": "u1", "plan_snapshot": "# 研究计划",
|
||||
"sources": [{"chunk_id": "source-1", "content": "证据"}], "action": "initial",
|
||||
}
|
||||
)
|
||||
await executor._run("initial-job", "u1")
|
||||
completed = await jobs.get_job("initial-job", "u1")
|
||||
task = await tasks.get_task("stream-task", "u1")
|
||||
assert completed is not None and completed["status"] == "completed"
|
||||
assert completed["report_markdown"] == "# 新报告\n正文 [资料:source-1]"
|
||||
assert "模型内部思考" not in completed["report_markdown"]
|
||||
assert task is not None and task["report_markdown"] == completed["report_markdown"]
|
||||
|
||||
await jobs.create_job(
|
||||
{
|
||||
"id": "followup-job", "task_id": "stream-task", "user_id": "u1", "plan_snapshot": "# 研究计划",
|
||||
"sources": [{"chunk_id": "source-1", "content": "证据"}], "action": "followup",
|
||||
"instruction": "结论是什么", "original_report": completed["report_markdown"],
|
||||
}
|
||||
)
|
||||
await executor._run("followup-job", "u1")
|
||||
followup = await jobs.get_job("followup-job", "u1")
|
||||
unchanged = await tasks.get_task("stream-task", "u1")
|
||||
assert followup is not None and followup["report_markdown"] == "追问回答"
|
||||
assert unchanged is not None and unchanged["report_markdown"] == completed["report_markdown"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_cross_process_cancel_cannot_be_overwritten_by_late_model_result(monkeypatch):
|
||||
import app.gateway.enterprise_research_report_executor as executor_module
|
||||
|
||||
tasks = MemoryEnterpriseResearchTaskStore()
|
||||
jobs = MemoryEnterpriseResearchReportJobStore()
|
||||
await _create(tasks, task_id="cancel-task")
|
||||
await tasks.update_task("cancel-task", "u1", {"report_markdown": "# 已保存报告"})
|
||||
await jobs.create_job(
|
||||
{"id": "cancel-job", "task_id": "cancel-task", "user_id": "u1", "plan_snapshot": "# 计划"}
|
||||
)
|
||||
started = asyncio.Event()
|
||||
release = asyncio.Event()
|
||||
|
||||
class SlowBackend:
|
||||
def __init__(self, _config) -> None:
|
||||
pass
|
||||
|
||||
async def stream_complete(self, *, on_delta, **_kwargs):
|
||||
started.set()
|
||||
await release.wait()
|
||||
await on_delta("# 不应提交的迟到结果")
|
||||
return SimpleNamespace(text="# 不应提交的迟到结果", model="fake-model")
|
||||
|
||||
monkeypatch.setattr(executor_module, "DeerFlowCompletionBackend", SlowBackend)
|
||||
writer = executor_module.EnterpriseResearchReportExecutor(tasks, jobs)
|
||||
remote_gateway = executor_module.EnterpriseResearchReportExecutor(tasks, jobs)
|
||||
running = asyncio.create_task(writer._run("cancel-job", "u1"))
|
||||
await started.wait()
|
||||
cancelled = await remote_gateway.cancel("cancel-job", "u1")
|
||||
assert cancelled is not None and cancelled["status"] == "cancelled"
|
||||
release.set()
|
||||
with pytest.raises(asyncio.CancelledError):
|
||||
await running
|
||||
final_job = await jobs.get_job("cancel-job", "u1")
|
||||
final_task = await tasks.get_task("cancel-task", "u1")
|
||||
assert final_job is not None and final_job["status"] == "cancelled"
|
||||
assert final_task is not None and final_task["report_markdown"] == "# 已保存报告"
|
||||
@@ -6,6 +6,7 @@ from types import SimpleNamespace
|
||||
import httpx
|
||||
import pytest
|
||||
from fastapi import FastAPI, HTTPException
|
||||
from fastapi.responses import Response
|
||||
from starlette.datastructures import Headers, QueryParams
|
||||
from starlette.requests import Request
|
||||
|
||||
@@ -19,6 +20,8 @@ from deerflow.integrations.weknora.client import WeKnoraClient, WeKnoraError
|
||||
from deerflow.persistence.llmwiki import MemoryLlmWikiStore
|
||||
from deerflow.tools.builtins.llmwiki_search_tool import (
|
||||
_sanitize_conversation_deposit_value as sanitize_tool_deposit_value,
|
||||
)
|
||||
from deerflow.tools.builtins.llmwiki_search_tool import (
|
||||
selected_knowledge_base_ids,
|
||||
)
|
||||
|
||||
@@ -31,11 +34,9 @@ def _request(
|
||||
request_headers: dict[str, str] | None = None,
|
||||
root_path: str = "",
|
||||
) -> Request:
|
||||
headers: list[tuple[bytes, bytes]] = [
|
||||
(key.lower().encode(), value.encode()) for key, value in (request_headers or {}).items()
|
||||
]
|
||||
headers: list[tuple[bytes, bytes]] = [(key.lower().encode(), value.encode()) for key, value in (request_headers or {}).items()]
|
||||
if cookies:
|
||||
headers.append(("cookie".encode(), "; ".join(f"{key}={value}" for key, value in cookies.items()).encode()))
|
||||
headers.append((b"cookie", "; ".join(f"{key}={value}" for key, value in cookies.items()).encode()))
|
||||
return Request(
|
||||
{
|
||||
"type": "http",
|
||||
@@ -173,9 +174,7 @@ def test_weknora_embed_cookie_bypasses_only_proxy_paths() -> None:
|
||||
cookies = {"deerflow_weknora_embed": raw_cookie}
|
||||
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/platform/knowledge-bases/kb", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(
|
||||
_request("/deerflow/platform/knowledge-bases/kb", cookies=cookies)
|
||||
)
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/platform/knowledge-bases/kb", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/assets/index.js", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/assets/index.js", cookies=cookies))
|
||||
for static_path in (
|
||||
@@ -191,26 +190,14 @@ def test_weknora_embed_cookie_bypasses_only_proxy_paths() -> None:
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(request)
|
||||
assert csrf_middleware.is_weknora_embed_proxy_request(request)
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/config.js", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(
|
||||
_request("/tdesign-icons/0.4.1/fonts/index.js", cookies=cookies)
|
||||
)
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/tdesign-icons/0.4.1/fonts/index.js", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(
|
||||
_request("/deerflow/api/v1/knowledge-search", cookies=cookies)
|
||||
)
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(
|
||||
_request("/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies)
|
||||
)
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(
|
||||
_request("/deerflow/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies)
|
||||
)
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/api/v1/knowledge-search", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies))
|
||||
assert auth_middleware._is_weknora_embed_proxy_request(_request("/deerflow/api/llmwiki/weknora-embed/api/v1/auth/me", cookies=cookies))
|
||||
assert csrf_middleware.is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies=cookies))
|
||||
assert not auth_middleware._is_weknora_embed_proxy_request(
|
||||
_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"})
|
||||
)
|
||||
assert not csrf_middleware.is_weknora_embed_proxy_request(
|
||||
_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"})
|
||||
)
|
||||
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"}))
|
||||
assert not csrf_middleware.is_weknora_embed_proxy_request(_request("/api/v1/knowledge-search", cookies={"deerflow_weknora_embed": "signed"}))
|
||||
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/api/v1/auth/me", cookies=cookies))
|
||||
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/api/models", cookies=cookies))
|
||||
assert not auth_middleware._is_weknora_embed_proxy_request(_request("/platform/knowledge-bases/kb"))
|
||||
@@ -227,6 +214,12 @@ async def test_weknora_session_endpoint_sets_cookie_and_returns_platform_path(mo
|
||||
async def get_authorized(self, *_: object, **__: object) -> dict[str, str]:
|
||||
return {"id": "local-kb", "weknora_id": "remote-kb"}
|
||||
|
||||
async def list_visible(self, *_: object, **__: object) -> list[dict[str, str]]:
|
||||
return [
|
||||
{"id": "local-kb", "weknora_id": "remote-kb"},
|
||||
{"id": "public-kb", "weknora_id": "other-public-kb"},
|
||||
]
|
||||
|
||||
monkeypatch.setattr(llmwiki_router, "_runtime_for_iframe_proxy", lambda _: object())
|
||||
monkeypatch.setattr(llmwiki_router, "_authorized_mapping", authorized_mapping)
|
||||
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
|
||||
@@ -246,11 +239,7 @@ async def test_weknora_session_endpoint_sets_cookie_and_returns_platform_path(mo
|
||||
assert "deerflow_weknora_embed=" in cookie
|
||||
assert "Secure" in cookie
|
||||
assert "SameSite=none" in cookie
|
||||
set_cookie_headers = [
|
||||
value.decode("latin-1")
|
||||
for key, value in response.raw_headers
|
||||
if key.lower() == b"set-cookie"
|
||||
]
|
||||
set_cookie_headers = [value.decode("latin-1") for key, value in response.raw_headers if key.lower() == b"set-cookie"]
|
||||
assert any("Path=/" in value for value in set_cookie_headers)
|
||||
assert any("Path=/deerflow" in value for value in set_cookie_headers)
|
||||
raw = cookie.split("deerflow_weknora_embed=", 1)[1].split(";", 1)[0]
|
||||
@@ -258,6 +247,7 @@ async def test_weknora_session_endpoint_sets_cookie_and_returns_platform_path(mo
|
||||
assert ctx.mapping_id == "local-kb"
|
||||
assert ctx.weknora_id == "remote-kb"
|
||||
assert ctx.can_write is True
|
||||
assert ctx.allowed_weknora_ids == ("remote-kb", "other-public-kb")
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@@ -271,6 +261,9 @@ async def test_weknora_session_endpoint_preserves_reverse_proxy_prefix(monkeypat
|
||||
async def get_authorized(self, *_: object, **__: object) -> dict[str, str]:
|
||||
return {"id": "local-kb", "weknora_id": "remote-kb"}
|
||||
|
||||
async def list_visible(self, *_: object, **__: object) -> list[dict[str, str]]:
|
||||
return []
|
||||
|
||||
monkeypatch.setattr(llmwiki_router, "_runtime_for_iframe_proxy", lambda _: object())
|
||||
monkeypatch.setattr(llmwiki_router, "_authorized_mapping", authorized_mapping)
|
||||
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
|
||||
@@ -301,6 +294,9 @@ async def test_weknora_session_endpoint_uses_backend_prefix_when_frontend_has_di
|
||||
async def get_authorized(self, *_: object, **__: object) -> dict[str, str]:
|
||||
return {"id": "local-kb", "weknora_id": "remote-kb"}
|
||||
|
||||
async def list_visible(self, *_: object, **__: object) -> list[dict[str, str]]:
|
||||
return []
|
||||
|
||||
monkeypatch.setattr(llmwiki_router, "_runtime_for_iframe_proxy", lambda _: object())
|
||||
monkeypatch.setattr(llmwiki_router, "_authorized_mapping", authorized_mapping)
|
||||
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
|
||||
@@ -1089,15 +1085,9 @@ def test_weknora_iframe_cookie_is_signed_and_short_lived() -> None:
|
||||
def test_weknora_iframe_proxy_is_fallback_after_deerflow_api_routes() -> None:
|
||||
assert _first_gateway_match("POST", "/api/v1/auth/login/username") == "/api/v1/auth/login/username"
|
||||
assert _first_gateway_match("POST", "/api/v1/knowledge-search") == "/api/v1/{proxied_path:path}"
|
||||
assert (
|
||||
_first_gateway_match("GET", "/api/llmwiki/weknora-embed/api/v1/auth/me")
|
||||
== "/api/llmwiki/weknora-embed/api/v1/{proxied_path:path}"
|
||||
)
|
||||
assert _first_gateway_match("GET", "/api/llmwiki/weknora-embed/api/v1/auth/me") == "/api/llmwiki/weknora-embed/api/v1/{proxied_path:path}"
|
||||
assert _first_gateway_match("GET", "/platform/knowledge-bases/remote-kb") == "/platform/{proxied_path:path}"
|
||||
assert (
|
||||
_first_gateway_match("GET", "/deerflow/platform/knowledge-bases/remote-kb")
|
||||
== "/deerflow/platform/{proxied_path:path}"
|
||||
)
|
||||
assert _first_gateway_match("GET", "/deerflow/platform/knowledge-bases/remote-kb") == "/deerflow/platform/{proxied_path:path}"
|
||||
assert _first_gateway_match("GET", "/deerflow/assets/index.js") == "/deerflow/assets/{proxied_path:path}"
|
||||
assert _first_gateway_match("GET", "/deerflow/js/index.js") == "/deerflow/{proxied_path:path}"
|
||||
assert _first_gateway_match("GET", "/deerflow/css/index.css") == "/deerflow/{proxied_path:path}"
|
||||
@@ -1177,21 +1167,13 @@ async def test_prefixed_weknora_proxy_serves_page_static_assets_and_api_without_
|
||||
if path == "/platform/knowledge-bases/remote-kb":
|
||||
return httpx.Response(
|
||||
200,
|
||||
text=(
|
||||
'<html><head><script src="/assets/main.js"></script>'
|
||||
'<link rel="stylesheet" href="css/app.css">'
|
||||
'<script src="/config.js"></script></head><body></body></html>'
|
||||
),
|
||||
text=('<html><head><script src="/assets/main.js"></script><link rel="stylesheet" href="css/app.css"><script src="/config.js"></script></head><body></body></html>'),
|
||||
headers={"content-type": "text/html; charset=utf-8"},
|
||||
)
|
||||
if path == "/assets/main.js":
|
||||
return httpx.Response(
|
||||
200,
|
||||
text=(
|
||||
'const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=['
|
||||
'"assets/lazy.css","assets/lazy.js"])))=>i.map(i=>d[i]);'
|
||||
'const chunk="/static/chunk.js",matcher=/platform\\//;fetch("/api/v1/auth/me")'
|
||||
),
|
||||
text=('const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/lazy.css","assets/lazy.js"])))=>i.map(i=>d[i]);const chunk="/static/chunk.js",matcher=/platform\\//;fetch("/api/v1/auth/me")'),
|
||||
headers={"content-type": "application/javascript"},
|
||||
)
|
||||
if path == "/css/app.css":
|
||||
@@ -1246,7 +1228,7 @@ async def test_prefixed_weknora_proxy_serves_page_static_assets_and_api_without_
|
||||
assert '"deerflow/assets/lazy.css"' in script.text
|
||||
assert '"deerflow/assets/lazy.js"' in script.text
|
||||
assert '"/deerflow/assets/lazy.css"' not in script.text
|
||||
assert 'matcher=/platform\\//' in script.text
|
||||
assert "matcher=/platform\\//" in script.text
|
||||
assert 'fetch("/deerflow/api/v1/auth/me")' in script.text
|
||||
|
||||
stylesheet = await client.get("/deerflow/css/app.css")
|
||||
@@ -1280,6 +1262,7 @@ def test_weknora_iframe_hides_current_outer_sidebar_shell() -> None:
|
||||
is_admin=False,
|
||||
can_write=False,
|
||||
exp=4_102_444_800,
|
||||
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
|
||||
)
|
||||
injection = llmwiki_router._weknora_embed_injection(
|
||||
allowed_path="/platform/knowledge-bases/remote-kb",
|
||||
@@ -1302,6 +1285,7 @@ def test_weknora_iframe_html_rewrites_public_prefix_paths() -> None:
|
||||
is_admin=False,
|
||||
can_write=False,
|
||||
exp=4_102_444_800,
|
||||
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
|
||||
)
|
||||
html = b'<html><head><script src="/assets/index.js"></script></head><body>fetch("/api/v1/auth/me")</body></html>'
|
||||
|
||||
@@ -1318,9 +1302,12 @@ def test_weknora_iframe_html_rewrites_public_prefix_paths() -> None:
|
||||
assert 'fetch("/deerflow/api/v1/auth/me")' in injected
|
||||
assert '"apiPrefix":"/deerflow/api/llmwiki/weknora-embed"' in injected
|
||||
assert '"allowedPath":"/deerflow/platform/knowledge-bases/remote-kb"' in injected
|
||||
assert '"allowedWeKnoraIds":["remote-kb","other-visible-kb"]' in injected
|
||||
assert ".breadcrumb-link.dropdown" not in injected
|
||||
assert "reloadForKnowledgeBaseSwitch" in injected
|
||||
|
||||
|
||||
def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
|
||||
def test_weknora_iframe_filters_kb_list_to_signed_visible_mappings() -> None:
|
||||
from app.gateway.routers import llmwiki as llmwiki_router
|
||||
|
||||
ctx = llmwiki_router.WeKnoraEmbedContext(
|
||||
@@ -1330,6 +1317,7 @@ def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
|
||||
is_admin=False,
|
||||
can_write=False,
|
||||
exp=4_102_444_800,
|
||||
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
|
||||
)
|
||||
response = httpx.Response(
|
||||
200,
|
||||
@@ -1337,6 +1325,7 @@ def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
|
||||
"success": True,
|
||||
"data": [
|
||||
{"id": "remote-kb", "name": "Allowed"},
|
||||
{"id": "other-visible-kb", "name": "Also allowed"},
|
||||
{"id": "other-kb", "name": "Blocked"},
|
||||
],
|
||||
},
|
||||
@@ -1346,7 +1335,112 @@ def test_weknora_iframe_filters_kb_list_to_current_mapping() -> None:
|
||||
|
||||
assert filtered is not None
|
||||
payload = json.loads(filtered)
|
||||
assert payload["data"] == [{"id": "remote-kb", "name": "Allowed"}]
|
||||
assert payload["data"] == [
|
||||
{"id": "remote-kb", "name": "Allowed"},
|
||||
{"id": "other-visible-kb", "name": "Also allowed"},
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_weknora_iframe_switch_rechecks_selected_mapping_permissions(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from app.gateway.routers import llmwiki as llmwiki_router
|
||||
|
||||
class Store:
|
||||
async def get_by_weknora_id(self, weknora_id: str) -> dict[str, str] | None:
|
||||
if weknora_id == "other-visible-kb":
|
||||
return {"id": "public-kb", "weknora_id": weknora_id, "owner_user_id": "owner-b"}
|
||||
return None
|
||||
|
||||
async def get_authorized(self, mapping_id: str, _: str, *, write: bool, **__: object) -> dict[str, str] | None:
|
||||
if mapping_id != "public-kb":
|
||||
return None
|
||||
if write:
|
||||
return None
|
||||
return {"id": "public-kb", "weknora_id": "other-visible-kb", "owner_user_id": "owner-b"}
|
||||
|
||||
monkeypatch.setattr(llmwiki_router, "_store", lambda _: Store())
|
||||
original = llmwiki_router.WeKnoraEmbedContext(
|
||||
mapping_id="local-kb",
|
||||
weknora_id="remote-kb",
|
||||
user_id="user-a",
|
||||
is_admin=False,
|
||||
can_write=True,
|
||||
exp=4_102_444_800,
|
||||
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
|
||||
)
|
||||
|
||||
selected = await llmwiki_router._switch_embed_context(
|
||||
_request("/platform/knowledge-bases/other-visible-kb"),
|
||||
original,
|
||||
"other-visible-kb",
|
||||
)
|
||||
|
||||
assert selected.mapping_id == "public-kb"
|
||||
assert selected.weknora_id == "other-visible-kb"
|
||||
assert selected.can_write is False
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_weknora_platform_proxy_reissues_cookie_for_native_kb_switch(
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
from app.gateway.routers import llmwiki as llmwiki_router
|
||||
|
||||
current = llmwiki_router.WeKnoraEmbedContext(
|
||||
mapping_id="local-kb",
|
||||
weknora_id="remote-kb",
|
||||
user_id="user-a",
|
||||
is_admin=False,
|
||||
can_write=False,
|
||||
exp=4_102_444_800,
|
||||
allowed_weknora_ids=("remote-kb", "other-visible-kb"),
|
||||
)
|
||||
selected = llmwiki_router.WeKnoraEmbedContext(
|
||||
mapping_id="public-kb",
|
||||
weknora_id="other-visible-kb",
|
||||
user_id="user-a",
|
||||
is_admin=False,
|
||||
can_write=False,
|
||||
exp=4_102_444_800,
|
||||
allowed_weknora_ids=current.allowed_weknora_ids,
|
||||
)
|
||||
seen: dict[str, object] = {}
|
||||
|
||||
async def read_context(_: Request) -> object:
|
||||
return current
|
||||
|
||||
async def switch_context(_: Request, ctx: object, weknora_id: str) -> object:
|
||||
seen["current"] = ctx
|
||||
seen["target"] = weknora_id
|
||||
return selected
|
||||
|
||||
async def proxy_request(*_: object, **kwargs: object) -> Response:
|
||||
seen.update(kwargs)
|
||||
return Response("ok")
|
||||
|
||||
monkeypatch.setattr(llmwiki_router, "_read_embed_context", read_context)
|
||||
monkeypatch.setattr(llmwiki_router, "_switch_embed_context", switch_context)
|
||||
monkeypatch.setattr(
|
||||
llmwiki_router,
|
||||
"_runtime_for_iframe_proxy",
|
||||
lambda _: SimpleNamespace(web_base_url="http://weknora-web"),
|
||||
)
|
||||
monkeypatch.setattr(llmwiki_router, "_proxy_weknora_request", proxy_request)
|
||||
|
||||
response = await llmwiki_router.proxy_weknora_platform_page(
|
||||
_request("/platform/knowledge-bases/other-visible-kb", request_headers={"X-Forwarded-Proto": "https"}),
|
||||
"knowledge-bases/other-visible-kb",
|
||||
)
|
||||
|
||||
assert seen["current"] == current
|
||||
assert seen["target"] == "other-visible-kb"
|
||||
assert seen["upstream_path"] == "/platform/knowledge-bases/other-visible-kb"
|
||||
raw_cookie = response.headers["set-cookie"].split("deerflow_weknora_embed=", 1)[1].split(";", 1)[0]
|
||||
switched_context = llmwiki_router._verify_embed_cookie(raw_cookie)
|
||||
assert switched_context.mapping_id == "public-kb"
|
||||
assert switched_context.weknora_id == "other-visible-kb"
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@@ -1365,7 +1459,7 @@ async def test_conversation_deposit_iframe_sanitizes_legacy_brand(monkeypatch: p
|
||||
def __init__(self, **_: object) -> None:
|
||||
pass
|
||||
|
||||
async def __aenter__(self) -> "FakeAsyncClient":
|
||||
async def __aenter__(self) -> FakeAsyncClient:
|
||||
return self
|
||||
|
||||
async def __aexit__(self, *_: object) -> None:
|
||||
|
||||
@@ -115,6 +115,69 @@ async def test_delete_model_configuration_removes_matching_model_and_activates_c
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_reorder_model_configurations_persists_a_complete_permutation(
|
||||
tmp_path,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
config_path = tmp_path / "config.yaml"
|
||||
config_path.write_text(
|
||||
"""models:
|
||||
- name: first
|
||||
use: langchain_openai:ChatOpenAI
|
||||
model: first
|
||||
- name: second
|
||||
use: langchain_openai:ChatOpenAI
|
||||
model: second
|
||||
""",
|
||||
encoding="utf-8",
|
||||
)
|
||||
saved: dict[str, object] = {}
|
||||
|
||||
async def save_models(_request, raw_before: str, models: list[dict[str, object]]) -> list[dict[str, object]]:
|
||||
saved["raw_before"] = raw_before
|
||||
saved["models"] = models
|
||||
return models
|
||||
|
||||
monkeypatch.setattr(router, "_resolve_config_path", lambda: config_path)
|
||||
monkeypatch.setattr(router, "_save_models", save_models)
|
||||
request = SimpleNamespace(state=SimpleNamespace(user=SimpleNamespace(system_role="admin")))
|
||||
|
||||
result = await router.reorder_model_configurations(
|
||||
router.ModelOrderRequest(names=["second", "first"]),
|
||||
request,
|
||||
)
|
||||
|
||||
assert [item.name for item in result] == ["second", "first"]
|
||||
assert [item["name"] for item in saved["models"]] == ["second", "first"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_reorder_model_configurations_rejects_stale_or_partial_orders(
|
||||
tmp_path,
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
) -> None:
|
||||
config_path = tmp_path / "config.yaml"
|
||||
config_path.write_text(
|
||||
"""models:
|
||||
- name: first
|
||||
use: langchain_openai:ChatOpenAI
|
||||
model: first
|
||||
- name: second
|
||||
use: langchain_openai:ChatOpenAI
|
||||
model: second
|
||||
""",
|
||||
encoding="utf-8",
|
||||
)
|
||||
monkeypatch.setattr(router, "_resolve_config_path", lambda: config_path)
|
||||
request = SimpleNamespace(state=SimpleNamespace(user=SimpleNamespace(system_role="admin")))
|
||||
|
||||
with pytest.raises(Exception) as exc_info:
|
||||
await router.reorder_model_configurations(router.ModelOrderRequest(names=["first"]), request)
|
||||
|
||||
assert getattr(exc_info.value, "status_code", None) == 409
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connection_test_uses_one_minimal_prompt_without_writing_config(
|
||||
tmp_path,
|
||||
|
||||
@@ -0,0 +1,273 @@
|
||||
"""Tests for PositionArtifactCapMiddleware."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from types import SimpleNamespace
|
||||
|
||||
from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
|
||||
|
||||
from deerflow.agents.middlewares.position_artifact_cap_middleware import (
|
||||
PositionArtifactCapMiddleware,
|
||||
_reminder_for,
|
||||
_successful_outputs_writes,
|
||||
_successful_presents,
|
||||
)
|
||||
|
||||
|
||||
def _runtime(cap: int | None = 1) -> SimpleNamespace:
|
||||
context: dict = {"thread_id": "t-pos"}
|
||||
if cap is not None:
|
||||
context["position_artifact_cap"] = cap
|
||||
return SimpleNamespace(context=context, config={"configurable": dict(context)})
|
||||
|
||||
|
||||
def _write_call(call_id: str, path: str = "/mnt/user-data/outputs/report.md") -> dict:
|
||||
return {
|
||||
"id": call_id,
|
||||
"name": "write_file",
|
||||
"args": {"path": path, "content": "# hello", "description": "deliver"},
|
||||
}
|
||||
|
||||
|
||||
def _present_call(call_id: str, path: str = "/mnt/user-data/outputs/report.md") -> dict:
|
||||
return {
|
||||
"id": call_id,
|
||||
"name": "present_files",
|
||||
"args": {"filepaths": [path]},
|
||||
}
|
||||
|
||||
|
||||
def test_successful_outputs_writes_counts_ok_in_current_turn_only() -> None:
|
||||
messages = [
|
||||
HumanMessage(content="上一轮"),
|
||||
AIMessage(content="", tool_calls=[_write_call("old")]),
|
||||
ToolMessage(content="OK", tool_call_id="old", name="write_file"),
|
||||
HumanMessage(content="本轮请交付"),
|
||||
AIMessage(content="", tool_calls=[_write_call("new")]),
|
||||
ToolMessage(content="OK", tool_call_id="new", name="write_file"),
|
||||
]
|
||||
assert _successful_outputs_writes(messages, turn_start=3) == 1
|
||||
|
||||
|
||||
def test_after_model_truncates_second_outputs_write_in_same_response() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付一份报告"),
|
||||
AIMessage(
|
||||
content="正在写入",
|
||||
tool_calls=[
|
||||
_write_call("w1"),
|
||||
_write_call("w2", "/mnt/user-data/outputs/report-copy.md"),
|
||||
_present_call("p1"),
|
||||
],
|
||||
),
|
||||
]
|
||||
}
|
||||
update = mw.after_model(state, _runtime(1))
|
||||
assert update is not None
|
||||
tool_calls = update["messages"][0].tool_calls
|
||||
assert [tc["id"] for tc in tool_calls] == ["w1", "p1"]
|
||||
|
||||
|
||||
def test_after_model_strips_all_writes_once_cap_already_met() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(content="", tool_calls=[_write_call("done")]),
|
||||
ToolMessage(content="OK", tool_call_id="done", name="write_file"),
|
||||
AIMessage(content="再写一份", tool_calls=[_write_call("again")]),
|
||||
]
|
||||
}
|
||||
update = mw.after_model(state, _runtime(1))
|
||||
assert update is not None
|
||||
assert update["messages"][0].tool_calls == []
|
||||
assert update.get("jump_to") == "end"
|
||||
assert "产物上限" not in str(update["messages"][0].content)
|
||||
assert "tool_calls" not in (update["messages"][0].additional_kwargs or {})
|
||||
|
||||
|
||||
def test_after_model_noop_without_cap() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(content="", tool_calls=[_write_call("w1"), _write_call("w2")]),
|
||||
]
|
||||
}
|
||||
assert mw.after_model(state, _runtime(None)) is None
|
||||
|
||||
|
||||
def test_wrap_tool_call_rejects_after_successful_delivery() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(content="", tool_calls=[_write_call("done")]),
|
||||
ToolMessage(content="OK", tool_call_id="done", name="write_file"),
|
||||
]
|
||||
}
|
||||
request = SimpleNamespace(
|
||||
tool_call=_write_call("again"),
|
||||
runtime=_runtime(1),
|
||||
state=state,
|
||||
)
|
||||
called = {"n": 0}
|
||||
|
||||
def handler(_request):
|
||||
called["n"] += 1
|
||||
return ToolMessage(content="OK", tool_call_id="again", name="write_file")
|
||||
|
||||
result = mw.wrap_tool_call(request, handler)
|
||||
assert called["n"] == 0
|
||||
assert isinstance(result, ToolMessage)
|
||||
assert str(result.content).startswith("Error:")
|
||||
|
||||
|
||||
def test_wrap_tool_call_allows_first_write() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {"messages": [HumanMessage(content="请交付")]}
|
||||
request = SimpleNamespace(
|
||||
tool_call=_write_call("w1"),
|
||||
runtime=_runtime(1),
|
||||
state=state,
|
||||
)
|
||||
|
||||
def handler(_request):
|
||||
return ToolMessage(content="OK", tool_call_id="w1", name="write_file")
|
||||
|
||||
result = mw.wrap_tool_call(request, handler)
|
||||
assert result.content == "OK"
|
||||
|
||||
|
||||
def test_wrap_tool_call_rejects_parallel_second_write_in_same_batch() -> None:
|
||||
"""Two write_file in one AIMessage can run concurrently; order in the list is the budget."""
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(content="", tool_calls=[_write_call("w1"), _write_call("w2")]),
|
||||
]
|
||||
}
|
||||
first = SimpleNamespace(tool_call=_write_call("w1"), runtime=_runtime(1), state=state)
|
||||
second = SimpleNamespace(tool_call=_write_call("w2"), runtime=_runtime(1), state=state)
|
||||
|
||||
def handler(request):
|
||||
return ToolMessage(content="OK", tool_call_id=request.tool_call["id"], name="write_file")
|
||||
|
||||
assert mw.wrap_tool_call(first, handler).content == "OK"
|
||||
rejected = mw.wrap_tool_call(second, handler)
|
||||
assert str(rejected.content).startswith("Error:")
|
||||
|
||||
|
||||
def test_after_model_clears_provider_tool_call_metadata() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
extra = {
|
||||
"tool_calls": [
|
||||
{"id": "w1", "type": "function", "function": {"name": "write_file"}},
|
||||
{"id": "w2", "type": "function", "function": {"name": "write_file"}},
|
||||
]
|
||||
}
|
||||
ai = AIMessage(content="写两份", tool_calls=[_write_call("w1"), _write_call("w2")])
|
||||
ai.additional_kwargs = extra
|
||||
state = {"messages": [HumanMessage(content="请交付"), ai]}
|
||||
update = mw.after_model(state, _runtime(1))
|
||||
assert update is not None
|
||||
kept = update["messages"][0]
|
||||
assert [tc["id"] for tc in kept.tool_calls] == ["w1"]
|
||||
assert [item["id"] for item in kept.additional_kwargs.get("tool_calls", [])] == ["w1"]
|
||||
|
||||
|
||||
def test_action_plan_style_cap_two_allows_second_write() -> None:
|
||||
"""Action-plan is exempt in the UI (no flag); if a cap of 2 were set it must allow both."""
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="生成行动规划"),
|
||||
AIMessage(content="", tool_calls=[_write_call("md", "/mnt/user-data/outputs/行动规划报告.md")]),
|
||||
ToolMessage(content="OK", tool_call_id="md", name="write_file"),
|
||||
AIMessage(
|
||||
content="",
|
||||
tool_calls=[_write_call("json", "/mnt/user-data/outputs/action-plan-subtasks.json")],
|
||||
),
|
||||
]
|
||||
}
|
||||
assert mw.after_model(state, _runtime(2)) is None
|
||||
|
||||
|
||||
def test_after_model_truncates_second_present_files_in_same_response() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(
|
||||
content="",
|
||||
tool_calls=[_write_call("w1"), _present_call("p1"), _present_call("p2")],
|
||||
),
|
||||
]
|
||||
}
|
||||
update = mw.after_model(state, _runtime(1))
|
||||
assert update is not None
|
||||
assert [tc["id"] for tc in update["messages"][0].tool_calls] == ["w1", "p1"]
|
||||
|
||||
|
||||
def test_after_model_strips_second_present_after_first_succeeded() -> None:
|
||||
"""Screenshot bug: write+present already done, weak model presents the same file again."""
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请评估"),
|
||||
AIMessage(content="", tool_calls=[_write_call("w1"), _present_call("p1")]),
|
||||
ToolMessage(content="OK", tool_call_id="w1", name="write_file"),
|
||||
ToolMessage(content="Successfully presented files", tool_call_id="p1", name="present_files"),
|
||||
AIMessage(content="评估报告已交付", tool_calls=[_present_call("p2")]),
|
||||
]
|
||||
}
|
||||
update = mw.after_model(state, _runtime(1))
|
||||
assert update is not None
|
||||
assert update["messages"][0].tool_calls == []
|
||||
assert update.get("jump_to") == "end"
|
||||
|
||||
|
||||
def test_wrap_tool_call_rejects_second_present_files() -> None:
|
||||
mw = PositionArtifactCapMiddleware()
|
||||
state = {
|
||||
"messages": [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(content="", tool_calls=[_present_call("p1")]),
|
||||
ToolMessage(content="Successfully presented files", tool_call_id="p1", name="present_files"),
|
||||
]
|
||||
}
|
||||
request = SimpleNamespace(
|
||||
tool_call=_present_call("p2"),
|
||||
runtime=_runtime(1),
|
||||
state=state,
|
||||
)
|
||||
called = {"n": 0}
|
||||
|
||||
def handler(_request):
|
||||
called["n"] += 1
|
||||
return ToolMessage(content="Successfully presented files", tool_call_id="p2", name="present_files")
|
||||
|
||||
result = mw.wrap_tool_call(request, handler)
|
||||
assert called["n"] == 0
|
||||
assert isinstance(result, ToolMessage)
|
||||
assert "已经呈现" in str(result.content)
|
||||
|
||||
|
||||
def test_reminder_asks_present_only_when_not_yet_presented() -> None:
|
||||
assert "present_files" in (_reminder_for(writes_done=True, presents_done=False) or "")
|
||||
done = _reminder_for(writes_done=True, presents_done=True) or ""
|
||||
assert "已经 present_files" in done
|
||||
assert "请立即 present_files" not in done
|
||||
assert _reminder_for(writes_done=False, presents_done=False) is None
|
||||
|
||||
|
||||
def test_successful_presents_counts_tool_result() -> None:
|
||||
messages = [
|
||||
HumanMessage(content="请交付"),
|
||||
AIMessage(content="", tool_calls=[_present_call("p1")]),
|
||||
ToolMessage(content="Successfully presented files", tool_call_id="p1", name="present_files"),
|
||||
]
|
||||
assert _successful_presents(messages, turn_start=0) == 1
|
||||
@@ -206,14 +206,14 @@ def test_position_intent_prompt_keeps_the_original_step_one_guardrails():
|
||||
assert phrase in prompt
|
||||
|
||||
|
||||
def test_position_intent_clarification_waits_for_the_user_before_ready():
|
||||
"""A same-run READY block must not consume the user-assistance pause."""
|
||||
def test_fresh_intent_clarification_waits_for_the_user_before_ready():
|
||||
"""A same-run READY block must not consume a fresh assistance pause."""
|
||||
assert intent_router._clarification_blocks_ready(
|
||||
intent_router.POSITION_INTENT_AGENT_ID,
|
||||
{"name": "ask_clarification"},
|
||||
is_fresh=True,
|
||||
)
|
||||
assert not intent_router._clarification_blocks_ready(
|
||||
assert intent_router._clarification_blocks_ready(
|
||||
intent_router.INTENT_AGENT_ID,
|
||||
{"name": "ask_clarification"},
|
||||
is_fresh=True,
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
"""Regression coverage for provider-safe transient context compression."""
|
||||
|
||||
from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
|
||||
|
||||
from deerflow.agents.middlewares.summarization_middleware import _ensure_latest_human_message
|
||||
|
||||
|
||||
def test_compression_restores_latest_human_turn_when_only_tool_tail_remains():
|
||||
user = HumanMessage(content="请分析这份材料", id="user-1")
|
||||
source = [
|
||||
user,
|
||||
AIMessage(content="", id="ai-1"),
|
||||
ToolMessage(content="检索结果", tool_call_id="call-1", id="tool-1"),
|
||||
]
|
||||
compressed = [SystemMessage(content="internal summary"), *source[1:]]
|
||||
|
||||
result = _ensure_latest_human_message(source, compressed)
|
||||
|
||||
assert result[0].type == "system"
|
||||
assert result[1] is user
|
||||
assert [message.type for message in result[2:]] == ["ai", "tool"]
|
||||
|
||||
|
||||
def test_compression_does_not_duplicate_human_turn_already_in_tail():
|
||||
user = HumanMessage(content="继续", id="user-1")
|
||||
compressed = [SystemMessage(content="internal summary"), user]
|
||||
|
||||
result = _ensure_latest_human_message([user], compressed)
|
||||
|
||||
assert result == compressed
|
||||
Reference in new issue
Block a user