初始化提交

backend/tests/modules/knocking/test_conditions.py

@@ -0,0 +1,303 @@
+"""叩心枢触发条件单元测试。"""
+
+# ruff: noqa: ARG002 — pytest fixture params are intentionally unused in test signatures
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.modules.knocking.conditions import (
+    AnniversaryCondition,
+    BigCycleCompletedCondition,
+    ConditionResult,
+    CuriosityCondition,
+    EmotionChangeCondition,
+    EvolutionAppliedCondition,
+    MemoryRecallCondition,
+    ProactiveCondition,
+    RelationshipMilestoneCondition,
+    TimeElapsedCondition,
+    TimeOfDayCondition,
+    UserReunionCondition,
+)
+
+
+class TestTimeElapsedCondition:
+    """空闲超时条件测试。"""
+
+    async def test_not_triggered_when_no_history(self, db_session: AsyncSession) -> None:
+        cond = TimeElapsedCondition(min_idle_minutes=360)
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_when_idle_exceeds_threshold(
+        self, db_session: AsyncSession, seed_old_message: None
+    ) -> None:
+        cond = TimeElapsedCondition(min_idle_minutes=1)
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "idle"
+
+    async def test_not_triggered_when_recent_message(
+        self, db_session: AsyncSession, seed_recent_message: None
+    ) -> None:
+        cond = TimeElapsedCondition(min_idle_minutes=360)
+        now = datetime.now(UTC)
+        result = await cond.check("char_test", db_session, now=now)
+        assert not result.triggered
+
+
+class TestTimeOfDayCondition:
+    async def test_morning_match(self) -> None:
+        cond = TimeOfDayCondition(windows=["morning"])
+        now = datetime(2026, 6, 27, 7, 0, 0, tzinfo=UTC)
+        result = await cond.check("char_test", None, now=now)
+        assert result.triggered
+        assert result.condition_name == "time_of_day"
+
+    async def test_late_night_match(self) -> None:
+        cond = TimeOfDayCondition(windows=["late_night"])
+        now = datetime(2026, 6, 27, 23, 0, 0, tzinfo=UTC)
+        result = await cond.check("char_test", None, now=now)
+        assert result.triggered
+        assert result.context.get("time_of_day") == "late_night"
+
+    async def test_no_match_outside_window(self) -> None:
+        cond = TimeOfDayCondition(windows=["morning"])
+        now = datetime(2026, 6, 27, 14, 0, 0, tzinfo=UTC)
+        result = await cond.check("char_test", None, now=now)
+        assert not result.triggered
+
+
+class TestAnniversaryCondition:
+    async def test_not_triggered_on_first_call_no_data(self, db_session: AsyncSession) -> None:
+        cond = AnniversaryCondition()
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_when_anniversary_exists(
+        self, db_session: AsyncSession, seed_anniversary: None
+    ) -> None:
+        cond = AnniversaryCondition()
+        now = datetime(2026, 6, 27, 12, 0, 0, tzinfo=UTC)
+        result = await cond.check("char_test", db_session, now=now)
+        assert result.triggered
+        assert result.condition_name == "anniversary"
+        assert "birthday" in result.context.get("anniversary_kind", "")
+
+    async def test_not_duplicated_same_day(
+        self, db_session: AsyncSession, seed_anniversary: None
+    ) -> None:
+        cond = AnniversaryCondition()
+        now = datetime(2026, 6, 27, 12, 0, 0, tzinfo=UTC)
+        result1 = await cond.check("char_test", db_session, now=now)
+        assert result1.triggered
+        result2 = await cond.check("char_test", db_session, now=now)
+        assert not result2.triggered  # 同一天不重复
+
+
+class TestUserReunionCondition:
+    async def test_not_triggered_when_no_event(self, db_session: AsyncSession) -> None:
+        cond = UserReunionCondition()
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+
+class TestEmotionChangeCondition:
+    async def test_not_triggered_on_first_check(
+        self, db_session: AsyncSession, seed_emotion_state: None
+    ) -> None:
+        cond = EmotionChangeCondition(min_delta=0.3)
+        result = await cond.check("char_test", db_session)
+        assert not result.triggered  # 首次无基线
+
+    async def test_triggered_when_intensity_changes(
+        self, db_session: AsyncSession, seed_emotion_state: None
+    ) -> None:
+        cond = EmotionChangeCondition(min_delta=0.3)
+        await cond.check("char_test", db_session)  # 首次建立基线
+
+        # 更新情绪 intensity 到 0.8（变化 0.6 > 0.3）
+        from app.models.personality_emotion import CharacterEmotionState
+
+        result = await db_session.execute(
+            select(CharacterEmotionState).where(CharacterEmotionState.character_id == "char_test")
+        )
+        state = result.scalar_one()
+        state.intensity = 0.8
+        state.mood = "melancholy"
+        await db_session.commit()
+
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "emotion"
+
+
+class TestCuriosityCondition:
+    async def test_not_triggered_when_no_active_questions(self, db_session: AsyncSession) -> None:
+        cond = CuriosityCondition()
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_when_active_question_exists(
+        self, db_session: AsyncSession, seed_curiosity: None
+    ) -> None:
+        cond = CuriosityCondition()
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "curiosity"
+        assert "curiosity_question" in result.context
+        assert result.context["curiosity_question"] == "你为什么总是沉默？"
+
+
+class TestEvolutionAppliedCondition:
+    """演化应用条件测试。"""
+
+    async def test_not_triggered_when_no_applied(self, db_session: AsyncSession) -> None:
+        cond = EvolutionAppliedCondition()
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_when_applied_exists(
+        self, db_session: AsyncSession, seed_applied_evolution: None
+    ) -> None:
+        cond = EvolutionAppliedCondition()
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "evolution_applied"
+        assert result.context.get("evolution_title") == "语气更柔和"
+        assert result.context.get("evolution_level") == "L3"
+        assert "evolution_proposal" in result.context
+
+    async def test_not_duplicated(
+        self, db_session: AsyncSession, seed_applied_evolution: None
+    ) -> None:
+        cond = EvolutionAppliedCondition()
+        result1 = await cond.check("char_test", db_session)
+        assert result1.triggered
+        result2 = await cond.check("char_test", db_session)
+        assert not result2.triggered  # 同一条不重复触发
+
+
+class TestBigCycleCompletedCondition:
+    """大周天完成条件测试。"""
+
+    async def test_not_triggered_when_no_completed(self, db_session: AsyncSession) -> None:
+        cond = BigCycleCompletedCondition()
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_when_completed_exists(
+        self, db_session: AsyncSession, seed_completed_big_cycle: None
+    ) -> None:
+        cond = BigCycleCompletedCondition()
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "big_cycle_completed"
+        assert "big_cycle_summary" in result.context
+        assert "big_cycle_trigger" in result.context
+
+    async def test_not_duplicated(
+        self, db_session: AsyncSession, seed_completed_big_cycle: None
+    ) -> None:
+        cond = BigCycleCompletedCondition()
+        result1 = await cond.check("char_test", db_session)
+        assert result1.triggered
+        result2 = await cond.check("char_test", db_session)
+        assert not result2.triggered  # 同一条不重复触发
+
+
+class TestMemoryRecallCondition:
+    """记忆唤醒条件测试。"""
+
+    async def test_not_triggered_when_no_memory(self, db_session: AsyncSession) -> None:
+        cond = MemoryRecallCondition()
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_when_new_memory_exists(
+        self, db_session: AsyncSession, seed_new_memory: None
+    ) -> None:
+        cond = MemoryRecallCondition()
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "memory_recall"
+        assert result.context.get("memory_title") == "今天去了海边"
+        assert "memory_content" in result.context
+        assert "memory_type" in result.context
+
+    async def test_not_duplicated(self, db_session: AsyncSession, seed_new_memory: None) -> None:
+        cond = MemoryRecallCondition()
+        result1 = await cond.check("char_test", db_session)
+        assert result1.triggered
+        result2 = await cond.check("char_test", db_session)
+        assert not result2.triggered  # 同一条不重复触发
+
+
+class TestRelationshipMilestoneCondition:
+    """关系里程碑条件测试。"""
+
+    async def test_not_triggered_when_no_messages(self, db_session: AsyncSession) -> None:
+        cond = RelationshipMilestoneCondition(message_milestones=[5], day_milestones=[30])
+        result = await cond.check("char_nonexistent", db_session)
+        assert not result.triggered
+
+    async def test_triggered_by_message_count(
+        self, db_session: AsyncSession, seed_many_messages: None
+    ) -> None:
+        cond = RelationshipMilestoneCondition(message_milestones=[5], day_milestones=[9999])
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "relationship_milestone"
+        assert result.context.get("milestone_type") == "messages"
+        assert result.context.get("milestone_value") == 5
+        assert result.context.get("milestone_threshold") == 5
+
+    async def test_triggered_by_days(
+        self, db_session: AsyncSession, seed_old_relationship: None
+    ) -> None:
+        cond = RelationshipMilestoneCondition(message_milestones=[9999], day_milestones=[30])
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.condition_name == "relationship_milestone"
+        assert result.context.get("milestone_type") == "days"
+        assert result.context.get("milestone_value") >= 30
+        assert result.context.get("milestone_threshold") == 30
+
+    async def test_not_duplicated(self, db_session: AsyncSession, seed_many_messages: None) -> None:
+        cond = RelationshipMilestoneCondition(message_milestones=[5], day_milestones=[9999])
+        result1 = await cond.check("char_test", db_session)
+        assert result1.triggered
+        result2 = await cond.check("char_test", db_session)
+        assert not result2.triggered  # 同一里程碑不重复触发
+
+    async def test_prefers_messages_over_days(
+        self, db_session: AsyncSession, seed_many_messages: None, seed_old_relationship: None
+    ) -> None:
+        """同时满足消息和天数里程碑时，优先触发消息里程碑。"""
+        cond = RelationshipMilestoneCondition(message_milestones=[5], day_milestones=[30])
+        result = await cond.check("char_test", db_session)
+        assert result.triggered
+        assert result.context.get("milestone_type") == "messages"  # 消息优先
+
+
+@pytest.mark.asyncio
+async def test_proactive_condition_protocol() -> None:
+    """验证 ProactiveCondition 可作为 Protocol 使用。"""
+
+    class DummyCondition(ProactiveCondition):
+        async def check(
+            self,
+            _character_id: str,
+            _session: AsyncSession | None = None,
+            *,
+            _now: datetime | None = None,
+        ) -> ConditionResult:
+            return ConditionResult(triggered=True, trigger_reason="测试", condition_name="dummy")
+
+    cond: ProactiveCondition = DummyCondition()
+    result = await cond.check("char_test")
+    assert result.triggered