初始化提交

backend/tests/repositories/test_drive_repo.py

@@ -0,0 +1,107 @@
+"""内驱力数据访问测试（好奇问题 + 次生目标）。"""
+
+import pytest
+
+from app.db.session import AsyncSessionLocal
+from app.models.big_cycle import BigCycle
+from app.models.drive import CuriosityQuestion, ExploratorySubgoal
+from app.repositories import drive as drive_repo
+from app.services.characters import get_active_character_model
+
+
+async def _seed_cycle(session, character_id: str) -> str:
+    cycle = BigCycle(
+        character_id=character_id,
+        trigger="test",
+        status="completed",
+        memory_count_at_trigger=20,
+    )
+    session.add(cycle)
+    await session.flush()
+    return cycle.id
+
+
+def _curiosity(character_id: str, cycle_id: str, **overrides) -> CuriosityQuestion:
+    base = {
+        "character_id": character_id,
+        "cycle_id": cycle_id,
+        "question": "q",
+        "source": "memory_gap",
+        "related_entities_json": "[]",
+        "expected_value": 0.5,
+        "urgency": 0.5,
+        "risk_level": "L2",
+    }
+    base.update(overrides)
+    return CuriosityQuestion(**base)
+
+
+def _subgoal(
+    character_id: str, cycle_id: str, curiosity_id: str, **overrides
+) -> ExploratorySubgoal:
+    base = {
+        "character_id": character_id,
+        "cycle_id": cycle_id,
+        "curiosity_question_id": curiosity_id,
+        "title": "t",
+        "description": "d",
+        "expected_information_gain": 0.6,
+        "interruption_cost": 0.3,
+        "risk_level": "L2",
+        "status": "candidate",
+    }
+    base.update(overrides)
+    return ExploratorySubgoal(**base)
+
+
+@pytest.mark.asyncio
+async def test_curiosity_add_get_list() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cycle_id = await _seed_cycle(session, character.id)
+        curios = _curiosity(character.id, cycle_id, question="为何频繁提到项目X")
+        await drive_repo.add_curiosities(session, [curios])
+        await drive_repo.add_curiosities(
+            session, [_curiosity(character.id, cycle_id, source="world_uncertainty")]
+        )
+        await session.commit()
+        cid = curios.id
+
+    async with AsyncSessionLocal() as session:
+        fetched = await drive_repo.get_curiosity(session, cid)
+        all_items, total = await drive_repo.list_curiosities(session, character.id)
+        gap, gap_total = await drive_repo.list_curiosities(
+            session, character.id, source="memory_gap"
+        )
+    assert fetched is not None
+    assert fetched.question == "为何频繁提到项目X"
+    assert total == 2
+    assert gap_total == 1
+
+
+@pytest.mark.asyncio
+async def test_subgoal_add_get_list() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cycle_id = await _seed_cycle(session, character.id)
+        curios = _curiosity(character.id, cycle_id)
+        await drive_repo.add_curiosities(session, [curios])
+        await session.flush()
+        curiosity_id = curios.id
+        sub = _subgoal(character.id, cycle_id, curiosity_id, title="询问项目目标")
+        await drive_repo.add_subgoals(session, [sub])
+        await drive_repo.add_subgoals(
+            session, [_subgoal(character.id, cycle_id, curiosity_id, status="approved")]
+        )
+        await session.commit()
+        sid = sub.id
+
+    async with AsyncSessionLocal() as session:
+        fetched = await drive_repo.get_subgoal(session, sid)
+        _, total = await drive_repo.list_subgoals(session, character.id)
+        cand, cand_total = await drive_repo.list_subgoals(session, character.id, status="candidate")
+    assert fetched is not None
+    assert fetched.title == "询问项目目标"
+    assert fetched.curiosity_question_id == curiosity_id
+    assert total == 2
+    assert cand_total == 1

backend/tests/repositories/test_evolution_repo.py

