- 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
1193 lines
36 KiB
Python
1193 lines
36 KiB
Python
"""类式任务测试:注册、触发、堆叠策略、失败钩子、运行跟踪与图任务体。"""
|
||
|
||
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
|