330 lines
13 KiB
Python
330 lines
13 KiB
Python
from __future__ import annotations
|
|
|
|
import unittest
|
|
from unittest.mock import AsyncMock, patch
|
|
from uuid import uuid4
|
|
|
|
from app.deps import Principal, Role
|
|
from app.services import session_metrics, state_machine
|
|
from app.services.persona import P1, P2, P3
|
|
from app.session_dashboard_projection import (
|
|
dashboard_achievements,
|
|
dashboard_overview,
|
|
dashboard_persona_progress,
|
|
dashboard_training_exposure,
|
|
)
|
|
from app.store import InProcSession, TurnRecord
|
|
|
|
|
|
def _make_session(
|
|
session_id: str,
|
|
session_no: int,
|
|
learner_id: str,
|
|
persona_code: str = "P1",
|
|
ended: bool = True,
|
|
turns: list[TurnRecord] | None = None,
|
|
) -> InProcSession:
|
|
persona = {P1.code: P1, P2.code: P2, P3.code: P3}.get(persona_code, P1)
|
|
state = state_machine.init_state(params=persona.openness_params())
|
|
state.stage = state_machine.Stage.EXPLORE
|
|
sess = InProcSession(
|
|
session_id=session_id,
|
|
case_id=session_id,
|
|
learner_id=learner_id,
|
|
persona_code=persona.code,
|
|
theory_mode="humanistic",
|
|
persona=persona,
|
|
state=state,
|
|
session_no=session_no,
|
|
created_at=1000.0 + session_no * 10.0,
|
|
ended_at=1000.0 + session_no * 10.0 + 600 if ended else None,
|
|
ended=ended,
|
|
turns=[],
|
|
)
|
|
if turns is not None:
|
|
sess.turns = turns
|
|
else:
|
|
sess.turns = [
|
|
TurnRecord(
|
|
turn_seq=1,
|
|
speaker="counselor",
|
|
stage=state.stage.value,
|
|
text="어떤 점이 힘드신가요?",
|
|
text_masked="어떤 점이 힘드신가요?",
|
|
evaluation={
|
|
"appropriateness": "pos",
|
|
"appropriateness_note": "공감적 반응",
|
|
"rapport_signal": 0.6,
|
|
"techniques": [{"label": "reflection"}],
|
|
},
|
|
created_at=1000.0 + session_no * 10.0 + 5.0,
|
|
)
|
|
]
|
|
return sess
|
|
|
|
|
|
class DashboardProjectionTDDTests(unittest.TestCase):
|
|
"""Multi-angle TDD tests for metrics projection invariants (REQ-010)."""
|
|
|
|
def test_learner_growth_metrics_excludes_zero_turn_from_ended_sessions(self) -> None:
|
|
"""LearnerGrowthMetrics.ended_sessions must exclude zero-turn sessions."""
|
|
learner_id = "00000000-0000-0000-0000-000000000111"
|
|
|
|
# Session 1: completed with turns
|
|
sess1 = _make_session("sess-1", 1, learner_id, ended=True)
|
|
# Session 2: zero-turn ended session
|
|
sess2 = _make_session("sess-2", 2, learner_id, ended=True, turns=[])
|
|
# Session 3: active session
|
|
sess3 = _make_session("sess-3", 3, learner_id, ended=False)
|
|
|
|
growth_list = session_metrics.build_learner_growth(
|
|
[sess1, sess2, sess3],
|
|
learner_label=lambda _uid: "홍길동",
|
|
)
|
|
self.assertEqual(len(growth_list), 1)
|
|
growth = growth_list[0]
|
|
|
|
self.assertEqual(growth.sessions, 3)
|
|
# Invariant: ended_sessions must equal completed sessions with dialogue (1), not 2
|
|
self.assertEqual(
|
|
growth.ended_sessions,
|
|
1,
|
|
"ended_sessions in LearnerGrowthMetrics must not count 0-turn sessions",
|
|
)
|
|
|
|
def test_training_exposure_multi_persona_isolation(self) -> None:
|
|
"""Zero-turn sessions must not inflate exposure count across multiple personas."""
|
|
learner_id = "00000000-0000-0000-0000-000000000111"
|
|
|
|
# P1: 1 completed session, 1 zero-turn ended session
|
|
p1_completed = _make_session("sess-p1-1", 1, learner_id, persona_code="P1", ended=True)
|
|
p1_zero = _make_session("sess-p1-2", 2, learner_id, persona_code="P1", ended=True, turns=[])
|
|
|
|
# P2: 1 completed session
|
|
p2_completed = _make_session("sess-p2-1", 3, learner_id, persona_code="P2", ended=True)
|
|
|
|
exposure = dashboard_training_exposure([p1_completed, p1_zero, p2_completed])
|
|
self.assertEqual(exposure.completed_sessions, 2)
|
|
|
|
# Persona progress table check
|
|
progress_rows = dashboard_persona_progress(
|
|
[p1_completed, p1_zero, p2_completed],
|
|
review_ready={},
|
|
)
|
|
p1_row = next(r for r in progress_rows if r.persona_code == "P1")
|
|
p2_row = next(r for r in progress_rows if r.persona_code == "P2")
|
|
|
|
self.assertEqual(p1_row.sessions, 2)
|
|
self.assertEqual(p1_row.completed_sessions, 1)
|
|
self.assertEqual(p2_row.sessions, 1)
|
|
self.assertEqual(p2_row.completed_sessions, 1)
|
|
|
|
def test_achievements_ignore_zero_turn_ended_sessions(self) -> None:
|
|
"""무발화 종료 회기는 성취를 열지 않는다."""
|
|
learner_id = "00000000-0000-0000-0000-000000000111"
|
|
zero_turn = _make_session("sess-zero", 1, learner_id, ended=True, turns=[])
|
|
|
|
achievements = {
|
|
item.id: item
|
|
for item in dashboard_achievements(
|
|
[zero_turn],
|
|
{},
|
|
)
|
|
}
|
|
|
|
self.assertEqual(achievements["first_session_complete"].state, "locked")
|
|
self.assertEqual(achievements["review_ready"].state, "locked")
|
|
self.assertEqual(achievements["review_ready"].detail, "현재 리뷰 가능한 회기 0건입니다.")
|
|
|
|
def test_achievements_ignore_zero_turn_repeat_and_coverage(self) -> None:
|
|
"""무발화 회기는 반복 및 페르소나 연습 기록으로 집계하지 않는다."""
|
|
learner_id = "00000000-0000-0000-0000-000000000111"
|
|
zero_turns = [
|
|
_make_session(
|
|
"sess-zero-1", 1, learner_id, ended=True, turns=[]
|
|
),
|
|
_make_session(
|
|
"sess-zero-2", 2, learner_id, persona_code="P2", ended=True, turns=[]
|
|
),
|
|
_make_session(
|
|
"sess-zero-3", 3, learner_id, persona_code="P3", ended=True, turns=[]
|
|
),
|
|
]
|
|
|
|
achievements = {
|
|
item.id: item
|
|
for item in dashboard_achievements(zero_turns, {})
|
|
}
|
|
|
|
self.assertEqual(achievements["persona_repeat"].state, "locked")
|
|
self.assertEqual(achievements["persona_coverage"].state, "locked")
|
|
|
|
def test_achievements_ignore_client_only_ended_session(self) -> None:
|
|
"""내담자 발화만 있는 종료 회기는 학습 성취를 만들지 않는다."""
|
|
learner_id = "00000000-0000-0000-0000-000000000111"
|
|
client_only = _make_session("sess-client-only", 1, learner_id, ended=True)
|
|
client_only.turns[0].speaker = "client"
|
|
|
|
achievements = {
|
|
item.id: item
|
|
for item in dashboard_achievements(
|
|
[client_only],
|
|
{},
|
|
)
|
|
}
|
|
|
|
self.assertEqual(achievements["first_session_complete"].state, "locked")
|
|
self.assertEqual(achievements["review_ready"].state, "locked")
|
|
self.assertEqual(achievements["persona_repeat"].state, "locked")
|
|
|
|
def test_achievements_keep_dialogue_sessions_and_active_progress(self) -> None:
|
|
"""학습자 발화와 진행 중 회기의 기존 성취 흐름을 유지한다."""
|
|
learner_id = "00000000-0000-0000-0000-000000000111"
|
|
completed = [
|
|
_make_session(f"sess-p1-{index}", index, learner_id, ended=True)
|
|
for index in range(1, 4)
|
|
]
|
|
completed.extend(
|
|
[
|
|
_make_session("sess-p2", 4, learner_id, persona_code="P2", ended=True),
|
|
_make_session("sess-p3", 5, learner_id, persona_code="P3", ended=True),
|
|
]
|
|
)
|
|
active = _make_session("sess-active", 6, learner_id, ended=False)
|
|
|
|
achievements = {
|
|
item.id: item
|
|
for item in dashboard_achievements(
|
|
[*completed, active],
|
|
{completed[0].session_id: True},
|
|
)
|
|
}
|
|
|
|
self.assertEqual(achievements["first_session_complete"].state, "done")
|
|
self.assertEqual(achievements["review_ready"].state, "done")
|
|
self.assertEqual(achievements["persona_repeat"].state, "done")
|
|
self.assertEqual(achievements["persona_coverage"].state, "done")
|
|
|
|
active_only = {
|
|
item.id: item
|
|
for item in dashboard_achievements([active], {})
|
|
}
|
|
self.assertEqual(active_only["first_session_complete"].state, "available")
|
|
self.assertEqual(active_only["persona_repeat"].state, "available")
|
|
|
|
learner_alias = _make_session("sess-learner", 7, learner_id, ended=True)
|
|
learner_alias.turns[0].speaker = "learner"
|
|
learner_alias_achievements = {
|
|
item.id: item
|
|
for item in dashboard_achievements(
|
|
[learner_alias],
|
|
{learner_alias.session_id: True},
|
|
)
|
|
}
|
|
self.assertEqual(learner_alias_achievements["first_session_complete"].state, "done")
|
|
self.assertEqual(learner_alias_achievements["review_ready"].state, "done")
|
|
|
|
empty_active = _make_session(
|
|
"sess-empty-active", 8, learner_id, ended=False, turns=[]
|
|
)
|
|
empty_active_achievements = {
|
|
item.id: item
|
|
for item in dashboard_achievements([empty_active], {})
|
|
}
|
|
self.assertEqual(empty_active_achievements["first_session_complete"].state, "available")
|
|
self.assertEqual(empty_active_achievements["persona_repeat"].state, "locked")
|
|
|
|
|
|
class TeacherDashboardProjectionTDDTests(unittest.IsolatedAsyncioTestCase):
|
|
"""Teacher dashboard projection alignment for zero-turn sessions."""
|
|
|
|
async def test_teacher_dashboard_excludes_zero_turn_from_ended_sessions(self) -> None:
|
|
"""Teacher dashboard top-level ended_sessions must exclude zero-turn ended sessions."""
|
|
from app.routes import teacher
|
|
|
|
principal = Principal(
|
|
user_id="teacher-1",
|
|
role=Role.TEACHER,
|
|
cohort_ids=["cohort-1"],
|
|
)
|
|
learner_id = "learner-1"
|
|
sess_normal = _make_session("sess-1", 1, learner_id, ended=True)
|
|
sess_zero = _make_session("sess-2", 2, learner_id, ended=True, turns=[])
|
|
|
|
with (
|
|
patch.object(
|
|
teacher.session_persistence,
|
|
"list_all_sessions",
|
|
AsyncMock(return_value=([sess_normal, sess_zero], True)),
|
|
),
|
|
patch.object(
|
|
teacher.session_persistence,
|
|
"list_safety_alerts",
|
|
AsyncMock(return_value=([], True)),
|
|
),
|
|
patch.object(
|
|
teacher.session_persistence,
|
|
"list_session_review_statuses",
|
|
AsyncMock(return_value=({}, True)),
|
|
),
|
|
patch.object(
|
|
teacher.session_evaluation_repository,
|
|
"list_session_evaluations",
|
|
AsyncMock(return_value=({}, True)),
|
|
),
|
|
):
|
|
response = await teacher.teacher_dashboard(principal)
|
|
|
|
self.assertEqual(
|
|
response.ended_sessions,
|
|
1,
|
|
"Teacher dashboard ended_sessions must exclude 0-turn ended sessions",
|
|
)
|
|
self.assertEqual(
|
|
response.learner_growth[0].ended_sessions,
|
|
1,
|
|
"Learner growth in teacher dashboard must exclude 0-turn ended sessions",
|
|
)
|
|
|
|
async def test_teacher_learner_analysis_excludes_zero_turn_from_ended_sessions(self) -> None:
|
|
"""Teacher learner analysis ended_sessions must exclude zero-turn ended sessions."""
|
|
from app.routes import teacher
|
|
|
|
principal = Principal(
|
|
user_id="teacher-1",
|
|
role=Role.TEACHER,
|
|
cohort_ids=["cohort-1"],
|
|
)
|
|
learner_id = "learner-1"
|
|
sess_normal = _make_session("sess-1", 1, learner_id, ended=True)
|
|
sess_zero = _make_session("sess-2", 2, learner_id, ended=True, turns=[])
|
|
|
|
with (
|
|
patch.object(
|
|
teacher.session_persistence,
|
|
"list_all_sessions",
|
|
AsyncMock(return_value=([sess_normal, sess_zero], True)),
|
|
),
|
|
patch.object(
|
|
teacher.session_persistence,
|
|
"list_session_review_statuses",
|
|
AsyncMock(return_value=({}, True)),
|
|
),
|
|
patch.object(
|
|
teacher.session_evaluation_repository,
|
|
"list_session_evaluations",
|
|
AsyncMock(return_value=({}, True)),
|
|
),
|
|
):
|
|
response = await teacher.learner_analysis(learner_id, principal)
|
|
|
|
self.assertEqual(
|
|
response.ended_sessions,
|
|
1,
|
|
"Teacher learner analysis ended_sessions must exclude 0-turn ended sessions",
|
|
)
|
|
self.assertEqual(
|
|
response.summary.ended_sessions,
|
|
1,
|
|
"Teacher learner analysis summary.ended_sessions must exclude 0-turn ended sessions",
|
|
)
|