@@ -0,0 +1,100 @@
+"""演化候选数据访问测试。"""
+
+import pytest
+
+from app.db.session import AsyncSessionLocal
+from app.models.big_cycle import BigCycle
+from app.models.evolution import EvolutionCandidate
+from app.repositories import evolution as evolution_repo
+from app.repositories.json_utils import dumps
+from app.services.characters import get_active_character_model
+
+
+async def _seed_cycle(session, character_id: str) -> str:
+    cycle = BigCycle(
+        character_id=character_id,
+        trigger="test",
+        status="completed",
+        memory_count_at_trigger=20,
+    )
+    session.add(cycle)
+    await session.flush()
+    return cycle.id
+
+
+def _make_candidate(character_id: str, cycle_id: str, **overrides) -> EvolutionCandidate:
+    base = {
+        "character_id": character_id,
+        "cycle_id": cycle_id,
+        "type": "personality",
+        "source": "big_cycle",
+        "level": "L4",
+        "scope": "character_scope",
+        "title": "t",
+        "proposal": "p",
+        "delta_json": dumps({}),
+        "evidence_ids_json": "[]",
+        "confidence": 0.5,
+        "benefit_score": 0.5,
+        "risk_score": 0.5,
+        "drift_score": 0.0,
+        "auto_apply_allowed": False,
+        "status": "pending",
+    }
+    base.update(overrides)
+    return EvolutionCandidate(**base)
+
+
+@pytest.mark.asyncio
+async def test_add_and_get_candidate() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cycle_id = await _seed_cycle(session, character.id)
+        candidate = _make_candidate(character.id, cycle_id, title="身份调整")
+        await evolution_repo.add_candidates(session, [candidate])
+        await session.commit()
+        cid = candidate.id
+
+    async with AsyncSessionLocal() as session:
+        fetched = await evolution_repo.get_candidate(session, cid)
+    assert fetched is not None
+    assert fetched.title == "身份调整"
+    assert fetched.status == "pending"
+    assert fetched.source == "big_cycle"
+
+
+@pytest.mark.asyncio
+async def test_list_candidates_with_filters_and_paging() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cycle_id = await _seed_cycle(session, character.id)
+        await evolution_repo.add_candidates(
+            session,
+            [
+                _make_candidate(character.id, cycle_id, type="personality", status="pending"),
+                _make_candidate(character.id, cycle_id, type="procedural", status="applied"),
+                _make_candidate(character.id, cycle_id, type="procedural", status="pending"),
+            ],
+        )
+        await session.commit()
+
+    async with AsyncSessionLocal() as session:
+        all_items, total = await evolution_repo.list_candidates(session, character.id)
+        assert total == 3
+        assert len(all_items) == 3
+
+        pending, pending_total = await evolution_repo.list_candidates(
+            session, character.id, status="pending"
+        )
+        assert pending_total == 2
+        assert len(pending) == 2
+
+        procedural, proc_total = await evolution_repo.list_candidates(
+            session, character.id, candidate_type="procedural"
+        )
+        assert proc_total == 2
+
+        page1, _ = await evolution_repo.list_candidates(session, character.id, page=1, page_size=2)
+        page2, _ = await evolution_repo.list_candidates(session, character.id, page=2, page_size=2)
+        assert len(page1) == 2
+        assert len(page2) == 1

backend/tests/repositories/test_governance_repo.py

