import inspect from types import SimpleNamespace import pytest from app.services.integrations.feishu_signal_pipeline.mixin_gate_project import ( FeishuPipelineGateProjectMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_command_commit_project import ( FeishuPipelineCommandCommitProjectMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_command_commit_task import ( FeishuPipelineCommandCommitTaskMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_context_prefill_b import ( FeishuPipelineContextPrefillBMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_extraction import ( FeishuPipelineExtractionMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_item_processing import ( FeishuPipelineItemProcessingMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_followup_a import ( FeishuPipelineFollowupAMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_followup_b import FeishuPipelineFollowupBMixin from app.services.integrations.feishu_signal_pipeline.mixin_gate_dispatch import ( FeishuPipelineGateDispatchMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_item_finalize_routing import ( FeishuPipelineItemFinalizeRoutingMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_message_utils_b import ( FeishuPipelineMessageUtilsBMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_message_utils_a import ( FeishuPipelineMessageUtilsAMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_process_message_helpers_b import ( FeishuPipelineProcessMessageHelpersBMixin, ) from app.services.integrations.feishu_signal_pipeline.mixin_queue_confirm_undo import ( FeishuPipelineQueueConfirmUndoMixin, ) from app.services.integrations.feishu_signal_pipeline.service import FeishuSignalPipelineService from app.services.integrations.feishu_signal_pipeline import mixin_process_message_core from app.services.signal.signal_capture_service import mixin_capture_entry from app.services.signal.signal_capture_service.service import ProactiveSignalCaptureService from app.services.signal.signal_capture_service.mixin_task_orchestration_main import ( SignalCaptureTaskOrchestrationMainMixin, ) from app.services.signal.signal_capture_service.mixin_task_orchestration_skill import ( SignalCaptureTaskOrchestrationSkillMixin, ) class _Item: def __init__(self, *, item_id: int, level: str, operation_code: str, raw_message: str = "") -> None: self.id = item_id self.level = level self.card_type = operation_code.replace(".", "_") self.raw_message = raw_message self.result_payload = {"operation_code": operation_code} self.feishu_message_id = f"msg-{item_id}" def test_followup_status_target_requires_unique_match() -> None: items = [ _Item(item_id=1, level="command", operation_code="project.create"), _Item(item_id=2, level="command", operation_code="project.create"), ] target = FeishuPipelineFollowupBMixin._select_followup_status_target( message="刚才创建项目现在怎么样了", recent_items=items, ) assert target is None def test_followup_status_target_rejects_single_item_without_anchor() -> None: items = [ _Item(item_id=1, level="project", operation_code="project.create"), ] target = FeishuPipelineFollowupBMixin._select_followup_status_target( message="它现在怎么样？", recent_items=items, ) assert target is None def test_followup_status_target_prefers_thread_anchor() -> None: items = [ _Item(item_id=1, level="project", operation_code="project.create"), _Item(item_id=2, level="project", operation_code="project.create"), ] items[0].feishu_message_id = "root-1" items[1].feishu_message_id = "root-2" target = FeishuPipelineFollowupBMixin._select_followup_status_target( message="他是什么时候创建的？", recent_items=items, thread_context={"root_message_id": "root-1"}, ) assert target is items[0] def test_followup_status_target_rejects_unmatched_thread_anchor() -> None: items = [ _Item(item_id=1, level="project", operation_code="project.create"), _Item(item_id=2, level="project", operation_code="project.create"), ] items[0].feishu_message_id = "root-1" items[1].feishu_message_id = "root-2" target = FeishuPipelineFollowupBMixin._select_followup_status_target( message="他是什么时候创建的？", recent_items=items, thread_context={"reply_to_message_id": "reply-miss"}, ) assert target is None @pytest.mark.asyncio async def test_followup_status_reply_reports_project_created_at(monkeypatch) -> None: from datetime import datetime class _FakeDBResult: def __init__(self, value) -> None: self._value = value def scalar_one_or_none(self): return self._value class _FakeDB: async def execute(self, query): _ = query return _FakeDBResult(type("ProjectRow", (), {"id": 7, "tenant_id": 1, "title": "自动开票系统", "name": "自动开票系统", "created_at": datetime(2026, 3, 1, 9, 30)})()) class _FakeFollowup(FeishuPipelineFollowupBMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 async def _get_project_suggestion(self, item_id: int): _ = item_id return type("Suggestion", (), {"created_project_id": 7})() @staticmethod def _normalize_route_status(value): return str(value) item = _Item(item_id=1, level="project", operation_code="project.create") item.route_status = "auto_done" item.matched_project_id = 7 reply = await _FakeFollowup()._build_followup_status_reply(item, message="他是什么时候创建的？") assert "创建于 2026-03-01 09:30" in reply @pytest.mark.asyncio async def test_followup_queue_handler_ignores_unmatched_thread_anchor() -> None: class _FakeItem: def __init__(self) -> None: self.id = 1 self.route_status = "queued" self.level = "project" self.feishu_message_id = "queue-root-1" self.blocking_reason = "请确认" class _FakeFollowup(FeishuPipelineFollowupAMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 @staticmethod def _looks_like_continue_followup(message: str) -> bool: _ = message return False async def _load_recent_chat_items(self, *, source_chat_id, source_sender_open_id, sender, limit=5): _ = (source_chat_id, source_sender_open_id, sender, limit) return [_FakeItem()] result = await _FakeFollowup()._maybe_handle_queue_followup( message="他是什么时候创建的？", sender="测试用户", source_chat_id="chat-1", source_sender_open_id="ou-1", feishu_message_id="msg-1", process_started_at=0.0, thread_context={"reply_to_message_id": "reply-miss"}, ) assert result is None def test_process_message_no_longer_calls_legacy_queue_followup() -> None: source = inspect.getsource(mixin_process_message_core.FeishuPipelineProcessMessageCoreMixin.process_message) assert "_maybe_handle_queue_followup" not in source def test_feishu_signal_pipeline_service_runtime_excludes_legacy_followup_mixins() -> None: source = inspect.getsource(FeishuSignalPipelineService) assert "FeishuPipelineFollowupAMixin" not in source assert "FeishuPipelineFollowupBMixin" not in source def test_proactive_signal_capture_service_runtime_excludes_legacy_capture_mixin() -> None: source = inspect.getsource(ProactiveSignalCaptureService) assert "SignalCaptureLegacyMixin" not in source def test_decorate_capture_result_adds_queue_action_card_metadata() -> None: result = FeishuPipelineProcessMessageHelpersBMixin._decorate_capture_result( { "status": "captured", "results": [{"item_id": 301, "route_status": "queued_for_decision"}], "direct_reply_text": "已转待确认。", }, chat_type="group", normalized_text="请创建项目", route="group.intent_gate.project_create", db_mutations=[], ) assert result["reply_template_key"] == "queue_pending_confirm" assert result["queue_item_id"] == 301 def test_rag_conversation_key_uses_stable_scope_without_reply_anchor() -> None: key = FeishuPipelineMessageUtilsAMixin._build_rag_conversation_key( source_chat_id="chat-1", source_sender_open_id="ou-1", sender="测试用户", source_message_id="msg-123", thread_context=None, ) assert key == "feishu:chat-1:ou-1" @pytest.mark.asyncio async def test_build_direct_qa_capture_exposes_reason_code_and_anchor_kind() -> None: class _FakeHelpers(FeishuPipelineProcessMessageHelpersBMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _write_processing_log(self, **kwargs): _ = kwargs def _build_rag_reply_text(self, *, answer: str, sources: list[dict[str, object]]) -> str: _ = sources return answer helpers = _FakeHelpers() capture = await helpers._build_direct_qa_capture( message="这个是哪个模型回复的？", rag_result={ "answer": "这条回复命中的逻辑层是 low。", "clarification_code": None, "reason_code": "meta_followup_answered", "anchor_kind": "meta_recent_reply", "meta_followup_kind": "reply_model_identity", "sources": [], }, inferred_project_id=None, feishu_message_id="msg-1", process_started_at=0.0, route_reason="direct qa", intent_label="question", ) assert capture["reason_code"] == "meta_followup_answered" assert capture["anchor_kind"] == "meta_recent_reply" assert capture["meta_followup_kind"] == "reply_model_identity" @pytest.mark.asyncio async def test_intent_gate_query_does_not_inherit_project_context(monkeypatch) -> None: captured: dict[str, object] = {} class _FakeAdaptiveRAGService: def __init__(self, db, tenant_id: int): captured["tenant_id"] = tenant_id _ = db async def classify_intent(self, text: str): captured["classified_text"] = text return {"intent": "question", "question_part": text} async def answer_question(self, **kwargs): captured["answer_kwargs"] = kwargs return {"answer": "AI 行业动态正常", "sources": []} class _FakeGate(FeishuPipelineGateDispatchMixin, FeishuPipelineProcessMessageHelpersBMixin): def __init__(self) -> None: class _FakeDB: async def commit(self) -> None: return None self.db = _FakeDB() self.tenant_id = 1 async def _write_processing_log(self, **kwargs): captured["write_log"] = kwargs def _build_rag_conversation_key(self, **kwargs): _ = kwargs return "feishu:chat-1" def _build_rag_reply_text(self, *, answer: str, sources: list[dict[str, object]]) -> str: _ = sources return answer monkeypatch.setattr( "app.services.integrations.feishu_signal_pipeline.mixin_gate_dispatch.AdaptiveRAGService", _FakeAdaptiveRAGService, ) result = await _FakeGate()._maybe_handle_intent_gate_capture( intent_gate={"intent": "query"}, message="最近AI行业有什么动态", sender="测试用户", source_chat_id="chat-1", source_sender_open_id="ou-1", feishu_message_id="msg-1", captured_at=None, inferred_project_id=6, projects=[], process_started_at=0.0, normalized_chat_type="group", thread_context={"reply_to_message_id": "msg-root-1"}, ) assert isinstance(result, dict) assert result["linked_project_ids"] == [] assert captured["answer_kwargs"]["project_id"] is None assert captured["answer_kwargs"]["source_sender_open_id"] == "ou-1" assert captured["answer_kwargs"]["thread_context"] == {"reply_to_message_id": "msg-root-1"} @pytest.mark.asyncio async def test_feishu_question_like_messages_use_sync_high_accuracy_path(monkeypatch) -> None: calls = {"sync": 0, "session": 0, "cache": 0} class _FakeKernel: @staticmethod def _build_source_message_id(*, source_system: str, source_message_id, channel_ref: str, sender: str, message_text: str): _ = (source_system, source_message_id, channel_ref, sender, message_text) return "msg-1" def __init__(self, db, tenant_id: int): _ = (db, tenant_id) async def _get_or_create_session(self, **kwargs): calls["session"] += 1 _ = kwargs raise AssertionError("question-like Feishu messages should not create an async queue session") def _is_short_confirmation_message(self, **kwargs): _ = kwargs return False async def process_feishu_message(self, **kwargs): calls["sync"] += 1 _ = kwargs return { "handled": True, "status": "answered", "classification": "question", "linked_project_ids": [], "signal_id": None, "created_project_id": None, "auto_tasks": [], "ai_trace_id": "trace-1", "direct_reply_required": True, "direct_reply_text": "垂直行业建议先看目标客户与交付边界。", } async def _noop_sync_recent_cache(self, **kwargs): calls["cache"] += 1 _ = kwargs monkeypatch.setattr(mixin_capture_entry, "AIPMOKernelService", _FakeKernel) monkeypatch.setattr(ProactiveSignalCaptureService, "_sync_feishu_recent_cache", _noop_sync_recent_cache) service = ProactiveSignalCaptureService(object()) result = await service.capture_from_feishu( group_chat_id="chat-1", message_content="我感觉第一个垂直应用前景比较好，但是垂直哪个行业呢？", sender="测试用户", tenant_id=1, feishu_message_id="msg-1", chat_type="group", ) assert result["status"] == "answered" assert "已收到，正在处理。" not in str(result.get("direct_reply_text") or "") assert calls["sync"] == 1 assert calls["session"] == 0 assert calls["cache"] == 1 @pytest.mark.asyncio async def test_feishu_business_review_query_forwards_semantic_bundle_into_kernel(monkeypatch) -> None: captured: dict[str, object] = {} class _FakeKernel: @staticmethod def _build_source_message_id(*, source_system: str, source_message_id, channel_ref: str, sender: str, message_text: str): _ = (source_system, source_message_id, channel_ref, sender, message_text) return "msg-business-review" def __init__(self, db, tenant_id: int): _ = (db, tenant_id) async def _get_or_create_session(self, **kwargs): _ = kwargs raise AssertionError("business review sync path should not create async queue session") def _is_short_confirmation_message(self, **kwargs): _ = kwargs return False async def process_feishu_message(self, **kwargs): captured["kwargs"] = kwargs return { "handled": True, "status": "answered", "classification": "question", "linked_project_ids": [], "signal_id": None, "created_project_id": None, "auto_tasks": [], "ai_trace_id": "trace-br", "direct_reply_required": True, "direct_reply_text": "五大口径评审中。", } async def _noop_sync_recent_cache(self, **kwargs): _ = (self, kwargs) monkeypatch.setattr(mixin_capture_entry, "AIPMOKernelService", _FakeKernel) monkeypatch.setattr(ProactiveSignalCaptureService, "_sync_feishu_recent_cache", _noop_sync_recent_cache) service = ProactiveSignalCaptureService(object()) result = await service.capture_from_feishu( group_chat_id="chat-br-1", message_content="我现在要创建需求为一个大模型api聚合平台，你帮我分析下要怎么做，", sender="测试用户", tenant_id=1, feishu_message_id="msg-business-review", chat_type="group", ) assert result["status"] == "answered" kwargs = captured["kwargs"] assert isinstance(kwargs, dict) semantic_bundle = kwargs["semantic_bundle"] assert semantic_bundle["primary_workflow"] == "query_flow" assert semantic_bundle["diagnostics"]["message_intent"] == "business_review" def test_capture_from_feishu_no_longer_references_legacy_fallback() -> None: source = inspect.getsource(mixin_capture_entry.SignalCaptureEntryMixin.capture_from_feishu) assert "_capture_from_feishu_legacy_flow" not in source @pytest.mark.asyncio async def test_project_context_prefill_skips_chatwide_reply_fallback(monkeypatch) -> None: called = {"fallback": False} class _FakePrefill(FeishuPipelineContextPrefillBMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 @staticmethod def _looks_like_contextual_project_request(message: str) -> bool: return True async def _load_recent_chat_turns(self, **kwargs): _ = kwargs return [] async def _load_recent_chat_reply_fallback_text(self, *, source_chat_id: str, limit: int = 5) -> str: _ = (source_chat_id, limit) called["fallback"] = True raise AssertionError("reply fallback should not be used when no recent turns are available") fields = { "title": "", "description": "", "project_scope": "", "missing_fields": ["title", "description", "project_scope"], "ready": False, } result = await _FakePrefill()._maybe_prefill_project_fields_from_context( message="根据这个创建一个项目", source_chat_id="chat-1", source_sender_open_id="ou-1", sender="测试用户", fields=fields, source_message_id="msg-1", thread_context={"reply_to_message_id": "msg-root-1"}, ) assert result == fields assert called["fallback"] is False @pytest.mark.asyncio async def test_project_prefill_fallback_leaves_owner_and_timeline_empty() -> None: class _FakeLLM: async def generate(self, *args, **kwargs): _ = args, kwargs raise RuntimeError("boom") class _FakeExtraction(FeishuPipelineExtractionMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() result = await _FakeExtraction()._extract_project_prefill( "我们想做一个内部知识库升级项目，先把项目名称和范围整理出来。" ) assert result["suggested_owner"] is None assert result["suggested_timeline"] is None assert float(result["confidence"]) <= 0.35 assert len(result["reasoning"]) >= 1 @pytest.mark.asyncio async def test_create_project_suggestion_preserves_uncertain_owner_and_timeline() -> None: class _FakeDB: def __init__(self) -> None: self.added = [] def add(self, obj): self.added.append(obj) async def flush(self): return None class _FakeProcessing(FeishuPipelineItemProcessingMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 async def _extract_project_prefill(self, message: str): _ = message return { "suggested_name": "内部知识库升级", "suggested_description": "围绕内部知识库问答能力升级", "suggested_owner": None, "suggested_timeline": None, "confidence": 0.31, "reasoning": ["需求里没有明确负责人", "需求里没有明确时间线"], } project_info, suggestion = await _FakeProcessing()._create_project_suggestion( item_id=12, content="我们想做一个内部知识库升级项目，先把项目名称和范围整理出来。", sender="测试用户", fallback_confidence=0.31, ) assert project_info["suggested_owner"] is None assert project_info["suggested_timeline"] is None assert suggestion.suggested_owner is None assert suggestion.suggested_timeline is None def test_project_create_idempotency_key_prefers_message_key() -> None: key_one = FeishuPipelineCommandCommitProjectMixin._build_project_create_idempotency_key( idempotency_key="feishu:sm-123", trace_id="trace-1", ) key_two = FeishuPipelineCommandCommitProjectMixin._build_project_create_idempotency_key( idempotency_key="feishu:sm-123", trace_id="trace-2", ) fallback_key = FeishuPipelineCommandCommitProjectMixin._build_project_create_idempotency_key( idempotency_key=None, trace_id="trace-3", ) assert key_one == "feishu:sm-123" assert key_two == "feishu:sm-123" assert fallback_key == "trace-3" def test_task_orchestration_charter_context_flattens_modules() -> None: charter = SimpleNamespace( id=55, title="内部知识库升级宪章", version=2, status="aligning", content={ "modules": { "module_1": { "problem_statement": "减少重复检索", "goal_statement": "提升命中率 / 降低重复提问", "kpis": "首响 < 3s", }, "module_2": { "in_scope": "问答检索，知识补充", "out_of_scope": "权限模型重构", }, "module_4": { "milestones": "需求冻结\n开发完成", }, "module_5": { "risk_register": "需求膨胀; 依赖不清", }, "module_6": { "governance_rule": "附件仅作证据引用", }, } }, ) context = SignalCaptureTaskOrchestrationMainMixin._build_task_orchestration_charter_context(charter) assert context["title"] == "内部知识库升级宪章" assert context["summary"] == "减少重复检索" assert context["objectives"] == ["提升命中率", "降低重复提问"] assert context["in_scope"] == ["问答检索", "知识补充"] assert context["out_of_scope"] == ["权限模型重构"] assert context["milestones"] == ["需求冻结", "开发完成"] assert "附件仅作证据引用" in context["constraints"][0] def test_task_orchestration_prompt_embeds_charter_context() -> None: prompt = SignalCaptureTaskOrchestrationMainMixin._build_task_orchestration_prompt( project_payload={ "id": 6, "title": "内部知识库升级", "description": "围绕内部知识库问答能力升级", "assigned_role": "backend", "status": "active", }, charter_payload={ "id": 55, "title": "内部知识库升级宪章", "version": 2, "status": "aligning", "summary": "减少重复检索", "objectives": ["提升命中率", "降低重复提问"], "scope": "知识库检索与问答", "in_scope": ["问答检索", "知识补充"], "out_of_scope": ["权限模型重构"], "success_criteria": ["首响 < 3s"], "constraints": ["附件仅作证据引用"], "milestones": ["需求冻结", "开发完成"], "risks": ["需求膨胀"], }, signal_payload={ "signal_id": 8, "message": "支持导出知识库内容", "classification": {"classification": "new_project"}, "proposer": "测试用户", "captured_at": "2026-03-25T10:00:00+08:00", }, team_members=[ {"user_id": 1, "name": "Alice", "workload_ratio": 42.0, "skill_tag_ids": [11, 12]}, ], ) assert "charter_json" in prompt assert "内部知识库升级宪章" in prompt assert "success_criteria" in prompt assert "附件仅作证据引用" in prompt def test_task_orchestration_fallback_uses_charter_context() -> None: class _FakeSkill(SignalCaptureTaskOrchestrationSkillMixin): @staticmethod def _normalize_single_line_text(text: str, max_len: int = 64) -> str: return " ".join(str(text or "").split())[:max_len] tasks = _FakeSkill()._build_task_orchestration_fallback( cleaned_message="新增内部知识库导出需求", classification={"summary": "补充内部知识库导出能力"}, charter_context={ "title": "内部知识库升级宪章", "summary": "围绕内部知识库问答体验升级", }, ) assert len(tasks) == 2 assert all("内部知识库升级宪章" in task["description"] for task in tasks) def test_queue_confirm_undo_prefers_feishu_message_id_for_idempotency() -> None: item = _Item(item_id=42, level="command", operation_code="project.create") key = FeishuPipelineQueueConfirmUndoMixin._build_operation_idempotency_key(item=item) assert key == "feishu:msg-42" def test_task_create_idempotency_key_prefers_message_key() -> None: key_one = FeishuPipelineCommandCommitTaskMixin._build_task_create_idempotency_key( idempotency_key="feishu:sm-456", trace_id="trace-1", ) key_two = FeishuPipelineCommandCommitTaskMixin._build_task_create_idempotency_key( idempotency_key="feishu:sm-456", trace_id="trace-2", ) fallback_key = FeishuPipelineCommandCommitTaskMixin._build_task_create_idempotency_key( idempotency_key=None, trace_id="trace-3", ) assert key_one == "feishu:sm-456" assert key_two == "feishu:sm-456" assert fallback_key == "trace-3" @pytest.mark.asyncio async def test_task_create_replays_existing_ledger_without_persisting_task(monkeypatch) -> None: from app.services.integrations.feishu_signal_pipeline import mixin_command_commit_task as task_commit_module class _FakeResult: def __init__(self, value) -> None: self._value = value def scalar_one_or_none(self): return self._value def scalars(self): return self def first(self): return self._value class _FakeDB: def __init__(self) -> None: self.calls = 0 self.committed = False async def execute(self, query): self.calls += 1 if self.calls == 1: return _FakeResult(type("ProjectRow", (), {"id": 11, "tenant_id": 1})()) if self.calls == 2: return _FakeResult(type("TruthNodeRow", (), {"id": 22, "tenant_id": 1})()) raise AssertionError("unexpected execute") async def commit(self): self.committed = True class _FakeLedger: def __init__(self) -> None: self.status = "applied" self.result_payload = { "status": "applied", "message": "task created #777", "entity_type": "task", "entity_id": "777", "result": { "task_id": 777, "title": "补充埋点", "project_id": 11, }, } class _FakeCommit(FeishuPipelineCommandCommitTaskMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 self.sync_called = False async def _load_task_create_ledger(self, *, idempotency_key): self.loaded_key = idempotency_key return _FakeLedger() async def _claim_task_create_ledger(self, *, idempotency_key, trace_id, payload): raise AssertionError("ledger claim should not be reached when replaying an applied result") def _sync_task_rag(self, *, task): self.sync_called = True async def _fail_persist_task(*args, **kwargs): raise AssertionError("persist_task should not be called when replaying an existing ledger") monkeypatch.setattr(task_commit_module, "persist_task", _fail_persist_task) kernel = _FakeCommit() result = await kernel._commit_task_create( operator_user=type("User", (), {"id": 9})(), payload={"project_id": 11, "title": "补充埋点", "description": "补充行为埋点"}, trace_id="trace-task-1", idempotency_key="feishu:msg-777", ) assert result["status"] == "applied" assert result["result"]["task_id"] == 777 assert kernel.loaded_key == "feishu:msg-777" assert kernel.db.committed is False assert kernel.sync_called is False @pytest.mark.asyncio async def test_project_gate_always_queues_ready_create(monkeypatch) -> None: called: dict[str, object] = {} class _FakeGate(FeishuPipelineGateProjectMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 @staticmethod def _build_project_clarification_message(missing_fields): return "请补充项目信息。" @staticmethod def _stable_positive_int(*parts): return 42 async def _resolve_command_operator_user(self, *, sender): called["operator_sender"] = sender return object() def _can_execute_high_value_action(self, operator_user): called["can_execute"] = operator_user return True async def _queue_project_intent_item(self, **kwargs): called["queue_kwargs"] = kwargs return { "item_id": 42, "level": "project", "project_id": None, "signal_id": None, "route_status": "queued", "clarification_message": "建项目已进入待确认队列，请点击继续执行。", } async def _write_processing_log(self, **kwargs): called["write_processing_log"] = kwargs async def _execute_controlled_operation(self, **kwargs): raise AssertionError("project.create should not execute before confirmation") kernel = _FakeGate() result = await kernel._handle_create_project_gate( message="请创建一个新项目《AI PMO闭环重构实战-0314》：目标是完成工作流路由重构并上线验收。", sender="林宇航", source_chat_id="chat-1", source_sender_open_id="ou-1", feishu_message_id="msg-1", captured_at=None, intent_gate={ "intent": "project.create", "fields": { "ready": True, "title": "AI PMO闭环重构实战-0314", "description": "目标是完成工作流路由重构并上线验收。", "project_scope": "workflow routing", }, }, process_started_at=0.0, ) assert result["direct_reply_required"] is True assert result["created_project_id"] is None assert result["results"][0]["item_id"] == 42 assert result["reply_template_key"] == "queue_pending_confirm" assert result["queue_item_id"] == 42 assert called["queue_kwargs"]["message"].startswith("请创建一个新项目") @pytest.mark.asyncio async def test_signal_route_item_ignores_low_confidence_threshold_when_project_is_matched() -> None: class _FakeDBResult: def scalar_one_or_none(self): return None class _FakeDB: def __init__(self) -> None: self.added = [] async def execute(self, query): _ = query return _FakeDBResult() def add(self, obj): self.added.append(obj) async def flush(self): return None class _FakeFinalize(FeishuPipelineItemFinalizeRoutingMixin, FeishuPipelineMessageUtilsBMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 self.log_kwargs: dict[str, object] = {} self.notified: tuple[int, int] | None = None async def _ensure_signal_link(self, *, signal_id: int, project_id: int) -> None: _ = (signal_id, project_id) async def _write_processing_log(self, **kwargs): self.log_kwargs = kwargs async def _notify_signal_auto_entered(self, *, project_id: int, signal) -> None: self.notified = (project_id, int(signal.id)) item = SimpleNamespace(id=1) signal = SimpleNamespace(id=88, title="直播礼物量分析") kernel = _FakeFinalize() result = await kernel._route_signal_item( item=item, signal=signal, matched_project_id=62, confidence=0.03, cold_start_enabled=False, signal_auto_enter_threshold=0.80, ) assert result == 62 assert item.safe_to_auto_execute is True assert item.auto_execute_state == "done" assert item.blocking_reason is None assert item.route_status == "auto_done" assert kernel.notified == (62, 88)