Files
openbot fbb01c4c83 feat: 重构为 agent / channels / flows / db 分层架构
- agent: 新增 base.py 执行基类、execution.py 执行器、web.py 网络工具,
  middlewares/steering.py 中间件;移除旧的 agent.py
- channels: 新增 ChannelManager、registry、models 与 IM 渠道(企业微信),
  扩展 base.py
- flows: 新增 agent_task / bus / cron / scheduler / service / stream / rpc /
  processor / tasks / model_settings / builtin;移除旧的 task.py
- db: 新增 sqlite schema 与 repo 层
- docs: 新增架构说明、Channel × EventBus 设计、任务编写教程
- 依赖新增 aiosqlite / httpx / langgraph / primp / pydantic / ripgrep /
  wecom-aibot-sdk;新增 bot 命令入口
- 测试:232 passed
2026-11-09 20:32:25 +08:00

1193 lines
36 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""类式任务测试:注册、触发、堆叠策略、失败钩子、运行跟踪与图任务体。"""
from __future__ import annotations
import asyncio
import logging
import operator
from datetime import datetime, timedelta
from pathlib import Path
from typing import Annotated, Any, ClassVar, TypedDict
import pytest
from langgraph.graph import END, StateGraph
from bot042.flows.bus import EventBus
from bot042.flows.scheduler import CN_TZ, Fire, IntervalTrigger, OnceTrigger
from bot042.flows.tasks import (
EventTrigger,
GraphTask,
OverlapPolicy,
RunStatus,
Task,
TaskContext,
TaskRun,
TaskRunner,
TaskStats,
)
async def _wait_calls(calls: list, want: int, timeout: float = 2.0) -> None:
"""轮询等待调用数达到 want(宽松超时,避免定时抖动)。"""
loop = asyncio.get_running_loop()
deadline = loop.time() + timeout
while len(calls) < want and loop.time() < deadline:
await asyncio.sleep(0.02)
# ------------------------------------------------------------------ 注册校验
def test_register_requires_explicit_name() -> None:
class NoName(Task):
async def run(self) -> None:
pass
runner = TaskRunner(EventBus())
with pytest.raises(ValueError, match="任务名缺失"):
runner.register(NoName)
def test_register_rejects_invalid_name() -> None:
class BadName(Task):
name: ClassVar[str] = "bad name!"
async def run(self) -> None:
pass
runner = TaskRunner(EventBus())
with pytest.raises(ValueError, match="任务名缺失或非法"):
runner.register(BadName)
def test_register_rejects_duplicate_name() -> None:
class First(Task):
name: ClassVar[str] = "dup"
async def run(self) -> None:
pass
class Second(Task):
name: ClassVar[str] = "dup"
async def run(self) -> None:
pass
runner = TaskRunner(EventBus())
runner.register(First)
with pytest.raises(ValueError, match="任务名已存在"):
runner.register(Second)
def test_register_rejects_non_task() -> None:
runner = TaskRunner(EventBus())
with pytest.raises(TypeError, match="Task 子类"):
runner.register(int) # type: ignore[arg-type]
def test_register_requires_task_body() -> None:
class Incomplete(Task):
name: ClassVar[str] = "incomplete"
# 既未覆写 run() 也未覆写 build_graph() → 任务体缺失
runner = TaskRunner(EventBus())
with pytest.raises(ValueError, match="任务体缺失"):
runner.register(Incomplete)
def test_register_rejects_reserved_name() -> None:
class Done(Task):
name: ClassVar[str] = "done"
async def run(self) -> None:
pass
runner = TaskRunner(EventBus())
with pytest.raises(ValueError, match="保留"):
runner.register(Done)
def test_overlap_default_is_skip() -> None:
assert Task.overlap is OverlapPolicy.SKIP
class Plain(Task):
name: ClassVar[str] = "plain"
async def run(self) -> None:
pass
assert Plain.overlap is OverlapPolicy.SKIP
# ---------------------------------------------------------------- 脚本加载
def test_load_scripts(tmp_path: Path) -> None:
(tmp_path / "alpha.py").write_text(
"from bot042.flows.tasks import Task\n"
"\n"
"class Hello(Task):\n"
" name = 'alpha.hello'\n"
"\n"
" async def run(self) -> None:\n"
" pass\n",
encoding="utf-8",
)
runner = TaskRunner(EventBus())
names = runner.load_scripts(tmp_path)
assert names == ["alpha.hello"]
assert [spec.name for spec in runner.tasks()] == ["alpha.hello"]
def test_load_scripts_missing_dir(tmp_path: Path) -> None:
runner = TaskRunner(EventBus())
with pytest.raises(ValueError, match="脚本目录不存在"):
runner.load_scripts(tmp_path / "nope")
def test_broken_script_is_skipped(tmp_path: Path) -> None:
(tmp_path / "bad.py").write_text("raise RuntimeError('boom')\n", encoding="utf-8")
(tmp_path / "good.py").write_text(
"from bot042.flows.tasks import Task\n"
"\n"
"class Ok(Task):\n"
" name = 'good.ok'\n"
"\n"
" async def run(self) -> None:\n"
" pass\n",
encoding="utf-8",
)
runner = TaskRunner(EventBus())
names = runner.load_scripts(tmp_path)
assert names == ["good.ok"]
# ------------------------------------------------------------------ 监听触发
def test_event_trigger_runs_with_context() -> None:
async def _run() -> list[TaskContext]:
bus = EventBus()
runner = TaskRunner(bus)
calls: list[TaskContext] = []
class Rec(Task):
name: ClassVar[str] = "t1"
async def run(self) -> None:
calls.append(self.context)
runner.register(Rec)
runner.add_task("t1", EventTrigger(event="demo.ping"))
await runner.start()
bus.emit("demo.ping", {"x": 1})
await bus.wait_for_complete()
await runner.stop()
return calls
calls = asyncio.run(_run())
assert len(calls) == 1
ctx = calls[0]
assert ctx.task == "t1"
assert ctx.event == "demo.ping"
assert ctx.payload == {"x": 1}
assert ctx.fired_at.tzinfo is not None
assert ctx.run_id
def test_task_done_event_carries_run_record() -> None:
async def _run() -> list[TaskRun]:
bus = EventBus()
runner = TaskRunner(bus)
seen: list[TaskRun] = []
class Rec(Task):
name: ClassVar[str] = "t"
async def run(self) -> None:
pass
async def on_done(payload: object) -> None:
assert isinstance(payload, TaskRun)
seen.append(payload)
runner.register(Rec)
runner.add_task("t", EventTrigger(event="demo.d"))
_ = bus.on("task.done", on_done)
await runner.start()
bus.emit("demo.d")
await bus.wait_for_complete()
await runner.stop()
return seen
runs = asyncio.run(_run())
assert len(runs) == 1
assert runs[0].task == "t"
assert runs[0].status is RunStatus.SUCCEEDED
assert runs[0].finished_at is not None
def test_task_chain_via_task_event() -> None:
async def _run() -> list[str]:
bus = EventBus()
runner = TaskRunner(bus)
order: list[str] = []
class First(Task):
name: ClassVar[str] = "ta"
async def run(self) -> None:
order.append("a")
class Second(Task):
name: ClassVar[str] = "tb"
async def run(self) -> None:
order.append("b")
runner.register(First)
runner.register(Second)
runner.add_task("ta", EventTrigger(event="demo.go"))
runner.add_task("tb", EventTrigger(event="task.ta"))
await runner.start()
bus.emit("demo.go")
await bus.wait_for_complete()
await runner.stop()
return order
assert asyncio.run(_run()) == ["a", "b"]
# ------------------------------------------------------------------ 定时触发
def test_once_trigger_runs_task_with_fire() -> None:
async def _run() -> list[TaskContext]:
bus = EventBus()
runner = TaskRunner(bus)
calls: list[TaskContext] = []
class Rec(Task):
name: ClassVar[str] = "t2"
async def run(self) -> None:
calls.append(self.context)
runner.register(Rec)
at = datetime.now(CN_TZ) + timedelta(milliseconds=120)
runner.add_task("t2", OnceTrigger(at=at))
await runner.start()
await _wait_calls(calls, 1)
await bus.wait_for_complete()
await runner.stop()
return calls
calls = asyncio.run(_run())
assert len(calls) == 1
ctx = calls[0]
assert ctx.event == "schedule.t2.1"
assert isinstance(ctx.payload, Fire)
assert ctx.payload.name == "t2.1"
def test_interval_trigger_repeats() -> None:
async def _run() -> list[TaskContext]:
bus = EventBus()
runner = TaskRunner(bus)
calls: list[TaskContext] = []
class Rec(Task):
name: ClassVar[str] = "tick"
async def run(self) -> None:
calls.append(self.context)
runner.register(Rec)
runner.add_task("tick", IntervalTrigger(every=timedelta(milliseconds=50)))
await runner.start()
await _wait_calls(calls, 2)
await bus.wait_for_complete()
await runner.stop()
return calls
calls = asyncio.run(_run())
assert len(calls) >= 2
assert all(c.event == "schedule.tick.1" for c in calls)
# ------------------------------------------------------------------ 堆叠策略
def test_overlap_skip_drops_during_run() -> None:
"""5s 任务每 3s 触发(缩放版):SKIP 只跑第一次,其余记 skipped。"""
async def _run() -> tuple[list[str], TaskStats]:
bus = EventBus()
runner = TaskRunner(bus)
started: list[str] = []
class Slow(Task):
name: ClassVar[str] = "slow"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.SKIP
async def run(self) -> None:
started.append(self.context.run_id)
await asyncio.sleep(0.2) # 缩放版 5s
runner.register(Slow)
runner.add_task("slow", EventTrigger(event="demo.s"))
await runner.start()
for _ in range(3):
bus.emit("demo.s")
await asyncio.sleep(0.08) # 缩放版 3s 间隔
await bus.wait_for_complete()
stats = runner.stats("slow")
await runner.stop()
return started, stats
started, stats = asyncio.run(_run())
assert len(started) == 1 # 只跑了一次
assert stats.succeeded == 1
assert stats.skipped == 2
assert stats.total == 3
def test_overlap_default_also_skips() -> None:
"""不声明 overlap 时默认 SKIP。"""
async def _run() -> TaskStats:
bus = EventBus()
runner = TaskRunner(bus)
class Slow(Task):
name: ClassVar[str] = "slow"
async def run(self) -> None:
await asyncio.sleep(0.15)
runner.register(Slow)
runner.add_task("slow", EventTrigger(event="demo.s"))
await runner.start()
for _ in range(3):
bus.emit("demo.s")
await bus.wait_for_complete()
stats = runner.stats("slow")
await runner.stop()
return stats
stats = asyncio.run(_run())
assert stats.succeeded == 1
assert stats.skipped == 2
def test_overlap_queue_serializes_with_backlog_limit() -> None:
"""QUEUE 串行排队;超出 ``queue_limit`` 的触发按 drop_new 记 failed。"""
async def _run() -> tuple[list[str], TaskStats]:
bus = EventBus()
runner = TaskRunner(bus, queue_limit=1)
started: list[str] = []
class Slow(Task):
name: ClassVar[str] = "slow"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.QUEUE
async def run(self) -> None:
started.append(self.context.run_id)
await asyncio.sleep(0.15)
runner.register(Slow)
runner.add_task("slow", EventTrigger(event="demo.s"))
await runner.start()
for _ in range(3):
bus.emit("demo.s") # 第 1 次执行、第 2 次排队、第 3 次溢出丢弃
await _wait_calls(started, 2) # 第 2 次已接力起跑
bus.emit("demo.s") # 此时队列已空 → 新触发应排队而非丢弃
await runner.wait_idle(timeout=2)
stats = runner.stats("slow")
await runner.stop()
return started, stats
started, stats = asyncio.run(_run())
assert len(started) == 3 # 3 次真正执行
assert stats.succeeded == 3
assert stats.failed == 1 # 仅超出积压的那 1 次被丢弃
def test_queue_fifo_and_wait_idle() -> None:
"""QUEUE 分区内 FIFO;``wait_idle`` 会等排队项全部跑完。"""
async def _run() -> tuple[list[int], bool]:
bus = EventBus()
runner = TaskRunner(bus)
order: list[int] = []
gate = asyncio.Event()
class Seq(Task):
name: ClassVar[str] = "seq"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.QUEUE
async def run(self) -> None:
order.append(int(self.context.payload)) # type: ignore[arg-type]
if len(order) == 1:
await gate.wait() # 首条阻塞,让后续全部排队
runner.register(Seq)
runner.add_task("seq", EventTrigger(event="demo.fifo"))
await runner.start()
for i in range(4):
bus.emit("demo.fifo", i)
await asyncio.sleep(0.02)
assert runner.busy is True
gate.set()
await runner.wait_idle(timeout=2)
busy = runner.busy
await runner.stop()
return order, busy
order, busy = asyncio.run(_run())
assert order == [0, 1, 2, 3]
assert busy is False
def test_partition_key_serializes_per_session() -> None:
"""不同分区并行,同一分区串行(session_key 语义)。"""
async def _run() -> tuple[list[str], list[tuple[str, int]], bool]:
bus = EventBus()
runner = TaskRunner(bus)
seen: list[tuple[str, int]] = []
gate = asyncio.Event()
class Msg(Task):
name: ClassVar[str] = "msg"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.QUEUE
@staticmethod
def partition_key(ctx: TaskContext) -> str:
payload = ctx.payload
return str(payload.get("session", "")) if isinstance(payload, dict) else ""
async def run(self) -> None:
payload = self.context.payload
assert isinstance(payload, dict)
session = str(payload["session"])
seen.append((session, int(payload["n"])))
if session == "s1":
await gate.wait()
runner.register(Msg)
runner.add_task("msg", EventTrigger(event="demo.msg"))
await runner.start()
bus.emit("demo.msg", {"session": "s1", "n": 1})
await asyncio.sleep(0.02)
bus.emit("demo.msg", {"session": "s1", "n": 2}) # 同分区 → 排队
bus.emit("demo.msg", {"session": "s2", "n": 1}) # 另一分区 → 立即跑
await asyncio.sleep(0.05)
started_before_release = [session for session, _ in seen]
gate.set()
await runner.wait_idle(timeout=2)
busy = runner.busy
await runner.stop()
return started_before_release, seen, busy
started, seen, busy = asyncio.run(_run())
assert started == ["s1", "s2"] # s2 未被 s1 阻塞
assert seen == [("s1", 1), ("s2", 1), ("s1", 2)] # s1 内部串行
assert busy is False
def test_queue_overflow_emits_failed() -> None:
"""drop_new:溢出触发记 failed 并发出 task.failed。"""
async def _run() -> tuple[list[TaskRun], int]:
bus = EventBus()
runner = TaskRunner(bus, queue_limit=1)
gate = asyncio.Event()
failed: list[TaskRun] = []
class Slow(Task):
name: ClassVar[str] = "slow"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.QUEUE
async def run(self) -> None:
await gate.wait()
async def on_failed(payload: object) -> None:
if isinstance(payload, TaskRun):
failed.append(payload)
runner.register(Slow)
runner.add_task("slow", EventTrigger(event="demo.ov"))
_ = bus.on("task.failed", on_failed)
await runner.start()
bus.emit("demo.ov") # 运行中
bus.emit("demo.ov") # 排队(占用唯一额度)
bus.emit("demo.ov") # 溢出
await asyncio.sleep(0.02)
gate.set()
await runner.wait_idle(timeout=2)
await bus.wait_for_complete()
runs = runner.runs("slow")
await runner.stop()
return failed, len([r for r in runs if r.status is RunStatus.FAILED])
failed, failed_runs = asyncio.run(_run())
assert failed_runs == 1
assert len(failed) == 1
assert failed[0].error is not None and "queue overflow" in failed[0].error
def test_overlap_parallel_runs_concurrently() -> None:
async def _run() -> int:
bus = EventBus()
runner = TaskRunner(bus)
active = 0
max_active = 0
class Slow(Task):
name: ClassVar[str] = "slow"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.PARALLEL
async def run(self) -> None:
nonlocal active, max_active
active += 1
max_active = max(max_active, active)
await asyncio.sleep(0.15)
active -= 1
runner.register(Slow)
runner.add_task("slow", EventTrigger(event="demo.s"))
await runner.start()
for _ in range(2):
bus.emit("demo.s")
await bus.wait_for_complete()
await runner.stop()
return max_active
assert asyncio.run(_run()) == 2
def test_overlap_replace_cancels_previous() -> None:
async def _run() -> tuple[list[str], list[TaskRun], list[TaskRun]]:
bus = EventBus()
runner = TaskRunner(bus)
started: list[str] = []
first_started = asyncio.Event()
done_events: list[TaskRun] = []
class Slow(Task):
name: ClassVar[str] = "slow"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.REPLACE
async def run(self) -> None:
started.append(self.context.run_id)
if len(started) == 1:
first_started.set()
await asyncio.sleep(0.5)
async def on_done(payload: object) -> None:
assert isinstance(payload, TaskRun)
done_events.append(payload)
runner.register(Slow)
runner.add_task("slow", EventTrigger(event="demo.s"))
_ = bus.on("task.done", on_done)
await runner.start()
bus.emit("demo.s")
await first_started.wait() # 确保第一次已在执行中
bus.emit("demo.s") # 取消第一次、立即执行新的
await bus.wait_for_complete()
runs = runner.runs("slow")
await runner.stop()
return started, runs, done_events
started, runs, done_events = asyncio.run(_run())
assert len(started) == 2 # 两次都实例化并进入 run
statuses = [r.status for r in runs]
assert RunStatus.CANCELLED in statuses
assert RunStatus.SUCCEEDED in statuses
assert len(done_events) == 2 # 取消与成功各发一次 task.done
# ------------------------------------------------------------------ 失败处理
def test_failure_recorded_and_failed_event_emitted() -> None:
async def _run() -> tuple[list[TaskRun], list[TaskRun], TaskStats]:
bus = EventBus()
runner = TaskRunner(bus)
failed_events: list[TaskRun] = []
class Bad(Task):
name: ClassVar[str] = "bad"
async def run(self) -> None:
raise RuntimeError("boom")
async def on_failed(payload: object) -> None:
assert isinstance(payload, TaskRun)
failed_events.append(payload)
runner.register(Bad)
runner.add_task("bad", EventTrigger(event="demo.e"))
_ = bus.on("task.failed", on_failed)
await runner.start()
bus.emit("demo.e")
await bus.wait_for_complete()
runs = runner.runs("bad")
stats = runner.stats("bad")
await runner.stop()
return runs, failed_events, stats
runs, failed_events, stats = asyncio.run(_run())
assert len(runs) == 1
assert runs[0].status is RunStatus.FAILED
assert runs[0].error == "RuntimeError: boom"
assert len(failed_events) == 1
assert failed_events[0].run_id == runs[0].run_id
assert stats.failed == 1
assert stats.last_error == "RuntimeError: boom"
def test_on_error_hook_receives_exception() -> None:
async def _run() -> list[BaseException]:
bus = EventBus()
runner = TaskRunner(bus)
errors: list[BaseException] = []
class Bad(Task):
name: ClassVar[str] = "bad"
async def run(self) -> None:
raise RuntimeError("boom")
async def on_error(self, exc: BaseException) -> None:
errors.append(exc)
runner.register(Bad)
runner.add_task("bad", EventTrigger(event="demo.e"))
await runner.start()
bus.emit("demo.e")
await bus.wait_for_complete()
await runner.stop()
return errors
errors = asyncio.run(_run())
assert len(errors) == 1
assert isinstance(errors[0], RuntimeError)
def test_on_error_exception_is_contained(caplog: pytest.LogCaptureFixture) -> None:
async def _run() -> list[TaskRun]:
bus = EventBus()
runner = TaskRunner(bus)
class Bad(Task):
name: ClassVar[str] = "bad"
async def run(self) -> None:
raise RuntimeError("boom")
async def on_error(self, exc: BaseException) -> None:
raise ValueError("hook boom")
runner.register(Bad)
runner.add_task("bad", EventTrigger(event="demo.e"))
await runner.start()
with caplog.at_level(logging.ERROR):
bus.emit("demo.e")
await bus.wait_for_complete()
runs = runner.runs("bad")
await runner.stop()
return runs
runs = asyncio.run(_run())
assert runs[0].status is RunStatus.FAILED # 钩子异常不影响记录
assert any("on_error" in r.message for r in caplog.records)
def test_init_failure_recorded_without_hook(caplog: pytest.LogCaptureFixture) -> None:
async def _run() -> tuple[list[TaskRun], list[BaseException]]:
bus = EventBus()
runner = TaskRunner(bus)
errors: list[BaseException] = []
class BadInit(Task):
name: ClassVar[str] = "bad"
def __init__(self, context: TaskContext) -> None:
raise RuntimeError("init boom")
async def run(self) -> None:
pass
async def on_error(self, exc: BaseException) -> None:
errors.append(exc)
runner.register(BadInit)
runner.add_task("bad", EventTrigger(event="demo.e"))
await runner.start()
with caplog.at_level(logging.WARNING):
bus.emit("demo.e")
await bus.wait_for_complete()
runs = runner.runs("bad")
await runner.stop()
return runs, errors
runs, errors = asyncio.run(_run())
assert len(runs) == 1
assert runs[0].status is RunStatus.FAILED
assert runs[0].error == "RuntimeError: init boom"
assert errors == [] # __init__ 失败时无实例,钩子不调用
assert any("钩子不可用" in r.message for r in caplog.records)
# ------------------------------------------------------ 实例隔离与运行跟踪
def test_each_run_creates_new_instance() -> None:
async def _run() -> list[tuple[int, int]]:
bus = EventBus()
runner = TaskRunner(bus)
observed: list[tuple[int, int]] = []
class Iso(Task):
name: ClassVar[str] = "iso"
def __init__(self, context: TaskContext) -> None:
super().__init__(context)
self.buffer: list[int] = []
async def run(self) -> None:
self.buffer.append(len(observed))
await asyncio.sleep(0)
observed.append((id(self), len(self.buffer)))
runner.register(Iso)
runner.add_task("iso", EventTrigger(event="demo.i"))
await runner.start()
bus.emit("demo.i")
await bus.wait_for_complete() # 间隔开两次运行,避免被默认 SKIP 策略吞掉
bus.emit("demo.i")
await bus.wait_for_complete()
await runner.stop()
return observed
observed = asyncio.run(_run())
assert len(observed) == 2
assert all(buf == 1 for _, buf in observed) # 每次实例状态独立
assert observed[0][0] != observed[1][0] # 不同实例
def test_run_id_links_context_and_run_record() -> None:
async def _run() -> tuple[str, str]:
bus = EventBus()
runner = TaskRunner(bus)
ctx_ids: list[str] = []
done_ids: list[str] = []
class Rec(Task):
name: ClassVar[str] = "rec"
async def run(self) -> None:
ctx_ids.append(self.context.run_id)
async def on_done(payload: object) -> None:
assert isinstance(payload, TaskRun)
done_ids.append(payload.run_id)
runner.register(Rec)
runner.add_task("rec", EventTrigger(event="demo.r"))
_ = bus.on("task.done", on_done)
await runner.start()
bus.emit("demo.r")
await bus.wait_for_complete()
await runner.stop()
return ctx_ids[0], done_ids[0]
ctx_id, done_id = asyncio.run(_run())
assert ctx_id == done_id
def test_runs_and_stats_queries() -> None:
async def _run() -> tuple[list[TaskRun], TaskStats]:
bus = EventBus()
runner = TaskRunner(bus)
class Mixed(Task):
name: ClassVar[str] = "mixed"
overlap: ClassVar[OverlapPolicy] = OverlapPolicy.PARALLEL
async def run(self) -> None:
if self.context.payload == "fail":
raise RuntimeError("nope")
runner.register(Mixed)
runner.add_task("mixed", EventTrigger(event="demo.m"))
await runner.start()
bus.emit("demo.m", "ok")
bus.emit("demo.m", "fail")
await bus.wait_for_complete()
runs = runner.runs("mixed", limit=1)
stats = runner.stats("mixed")
await runner.stop()
return runs, stats
runs, stats = asyncio.run(_run())
assert len(runs) == 1 # limit 生效
assert stats.total == 2
assert stats.succeeded == 1
assert stats.failed == 1
def test_remove_task_stops_triggering() -> None:
async def _run() -> list[TaskContext]:
bus = EventBus()
runner = TaskRunner(bus)
calls: list[TaskContext] = []
class Rec(Task):
name: ClassVar[str] = "t"
async def run(self) -> None:
calls.append(self.context)
runner.register(Rec)
runner.add_task("t", EventTrigger(event="demo.r"))
await runner.start()
runner.remove_task("t")
bus.emit("demo.r")
await bus.wait_for_complete()
await runner.stop()
return calls
assert asyncio.run(_run()) == []
runner = TaskRunner(EventBus())
runner.remove_task("ghost") # 不存在时无操作
def test_stop_blocks_event_and_time_triggers() -> None:
async def _run() -> list[TaskContext]:
bus = EventBus()
runner = TaskRunner(bus)
calls: list[TaskContext] = []
class Rec(Task):
name: ClassVar[str] = "ev"
async def run(self) -> None:
calls.append(self.context)
class Tick(Task):
name: ClassVar[str] = "tick"
async def run(self) -> None:
calls.append(self.context)
runner.register(Rec)
runner.register(Tick)
runner.add_task("ev", EventTrigger(event="demo.b"))
runner.add_task("tick", IntervalTrigger(every=timedelta(milliseconds=30)))
await runner.start()
await runner.stop()
bus.emit("demo.b")
await bus.wait_for_complete()
await asyncio.sleep(0.2)
return calls
assert asyncio.run(_run()) == []
def test_add_task_validation() -> None:
runner = TaskRunner(EventBus())
class Rec(Task):
name: ClassVar[str] = "t"
async def run(self) -> None:
pass
runner.register(Rec)
with pytest.raises(ValueError, match="未登记的任务"):
runner.add_task("ghost", EventTrigger(event="demo.x"))
with pytest.raises(ValueError, match="仅对定时触发"):
runner.add_task(
"t",
EventTrigger(event="demo.x"),
start_time=datetime.now(CN_TZ),
)
runner.add_task("t", EventTrigger(event="demo.x"))
with pytest.raises(ValueError, match="触发器已存在"):
runner.add_task("t", EventTrigger(event="demo.x"))
spec = runner.tasks()[0]
assert spec.name == "t"
assert len(spec.triggers) == 1
# ------------------------------------------------------------------ 图任务
class _GState(TypedDict):
total: int
log: Annotated[list[str], operator.add]
class _SumGraph(GraphTask):
"""示例图任务:inc → double 两节点串行。"""
name: ClassVar[str] = "demo.graph"
def build_graph(self) -> Any:
builder = StateGraph(_GState)
builder.add_node("inc", self._inc)
builder.add_node("double", self._double)
builder.set_entry_point("inc")
builder.add_edge("inc", "double")
builder.add_edge("double", END)
return builder.compile()
async def _inc(self, state: _GState) -> dict[str, Any]:
return {"total": state["total"] + 1, "log": ["inc"]}
async def _double(self, state: _GState) -> dict[str, Any]:
return {"total": state["total"] * 2, "log": ["double"]}
def initial_state(self) -> dict[str, Any]:
return {"total": int(self.context.payload), "log": []}
class _BoomGraph(GraphTask):
"""示例图任务:节点抛异常。"""
name: ClassVar[str] = "demo.boom"
def build_graph(self) -> Any:
builder = StateGraph(_GState)
builder.add_node("boom", self._boom)
builder.set_entry_point("boom")
builder.add_edge("boom", END)
return builder.compile()
async def _boom(self, state: _GState) -> dict[str, Any]:
_ = state
raise RuntimeError("graph boom")
def initial_state(self) -> dict[str, Any]:
return {"total": 0, "log": []}
def test_graph_task_runs_graph_body() -> None:
async def _run() -> tuple[_SumGraph | None, TaskStats]:
bus = EventBus()
runner = TaskRunner(bus)
holder: list[_SumGraph] = []
class Capturing(_SumGraph):
async def run(self) -> None:
await super().run()
holder.append(self)
runner.register(Capturing)
runner.add_task("demo.graph", EventTrigger(event="demo.g"))
await runner.start()
bus.emit("demo.g", 5)
await bus.wait_for_complete()
stats = runner.stats("demo.graph")
await runner.stop()
return (holder[0] if holder else None), stats
task, stats = asyncio.run(_run())
assert task is not None
assert task.result == {"total": 12, "log": ["inc", "double"]} # (5+1)*2
assert stats.succeeded == 1
def test_graph_task_failure_recorded() -> None:
async def _run() -> tuple[list[TaskRun], list[BaseException]]:
bus = EventBus()
runner = TaskRunner(bus)
errors: list[BaseException] = []
class Boom(_BoomGraph):
async def on_error(self, exc: BaseException) -> None:
errors.append(exc)
runner.register(Boom)
runner.add_task("demo.boom", EventTrigger(event="demo.b"))
await runner.start()
bus.emit("demo.b")
await bus.wait_for_complete()
runs = runner.runs("demo.boom")
await runner.stop()
return runs, errors
runs, errors = asyncio.run(_run())
assert len(runs) == 1
assert runs[0].status is RunStatus.FAILED
assert runs[0].error == "RuntimeError: graph boom"
assert len(errors) == 1
def test_graph_task_is_task_alias() -> None:
"""GraphTask 是 Task 的兼容别名;任务体二选一,只写 run() 也能注册。"""
assert GraphTask is Task
class RunOnly(GraphTask):
name: ClassVar[str] = "run.only"
async def run(self) -> None:
pass
runner = TaskRunner(EventBus())
runner.register(RunOnly) # 不写 build_graph 也可以
assert [spec.name for spec in runner.tasks()] == ["run.only"]
# ------------------------------------------------------------ 运行记录上限
def test_runs_limit_keeps_recent() -> None:
async def _run() -> list[str]:
bus = EventBus()
runner = TaskRunner(bus, runs_limit=1)
class Tick(Task):
name: ClassVar[str] = "tick"
async def run(self) -> None:
pass
runner.register(Tick)
runner.add_task("tick", EventTrigger(event="demo.t"))
await runner.start()
bus.emit("demo.t")
await bus.wait_for_complete()
bus.emit("demo.t")
await bus.wait_for_complete()
runs = runner.runs()
await runner.stop()
return [run.run_id for run in runs]
assert len(asyncio.run(_run())) == 1
def test_runs_limit_must_be_positive() -> None:
with pytest.raises(ValueError, match="runs_limit"):
TaskRunner(EventBus(), runs_limit=0)
# ---------------------------------------------------------------- 健壮性回归
def test_bad_done_listener_does_not_stall_runner() -> None:
"""task.done 监听函数元数不匹配时,emit 不能把异常抛回执行方。
否则 _execute 里的 _release 被跳过,任务占位永远停在 running,
之后所有触发都被 SKIP。
"""
async def _run() -> list[RunStatus]:
bus = EventBus()
runner = TaskRunner(bus)
calls: list[str] = []
class Ok(Task):
name: ClassVar[str] = "ok"
async def run(self) -> None:
calls.append(self.context.run_id)
async def bad_listener() -> None: # 不接受参数 → 调用即 TypeError
pass
_ = bus.on("task.done", bad_listener)
runner.register(Ok)
runner.add_task("ok", EventTrigger(event="demo.ok"))
await runner.start()
for _ in range(2):
bus.emit("demo.ok")
await bus.wait_for_complete()
runs = runner.runs("ok")
await runner.stop()
assert len(calls) == 2 # 第二次没有被 SKIP
return [run.status for run in runs]
assert asyncio.run(_run()) == [RunStatus.SUCCEEDED, RunStatus.SUCCEEDED]
def test_remove_task_during_inflight_emit_is_ignored() -> None:
"""emit 已派发、handler 尚未执行时移除任务,不应产生 error 事件。"""
async def _run() -> list[BaseException]:
bus = EventBus()
errors: list[BaseException] = []
async def on_error(exc: BaseException) -> None:
errors.append(exc)
_ = bus.on("error", on_error)
runner = TaskRunner(bus)
class Noop(Task):
name: ClassVar[str] = "noop"
async def run(self) -> None:
pass
runner.register(Noop)
runner.add_task("noop", EventTrigger(event="demo.rm"))
await runner.start()
bus.emit("demo.rm") # fire-and-forget:handler 稍后才跑
runner.remove_task("noop")
await bus.wait_for_complete()
await runner.stop()
return errors
assert asyncio.run(_run()) == []
def test_external_scheduler_survives_runner_stop() -> None:
"""外部注入的调度器由调用方负责生命周期,runner.stop 不应停止它。"""
async def _run() -> bool:
from bot042.flows.scheduler import Scheduler
bus = EventBus()
shared = Scheduler(bus)
runner = TaskRunner(bus, scheduler=shared)
class Ok(Task):
name: ClassVar[str] = "ok"
async def run(self) -> None:
pass
runner.register(Ok)
runner.add_task("ok", IntervalTrigger(every=timedelta(hours=1)))
await runner.start()
await runner.stop()
started = shared._started # 断言外部调度器未被停
assert len(shared.schedules()) == 1
await shared.stop()
return started
assert asyncio.run(_run()) is True
def test_broken_script_not_left_in_sys_modules(tmp_path: Path) -> None:
import sys
(tmp_path / "broken.py").write_text("raise RuntimeError('boom')\n", encoding="utf-8")
runner = TaskRunner(EventBus())
assert runner.load_scripts(tmp_path) == []
assert "bot042_scripts.broken" not in sys.modules