@@ -0,0 +1,62 @@
+"""太一枢目标数据访问测试（per-character 查询 + 进度更新）。"""
+
+import pytest
+
+from app.db.session import AsyncSessionLocal
+from app.models.governance import Goal
+from app.repositories import governance as repo
+
+
+@pytest.mark.asyncio
+async def test_list_goals_by_character() -> None:
+    """返回指定 character_id 的目标列表。"""
+    async with AsyncSessionLocal() as session:
+        g1 = Goal(id="goal_1", title="t1", level="task", character_id="char_a")
+        g2 = Goal(id="goal_2", title="t2", level="task", character_id="char_b")
+        session.add_all([g1, g2])
+        await session.flush()
+
+        goals = await repo.list_goals_by_character(session, "char_a")
+        assert len(goals) == 1
+        assert goals[0].id == "goal_1"
+
+
+@pytest.mark.asyncio
+async def test_list_goals_by_character_filters_status() -> None:
+    """按 status 过滤指定角色的目标。"""
+    async with AsyncSessionLocal() as session:
+        g1 = Goal(id="goal_3", title="t3", level="task", character_id="char_c", status="active")
+        g2 = Goal(
+            id="goal_4",
+            title="t4",
+            level="task",
+            character_id="char_c",
+            status="completed",
+        )
+        session.add_all([g1, g2])
+        await session.flush()
+
+        goals = await repo.list_goals_by_character(session, "char_c", status_filter="active")
+        assert len(goals) == 1
+        assert goals[0].id == "goal_3"
+
+
+@pytest.mark.asyncio
+async def test_update_goal_progress() -> None:
+    """更新目标的 progress 字段。"""
+    async with AsyncSessionLocal() as session:
+        goal = Goal(id="goal_5", title="t5", level="task")
+        session.add(goal)
+        await session.flush()
+
+        updated = await repo.update_goal_progress(session, "goal_5", 0.75)
+        assert updated is not None
+        assert updated.progress == 0.75
+
+
+@pytest.mark.asyncio
+async def test_update_goal_progress_nonexistent() -> None:
+    """更新不存在的目标返回 None。"""
+    async with AsyncSessionLocal() as session:
+        result = await repo.update_goal_progress(session, "goal_nonexistent", 0.5)
+        assert result is None

backend/tests/repositories/test_mcp_servers_repo.py

@@ -0,0 +1,62 @@
+"""MCP server 数据访问测试。"""
+
+import pytest
+from sqlalchemy.exc import IntegrityError
+
+from app.db.session import AsyncSessionLocal
+from app.models.mcp_servers import McpServer
+from app.repositories import mcp_servers as mcp_repo
+
+
+def _server(name: str = "weather", **overrides) -> McpServer:
+    base = {
+        "name": name,
+        "endpoint_url": "http://mcp.local",
+        "auth_token": None,
+        "status": "enabled",
+        "tools_json": "[]",
+    }
+    base.update(overrides)
+    return McpServer(**base)
+
+
+@pytest.mark.asyncio
+async def test_add_and_get() -> None:
+    async with AsyncSessionLocal() as session:
+        s = _server()
+        await mcp_repo.add_server(session, s)
+        await session.commit()
+        sid = s.id
+
+    async with AsyncSessionLocal() as session:
+        fetched = await mcp_repo.get_server(session, sid)
+    assert fetched is not None
+    assert fetched.name == "weather"
+    assert fetched.endpoint_url == "http://mcp.local"
+
+
+@pytest.mark.asyncio
+async def test_list_with_status_filter() -> None:
+    async with AsyncSessionLocal() as session:
+        await mcp_repo.add_server(session, _server("a", status="enabled"))
+        await mcp_repo.add_server(session, _server("b", status="disabled"))
+        await session.commit()
+
+    async with AsyncSessionLocal() as session:
+        enabled = await mcp_repo.list_servers(session, status="enabled")
+        all_servers = await mcp_repo.list_servers(session)
+    assert len(enabled) == 1
+    assert enabled[0].name == "a"
+    assert len(all_servers) == 2
+
+
+@pytest.mark.asyncio
+async def test_name_unique_conflict() -> None:
+    async with AsyncSessionLocal() as session:
+        await mcp_repo.add_server(session, _server("dup"))
+        await session.commit()
+
+    async with AsyncSessionLocal() as session:
+        with pytest.raises(IntegrityError):
+            await mcp_repo.add_server(session, _server("dup"))
+            await session.commit()

backend/tests/repositories/test_personality_emotion_repo.py

