deer-flow/backend/tests/test_compaction_event_identity.py
Xinmin Zeng df544f126a
test(backend): prune 32 zero-unique redundant suites and rewrite 9 source-inspection tests (#8362)
* test(backend): prune 32 zero-unique redundant suites and rewrite 9 source-inspection tests

- Remove 32 superseded test files proven lossless across statement/branch coverage (per-test dynamic contexts), hotspot mutation testing (mutmut), and 20 historical bug replays.
- Replace all inspect.getsource and brittle source-string assertions across 9 test files with behavioral runtime assertions.

* test(backend): consolidate hidden-answer and compaction-hash guards and assert protocol defaults

- Fold hidden human-input turn-boundary regressions into tests/test_channels.py while keeping test_channel_hidden_human_input.py removed.
- Fold multimodal source content hashing and unobserved-skip regressions into tests/test_compaction_event_identity.py.
- Assert contract-specific default return values/types (False for bool registrations, empty sequence for middleware contributions, explicit return None for void hooks) in test_extension_api_contracts.py and add stub rejection tests.
2026-11-18 21:13:19 +08:00

318 lines
12 KiB
Python

"""A compaction event names the task, run and thread it happened in.
The host already holds the live task store when summarization runs: the summary
system call is observed with it. A compaction observer that cannot name its task
can only correlate a compaction with the run that produced it by matching hashes
across sessions, which is unreliable, so the host hands the observer the store it
already has and copies the seeded ``TaskInfo`` identity onto the event.
"""
from __future__ import annotations
import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
import pytest
from deerflow_extension_api import (
EXTENSION_TASK_STORE_KEY,
CompactionEvent,
ExtensionData,
TaskInfo,
canonical_hash,
)
from langchain_core.messages import AIMessage, HumanMessage
from langgraph.checkpoint.memory import InMemorySaver
from deerflow.agents.middlewares.summarization_middleware import DeerFlowSummarizationMiddleware
from deerflow.extensions import notify
from deerflow.extensions.registry import ExtensionRegistry
from deerflow.runtime import context_compaction
from deerflow.runtime.runs.manager import RunManager
from deerflow.runtime.runs.schemas import RunStatus
from deerflow.runtime.runs.worker import RunContext, run_agent
class _CompactionRecorder:
def __init__(self) -> None:
self.calls: list[tuple[ExtensionData, CompactionEvent]] = []
self._arrived = asyncio.Event()
async def on_context_compacted(self, app_store, task_store, event):
self.calls.append((task_store, event))
self._arrived.set()
async def received(self) -> list[tuple[ExtensionData, CompactionEvent]]:
# Dispatch is fire-and-forget onto the notify loop, so the observer may
# still be pending when the compaction call returns.
await asyncio.wait_for(self._arrived.wait(), 5)
return self.calls
class _LifecycleRecorder:
def __init__(self) -> None:
self.infos: list[TaskInfo] = []
async def on_task_start(self, app_store, task_store, info):
self.infos.append(info)
async def on_task_stop(self, app_store, task_store, info, outcome):
return None
def _extensions(observer, *, lifecycle=None):
registry = ExtensionRegistry()
with registry.attributed_to("identity:install"):
registry.context_compaction_observer(observer)
if lifecycle is not None:
registry.task_lifecycle(lifecycle)
return registry.build()
def _messages() -> list:
return [
HumanMessage(content="user-1"),
AIMessage(content="assistant-1"),
HumanMessage(content="user-2"),
AIMessage(content="assistant-2"),
]
def _middleware(extensions) -> DeerFlowSummarizationMiddleware:
model = MagicMock()
model.invoke.return_value = SimpleNamespace(text="compressed summary")
model.ainvoke = AsyncMock(return_value=SimpleNamespace(text="compressed summary"))
model.with_config.return_value = model
return DeerFlowSummarizationMiddleware(
model=model,
trigger=("messages", 4),
keep=("messages", 2),
token_counter=len,
extensions=extensions,
)
def _identity(event: CompactionEvent) -> tuple[str | None, str | None, str | None]:
return event.task_id, event.run_id, event.thread_id
# --- The contract stays additive -------------------------------------------
def test_an_event_built_the_old_way_still_constructs_without_identity():
keyword = CompactionEvent(
transform_kind="summarization",
transform_version="1",
source_content_hashes=("h1",),
output_content_hash="h2",
compacted_message_count=1,
kept_message_count=1,
)
positional = CompactionEvent("summarization", "1", ("h1",), "h2", 1, 1)
assert keyword == positional
assert _identity(keyword) == (None, None, None)
# --- Dispatch ----------------------------------------------------------------
class TestNotifyHandsOverTheLiveStore:
@pytest.mark.asyncio
async def test_a_live_store_reaches_the_observer_and_names_the_event(self, monkeypatch):
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
store = ExtensionData("run-1")
store.set(TaskInfo(task_id="run-1", run_id="run-1", thread_id="thread-1", kind="lead"))
notify.notify_context_compacted(CompactionEvent("summarization", "1", (), "h", 0, 0), extensions=_extensions(observer), task_store=store)
[(received_store, event)] = await observer.received()
assert received_store is store
assert _identity(event) == ("run-1", "run-1", "thread-1")
@pytest.mark.asyncio
async def test_a_store_without_task_info_is_handed_over_without_identity(self, monkeypatch):
# A subagent with no parent run allocates a store but never seeds TaskInfo.
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
store = ExtensionData("sub-1")
notify.notify_context_compacted(CompactionEvent("summarization", "1", (), "h", 0, 0), extensions=_extensions(observer), task_store=store)
[(received_store, event)] = await observer.received()
assert received_store is store
assert _identity(event) == (None, None, None)
@pytest.mark.asyncio
async def test_no_store_falls_back_to_detached(self, monkeypatch):
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
notify.notify_context_compacted(CompactionEvent("summarization", "1", (), "h", 0, 0), extensions=_extensions(observer))
[(received_store, event)] = await observer.received()
assert received_store.scope_id == "detached"
assert _identity(event) == (None, None, None)
# --- End to end through the hosts that allocate the store -----------------
class _CompactingLeadAgent:
"""Stands in for the lead graph: runs the real summarization middleware once
against the runtime context ``run_agent`` hands the graph."""
def __init__(self, middleware: DeerFlowSummarizationMiddleware) -> None:
self.middleware = middleware
self.task_store: ExtensionData | None = None
async def astream(self, graph_input, config=None, stream_mode=None, subgraphs=False):
context = (config or {}).get("context")
self.task_store = context.get(EXTENSION_TASK_STORE_KEY)
assert await self.middleware.abefore_model({"messages": _messages()}, SimpleNamespace(context=context)) is not None
yield {"messages": []}
def _bridge():
return SimpleNamespace(publish=AsyncMock(), publish_end=AsyncMock(), cleanup=AsyncMock())
async def _run_lead(extensions, agent):
manager = RunManager()
record = await manager.create("thread-identity", assistant_id="custom-agent")
await run_agent(
_bridge(),
manager,
record,
ctx=RunContext(checkpointer=InMemorySaver(), extensions=extensions),
agent_factory=lambda *, config: agent,
graph_input={},
config={},
)
assert record.status is RunStatus.success
return record
class TestLeadRunCompaction:
@pytest.mark.asyncio
async def test_async_compaction_names_the_run_it_happened_in(self, monkeypatch):
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
lifecycle = _LifecycleRecorder()
extensions = _extensions(observer, lifecycle=lifecycle)
agent = _CompactingLeadAgent(_middleware(extensions))
record = await _run_lead(extensions, agent)
[(store, event)] = await observer.received()
[info] = lifecycle.infos
assert store is agent.task_store
assert store.scope_id == info.task_id == record.run_id
assert store.get(TaskInfo) == info
assert _identity(event) == (info.task_id, info.run_id, info.thread_id) == (record.run_id, record.run_id, "thread-identity")
@pytest.mark.asyncio
async def test_identity_does_not_depend_on_a_lifecycle_contributor(self, monkeypatch):
"""Registering a compaction observer alone allocates the store; the host
must not drop the identity just because no lifecycle contributor asked."""
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
extensions = _extensions(observer)
assert extensions.needs_task_store and not extensions.has_task_lifecycle
agent = _CompactingLeadAgent(_middleware(extensions))
record = await _run_lead(extensions, agent)
[(store, event)] = await observer.received()
assert store is agent.task_store
assert store.scope_id == record.run_id
assert store.get(TaskInfo) == TaskInfo(
task_id=record.run_id,
run_id=record.run_id,
thread_id="thread-identity",
kind="lead",
agent_name="custom-agent",
)
assert _identity(event) == (record.run_id, record.run_id, "thread-identity")
class TestSyncCompaction:
@pytest.mark.asyncio
async def test_sync_compaction_carries_the_live_task_identity(self, monkeypatch):
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
store = ExtensionData("run-sync")
info = TaskInfo(task_id="run-sync", run_id="run-sync", thread_id="thread-sync", kind="lead")
store.set(info)
runtime = SimpleNamespace(context={"thread_id": "thread-sync", EXTENSION_TASK_STORE_KEY: store})
middleware = _middleware(_extensions(observer))
# The synchronous graph path runs before_model off the serving loop.
result = await asyncio.to_thread(middleware.before_model, {"messages": _messages()}, runtime)
assert result is not None
[(received_store, event)] = await observer.received()
assert received_store is store
assert _identity(event) == (info.task_id, info.run_id, info.thread_id)
class _Accessor:
def __init__(self, values: dict) -> None:
self.snapshot = SimpleNamespace(
values=values,
config={"configurable": {"thread_id": "thread-manual", "checkpoint_id": "ckpt-old", "checkpoint_ns": ""}},
metadata={"step": 4},
)
async def aget(self, _config):
return self.snapshot
async def aget_tuple(self, _config):
return SimpleNamespace(checkpoint={"channel_values": dict(self.snapshot.values)})
async def aupdate(self, config, values, *, as_node=None):
return {"configurable": {"thread_id": "thread-manual", "checkpoint_ns": "", "checkpoint_id": "ckpt-compacted"}}
class TestManualCompaction:
@pytest.mark.asyncio
async def test_manual_compact_outside_any_run_falls_back_to_a_detached_store(self, monkeypatch):
monkeypatch.setattr(notify, "_notify_loop", asyncio.get_running_loop())
observer = _CompactionRecorder()
middleware = _middleware(_extensions(observer))
monkeypatch.setattr(context_compaction, "_create_compaction_middleware", lambda **_kwargs: middleware)
result = await context_compaction.compact_thread_context(_Accessor({"messages": _messages()}), "thread-manual", app_config=SimpleNamespace())
assert result.compacted
[(store, event)] = await observer.received()
assert store.scope_id == "detached"
assert store.get(TaskInfo) is None
assert _identity(event) == (None, None, None)
class TestCompactionSourceHashing:
"""Consolidated from test_context_compaction_observation.py."""
def test_source_hashes_are_computed_on_content_directly_not_a_stringified_copy(self):
"""Hashing ``str(message.content)`` would defeat ``canonical_hash`` key-order normalization
for multimodal (``list[dict]``) content."""
a = HumanMessage(content=[{"type": "text", "text": "hi"}, {"b": 1, "a": 2}])
b = HumanMessage(content=[{"type": "text", "text": "hi"}, {"a": 2, "b": 1}])
middleware = _middleware(_extensions(_CompactionRecorder()))
hashes = middleware._freeze_compaction_sources([a, b])
assert hashes[0] == hashes[1]
assert hashes[0] == canonical_hash(a.content)
assert str(a.content) != str(b.content)
def test_the_sources_are_not_hashed_when_nothing_observes(self):
from dataclasses import replace
from deerflow.extensions import get_agent_build_extensions
unobserved = replace(get_agent_build_extensions(), context_compaction_observers=())
assert _middleware(unobserved)._freeze_compaction_sources(_messages()) == ()