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