@@ -0,0 +1,93 @@
+"""灵核情绪状态数据访问测试（设计 §11.4）。"""
+
+import pytest
+
+from app.db.session import AsyncSessionLocal
+from app.models.personality_emotion import CharacterEmotionState
+from app.repositories import personality_emotion as emotion_repo
+from app.services.characters import get_active_character_model
+
+
+def _state(character_id: str, **overrides) -> CharacterEmotionState:
+    base = {
+        "character_id": character_id,
+        "mood": "touched",
+        "intensity": 0.7,
+        "baseline_mood": "neutral",
+        "baseline_intensity": 0.2,
+        "last_trigger_event_id": "evt_abc",
+    }
+    base.update(overrides)
+    return CharacterEmotionState(**base)
+
+
+@pytest.mark.asyncio
+async def test_get_state_returns_none_when_absent() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        assert await emotion_repo.get_state(session, character.id) is None
+
+
+@pytest.mark.asyncio
+async def test_upsert_state_inserts_new() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cid = character.id
+        created = await emotion_repo.upsert_state(session, _state(cid))
+        await session.commit()
+        assert created.mood == "touched"
+        assert created.intensity == 0.7
+    async with AsyncSessionLocal() as session:
+        fetched = await emotion_repo.get_state(session, cid)
+        assert fetched is not None
+        assert fetched.mood == "touched"
+        assert fetched.last_trigger_event_id == "evt_abc"
+
+
+@pytest.mark.asyncio
+async def test_upsert_state_updates_existing() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cid = character.id
+        await emotion_repo.upsert_state(session, _state(cid, mood="touched", intensity=0.7))
+        await emotion_repo.upsert_state(
+            session,
+            _state(
+                cid,
+                mood="concerned",
+                intensity=0.5,
+                last_trigger_event_id="evt_def",
+            ),
+        )
+        await session.commit()
+    async with AsyncSessionLocal() as session:
+        fetched = await emotion_repo.get_state(session, cid)
+        assert fetched is not None
+        assert fetched.mood == "concerned"
+        assert fetched.intensity == 0.5
+        assert fetched.last_trigger_event_id == "evt_def"
+
+
+@pytest.mark.asyncio
+async def test_upsert_state_single_row_per_character() -> None:
+    """单行 per character：重复 upsert 不产生重复行。"""
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        cid = character.id
+        await emotion_repo.upsert_state(session, _state(cid))
+        await emotion_repo.upsert_state(session, _state(cid))
+        await emotion_repo.upsert_state(session, _state(cid))
+        await session.commit()
+    async with AsyncSessionLocal() as session:
+        from sqlalchemy import func, select
+
+        count = int(
+            (
+                await session.execute(
+                    select(func.count())
+                    .select_from(CharacterEmotionState)
+                    .where(CharacterEmotionState.character_id == cid)
+                )
+            ).scalar_one()
+        )
+        assert count == 1

backend/tests/repositories/test_skills_repo.py

@@ -0,0 +1,65 @@
+"""Skill 数据访问测试。"""
+
+import pytest
+from sqlalchemy.exc import IntegrityError
+
+from app.db.session import AsyncSessionLocal
+from app.models.skills import Skill
+from app.repositories import skills as skills_repo
+
+
+def _skill(name: str = "coding", **overrides) -> Skill:
+    base = {
+        "name": name,
+        "description": "代码辅助",
+        "trigger": "代码,编程",
+        "prompt_fragment": "你是代码助手",
+        "tool_bindings_json": "[]",
+        "risk_level": "L1",
+        "status": "enabled",
+    }
+    base.update(overrides)
+    return Skill(**base)
+
+
+@pytest.mark.asyncio
+async def test_add_and_get_skill() -> None:
+    async with AsyncSessionLocal() as session:
+        s = _skill()
+        await skills_repo.add_skill(session, s)
+        await session.commit()
+        sid = s.id
+
+    async with AsyncSessionLocal() as session:
+        fetched = await skills_repo.get_skill(session, sid)
+    assert fetched is not None
+    assert fetched.name == "coding"
+    assert fetched.trigger == "代码,编程"
+    assert fetched.status == "enabled"
+
+
+@pytest.mark.asyncio
+async def test_list_skills_with_status_filter() -> None:
+    async with AsyncSessionLocal() as session:
+        await skills_repo.add_skill(session, _skill("a", status="enabled"))
+        await skills_repo.add_skill(session, _skill("b", status="disabled"))
+        await session.commit()
+
+    async with AsyncSessionLocal() as session:
+        enabled = await skills_repo.list_skills(session, status="enabled")
+        all_skills = await skills_repo.list_skills(session)
+    assert len(enabled) == 1
+    assert enabled[0].name == "a"
+    assert len(all_skills) == 2
+
+
+@pytest.mark.asyncio
+async def test_name_unique_conflict() -> None:
+    async with AsyncSessionLocal() as session:
+        await skills_repo.add_skill(session, _skill("dup"))
+        await session.commit()
+
+    async with AsyncSessionLocal() as session:
+        with pytest.raises(IntegrityError):
+            await skills_repo.add_skill(session, _skill("dup"))
+            await session.commit()

backend/tests/repositories/test_time_anniversaries_repo.py

@@ -0,0 +1,79 @@
+"""时态纪念日数据访问测试（辰正 §5.3）。"""
+
+import pytest
+
+from app.db.session import AsyncSessionLocal
+from app.models.time_anniversary import TimeAnniversary
+from app.repositories import time_anniversaries as anni_repo
+from app.services.characters import get_active_character_model
+
+
+def _anniversary(character_id: str, **overrides) -> TimeAnniversary:
+    base = {
+        "character_id": character_id,
+        "name": "我们的相遇日",
+        "calendar": "solar",
+        "date": "2025-09-19",
+        "recurs_yearly": True,
+        "kind": "anniversary",
+        "subject_type": "relationship",
+        "source": "auto",
+        "metadata_json": "{}",
+    }
+    base.update(overrides)
+    return TimeAnniversary(**base)
+
+
+@pytest.mark.asyncio
+async def test_create_and_get_anniversary() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        created = await anni_repo.create_anniversary(session, _anniversary(character.id))
+        fetched = await anni_repo.get_anniversary(session, created.id)
+        assert fetched is not None
+        assert fetched.name == "我们的相遇日"
+        assert fetched.id.startswith("anniv_")
+
+
+@pytest.mark.asyncio
+async def test_list_anniversaries_by_character() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        await anni_repo.create_anniversary(session, _anniversary(character.id, date="2025-03-01"))
+        await anni_repo.create_anniversary(session, _anniversary(character.id, date="2025-09-19"))
+        items = await anni_repo.list_anniversaries(session, character.id)
+        # 默认人物 seed 时已带 1 条 birthday 纪念日；此处只验证 anniversary kind 的列表行为
+        anniversary_items = [a for a in items if a.kind == "anniversary"]
+        assert len(anniversary_items) == 2
+        # list 默认按 date 升序
+        assert anniversary_items[0].date < anniversary_items[1].date
+
+
+@pytest.mark.asyncio
+async def test_update_anniversary() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        created = await anni_repo.create_anniversary(session, _anniversary(character.id))
+        updated = await anni_repo.update_anniversary(
+            session, created.id, name="相识纪念日", source="manual"
+        )
+        assert updated is not None
+        assert updated.name == "相识纪念日"
+        assert updated.source == "manual"
+
+
+@pytest.mark.asyncio
+async def test_update_anniversary_missing_returns_none() -> None:
+    async with AsyncSessionLocal() as session:
+        result = await anni_repo.update_anniversary(session, "anniv_nonexistent", name="x")
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_delete_anniversary() -> None:
+    async with AsyncSessionLocal() as session:
+        character = await get_active_character_model(session)
+        created = await anni_repo.create_anniversary(session, _anniversary(character.id))
+        assert await anni_repo.delete_anniversary(session, created.id) is True
+        assert await anni_repo.get_anniversary(session, created.id) is None
+        assert await anni_repo.delete_anniversary(session, created.id) is False