644 lines
29 KiB
Python
644 lines
29 KiB
Python
"""Разбор по отметкам (lct-35): преподаватель подтверждает, снимает и добавляет отметку.
|
||
|
||
Балл пересчитывается теми же метриками и весами: снятая отметка не штрафует
|
||
свою метрику, ручная — штрафует. Автоматическая оценка остаётся рядом.
|
||
"""
|
||
|
||
import asyncio
|
||
from datetime import UTC, datetime
|
||
from uuid import uuid4
|
||
|
||
import pytest
|
||
from fastapi import HTTPException
|
||
from fastapi.testclient import TestClient
|
||
|
||
from app.api.auth import Principal
|
||
from app.api.http import sessions
|
||
from app.domain.events import Metric
|
||
from app.domain.roles import Role
|
||
from app.domain.taxonomy import (
|
||
ErrorCode,
|
||
Finding,
|
||
FindingDecision,
|
||
FindingReview,
|
||
FindingSource,
|
||
)
|
||
from app.main import app
|
||
from app.scoring.export import to_csv
|
||
from app.scoring.review import INSTRUCTOR_METRIC, add_finding, review_finding
|
||
from app.session import finish as finish_module
|
||
from app.session.hub import hub
|
||
from app.session.store import FindingAdded, FindingReviewed, MemorySessionStore
|
||
|
||
from tests.test_dds_desk_scores import dds_exercise_early_finish
|
||
|
||
AT = datetime(2026, 9, 27, 12, 0, tzinfo=UTC)
|
||
|
||
|
||
def review(decision: FindingDecision) -> FindingReview:
|
||
return FindingReview(decision=decision, reason="доклад пришёл по рации", author="teacher", at=AT)
|
||
|
||
|
||
def report_with(metrics: list[Metric], findings: list[Finding]) -> dict:
|
||
return {
|
||
"score_auto": 50.0,
|
||
"metrics": [metric.model_dump(mode="json") for metric in metrics],
|
||
"findings": [finding.model_dump(mode="json") for finding in findings],
|
||
"full_report": {"criteria": {"allowed_errors": 0}, "score_auto": 50.0,
|
||
"score_final": 50.0, "failed_metrics": 1, "passed": False},
|
||
}
|
||
|
||
|
||
def dds_metric(key: str, passed: bool, card: int = 1) -> Metric:
|
||
return Metric(key=key, title=key, fact="факт", norm="норма", passed=passed,
|
||
weight=1.0, card=card, service="01")
|
||
|
||
|
||
def dds_finding(code: ErrorCode, card: int = 1) -> Finding:
|
||
return Finding(code=code, source=FindingSource.DISPATCHER, summary=code.value,
|
||
fact="факт", norm="норма", card=card, service="01")
|
||
|
||
|
||
def test_dismissed_finding_stops_penalizing_its_metric_but_stays_in_report():
|
||
report = report_with(
|
||
[dds_metric("dds_primary", True), dds_metric("dds_progress", False)],
|
||
[dds_finding(ErrorCode.D6)],
|
||
)
|
||
|
||
updated = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||
|
||
assert updated["score_reviewed"] == 100.0
|
||
assert updated["score_final"] == 100.0
|
||
assert updated["score_auto"] == 50.0, "автооценка остаётся рядом"
|
||
progress = updated["metrics"][1]
|
||
assert (progress["passed"], progress["passed_auto"]) == (True, False)
|
||
finding = updated["findings"][0]
|
||
assert finding["reviews"][-1]["decision"] == "dismissed"
|
||
assert finding["reviews"][-1]["reason"] == "доклад пришёл по рации"
|
||
archived = updated["full_report"]
|
||
assert (archived["score_final"], archived["failed_metrics"], archived["passed"]) == (100.0, 0, True)
|
||
|
||
|
||
def test_confirmed_finding_and_other_card_keep_the_metric_failed():
|
||
report = report_with(
|
||
[dds_metric("dds_progress", False, card=1), dds_metric("dds_progress", False, card=2)],
|
||
[dds_finding(ErrorCode.D6, card=1), dds_finding(ErrorCode.D6, card=2)],
|
||
)
|
||
|
||
confirmed = review_finding(report, 0, review(FindingDecision.CONFIRMED))
|
||
assert confirmed["score_reviewed"] == 0.0
|
||
|
||
dismissed = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||
assert [metric["passed"] for metric in dismissed["metrics"]] == [True, False], (
|
||
"снятие отметки первой карточки не трогает вторую"
|
||
)
|
||
|
||
|
||
def test_metric_stays_failed_while_one_of_its_findings_is_active():
|
||
report = report_with(
|
||
[dds_metric("dds_reply", False)],
|
||
[dds_finding(ErrorCode.D5), dds_finding(ErrorCode.D5)],
|
||
)
|
||
|
||
updated = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||
|
||
assert updated["metrics"][0]["passed"] is False
|
||
again = review_finding(updated, 1, review(FindingDecision.DISMISSED))
|
||
assert again["metrics"][0]["passed"] is True
|
||
|
||
|
||
def test_instructor_finding_penalizes_linked_metric_and_unlinked_code_adds_one():
|
||
report = report_with([dds_metric("dds_progress", True), dds_metric("dds_primary", True)], [])
|
||
manual = Finding(code=ErrorCode.D6, source=FindingSource.INSTRUCTOR, summary="Карточка 1: D6",
|
||
fact="«Прибыла» отмечено до доклада", norm="по факту доклада",
|
||
card=1, service="01", author="teacher", at=AT)
|
||
|
||
updated = add_finding(report, manual)
|
||
|
||
assert updated["score_reviewed"] == 50.0
|
||
assert updated["metrics"][0]["passed"] is False
|
||
assert updated["metrics"][0]["passed_auto"] is True
|
||
assert updated["findings"][0]["source"] == "instructor"
|
||
|
||
# У D4 в методике нет метрики — ручная отметка всё равно должна штрафовать.
|
||
no_metric = manual.model_copy(update={"code": ErrorCode.D4})
|
||
extra = add_finding(report, no_metric)
|
||
assert [metric["key"] for metric in extra["metrics"]][-1] == INSTRUCTOR_METRIC
|
||
assert extra["score_reviewed"] == pytest.approx(66.7)
|
||
|
||
# Снятая ручная отметка не штрафует, и её метрика исчезает при пересчёте.
|
||
lifted = review_finding(extra, 0, review(FindingDecision.DISMISSED))
|
||
assert lifted["score_reviewed"] == 100.0
|
||
assert INSTRUCTOR_METRIC not in {metric["key"] for metric in lifted["metrics"]}
|
||
|
||
|
||
def test_score_override_stays_final_after_finding_review():
|
||
report = {**report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)]),
|
||
"score_final": 70.0, "overridden_by": "teacher"}
|
||
|
||
updated = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||
|
||
assert updated["score_reviewed"] == 100.0
|
||
assert updated["score_final"] == 70.0
|
||
|
||
|
||
def test_unknown_finding_index_is_refused():
|
||
with pytest.raises(LookupError):
|
||
review_finding(report_with([], []), 0, review(FindingDecision.DISMISSED))
|
||
|
||
|
||
# ── HTTP: живое занятие ДДС ──
|
||
|
||
@pytest.fixture
|
||
def lesson(monkeypatch):
|
||
"""Завершённое занятие ДДС преподавателя `dev` в памяти узла."""
|
||
|
||
class NoCoaching:
|
||
def model_dump(self, **_kwargs):
|
||
return {}
|
||
|
||
async def no_coach(_metrics):
|
||
return NoCoaching()
|
||
|
||
async def audit_in_memory(*_args, **_kwargs):
|
||
return None
|
||
|
||
async def no_database():
|
||
yield None
|
||
|
||
# Живое занятие в памяти: чтение отчёта не должно ходить в PostgreSQL.
|
||
monkeypatch.setattr(finish_module, "coach", no_coach)
|
||
monkeypatch.setattr(sessions, "audit_required", audit_in_memory)
|
||
monkeypatch.setitem(app.dependency_overrides, sessions.optional_session, no_database)
|
||
store = MemorySessionStore()
|
||
monkeypatch.setattr(hub, "store", store)
|
||
state = dds_exercise_early_finish()
|
||
state.owner_login = "dev"
|
||
with TestClient(app) as browser:
|
||
browser.post("/api/auth/dev-token")
|
||
hub.store = store
|
||
hub.register(state)
|
||
yield browser, state, store
|
||
|
||
|
||
def as_role(monkeypatch, role: Role, login: str = "dev") -> None:
|
||
def require(_request, *roles):
|
||
if roles and role not in roles:
|
||
raise HTTPException(status_code=403, detail="forbidden")
|
||
return Principal(login=login, full_name="Проверка", role=role,
|
||
trainee_id=uuid4() if role is Role.TRAINEE else None)
|
||
|
||
monkeypatch.setattr(sessions, "require", require)
|
||
|
||
|
||
def test_owner_dismisses_and_adds_finding_through_http(lesson):
|
||
browser, state, store = lesson
|
||
session_id = state.session_id
|
||
before = browser.get(f"/api/sessions/{session_id}/report").json()
|
||
target = next(index for index, finding in enumerate(before["findings"])
|
||
if finding["code"] == "D1")
|
||
|
||
dismissed = browser.post(
|
||
f"/api/sessions/{session_id}/findings/{target}/review",
|
||
json={"decision": "dismissed", "reason": "карточку выдали с опозданием"},
|
||
)
|
||
assert dismissed.status_code == 200, dismissed.text
|
||
body = dismissed.json()
|
||
assert body["findings"][target]["reviews"][-1]["decision"] == "dismissed"
|
||
assert body["findings"][target]["reviews"][-1]["author"] == "dev"
|
||
assert body["score_auto"] == before["score_auto"]
|
||
assert body["score_reviewed"] >= before["score_auto"]
|
||
|
||
added = browser.post(
|
||
f"/api/sessions/{session_id}/findings",
|
||
json={"code": "D5", "fact": "в комментарии нет адресата", "norm": "назвать адресата",
|
||
"card": 1},
|
||
)
|
||
assert added.status_code == 200, added.text
|
||
manual = added.json()["findings"][-1]
|
||
assert (manual["source"], manual["card"], manual["author"]) == ("instructor", 1, "dev")
|
||
assert manual["summary"].startswith("Карточка 1: ")
|
||
|
||
records = [record for _, batch in store.commits for record in batch]
|
||
assert [type(record) for record in records[-2:]] == [FindingReviewed, FindingAdded]
|
||
assert store.scores[session_id]["findings"][target]["reviews"][-1]["decision"] == "dismissed"
|
||
|
||
rows = to_csv(sessions.SessionReport.model_validate(added.json())).decode("utf-8-sig")
|
||
assert "карточку выдали с опозданием" in rows
|
||
assert "в комментарии нет адресата" in rows
|
||
|
||
|
||
def test_review_requires_reason_and_existing_card(lesson):
|
||
browser, state, _store = lesson
|
||
session_id = state.session_id
|
||
|
||
blank = browser.post(f"/api/sessions/{session_id}/findings/0/review",
|
||
json={"decision": "dismissed", "reason": " "})
|
||
assert blank.status_code == 422
|
||
missing = browser.post(f"/api/sessions/{session_id}/findings/999/review",
|
||
json={"decision": "confirmed", "reason": "проверено"})
|
||
assert missing.status_code == 404
|
||
card = browser.post(f"/api/sessions/{session_id}/findings",
|
||
json={"code": "D1", "fact": "факт", "norm": "норма", "card": 99})
|
||
assert card.status_code == 422
|
||
|
||
|
||
@pytest.mark.parametrize("role, login, status", [
|
||
(Role.TRAINEE, "trainee", 403),
|
||
(Role.INSTRUCTOR, "someone-else", 404),
|
||
])
|
||
def test_trainee_and_foreign_instructor_cannot_review(lesson, monkeypatch, role, login, status):
|
||
browser, state, store = lesson
|
||
commits = len(store.commits)
|
||
as_role(monkeypatch, role, login)
|
||
|
||
reviewed = browser.post(f"/api/sessions/{state.session_id}/findings/0/review",
|
||
json={"decision": "dismissed", "reason": "не согласен"})
|
||
added = browser.post(f"/api/sessions/{state.session_id}/findings",
|
||
json={"code": "D1", "fact": "факт", "norm": "норма"})
|
||
|
||
assert (reviewed.status_code, added.status_code) == (status, status)
|
||
assert len(store.commits) == commits, "отказ ничего не пишет"
|
||
|
||
|
||
def test_finding_review_is_audited_in_postgres(postgres_access):
|
||
"""Решение и аудит — одна транзакция: строка Score и AuditLog вместе."""
|
||
from sqlalchemy import select
|
||
|
||
from app.db.base import get_sessionmaker
|
||
from app.db.models import AuditLog, Score
|
||
from app.session.pg_store import PostgresSessionStore
|
||
from app.session.store import LessonRequest
|
||
|
||
store = PostgresSessionStore(get_sessionmaker())
|
||
session_id = uuid4()
|
||
report = report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)])
|
||
|
||
async def scenario():
|
||
from app.session.state import SessionState
|
||
from app.domain.events import Exercise, SessionMode
|
||
|
||
def build(_identity):
|
||
return SessionState(session_id=session_id, scenario_id="fire-apartment-l2",
|
||
scenario_title="Пожар", level="L2", mode=SessionMode.TRAINING,
|
||
exercise=Exercise.DDS)
|
||
|
||
await store.open(LessonRequest(
|
||
session_id=session_id, scenario_id="fire-apartment-l2", mode="training",
|
||
trainee_name=None, trainee_id=None, owner_login="teacher", backend_node_id=None,
|
||
), build)
|
||
from app.session.store import ScoreCalculated
|
||
await store.commit_archived(session_id, [ScoreCalculated(50.0, report)])
|
||
await store.commit_archived(session_id, [FindingReviewed(
|
||
index=0, role="instructor", review=review(FindingDecision.DISMISSED),
|
||
)])
|
||
async with get_sessionmaker()() as db:
|
||
score = await db.scalar(select(Score).where(Score.session_id == session_id))
|
||
audit = await db.scalar(select(AuditLog).where(
|
||
AuditLog.object_id == str(session_id), AuditLog.action == "finding.review",
|
||
))
|
||
return score, audit
|
||
|
||
score, audit = asyncio.run(scenario())
|
||
assert score.score_auto == 50.0
|
||
assert score.score_final == 100.0
|
||
assert score.report["findings"][0]["reviews"][-1]["decision"] == "dismissed"
|
||
assert audit is not None and audit.actor == "teacher"
|
||
assert "dismissed" in audit.detail and "50.0 → 100.0" in audit.detail
|
||
|
||
|
||
# ── История решений, коды, карточки, веса ──
|
||
|
||
def test_repeated_decision_keeps_history_and_last_one_applies():
|
||
report = report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)])
|
||
|
||
dismissed = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||
confirmed = review_finding(dismissed, 0, FindingReview(
|
||
decision=FindingDecision.CONFIRMED, reason="перепроверил запись", author="head", at=AT,
|
||
))
|
||
|
||
reviews = confirmed["findings"][0]["reviews"]
|
||
assert [(item["decision"], item["author"], item["reason"]) for item in reviews] == [
|
||
("dismissed", "teacher", "доклад пришёл по рации"),
|
||
("confirmed", "head", "перепроверил запись"),
|
||
]
|
||
assert confirmed["score_reviewed"] == 0.0, "действует последнее решение"
|
||
|
||
|
||
def test_report_saved_with_single_review_reads_as_history():
|
||
legacy = dds_finding(ErrorCode.D6).model_dump(mode="json")
|
||
legacy["review"] = review(FindingDecision.DISMISSED).model_dump(mode="json")
|
||
|
||
finding = Finding.model_validate(legacy)
|
||
|
||
assert [item.decision for item in finding.reviews] == [FindingDecision.DISMISSED]
|
||
assert finding.review.decision is FindingDecision.DISMISSED
|
||
|
||
|
||
def test_call_code_in_handoff_penalizes_call_metric_not_instructor_metric():
|
||
"""Связка 112 → ДДС: E1 без карточки проваливает метрику 112, а не добавляет свою."""
|
||
call = Metric(key="checklist_completeness", title="Полнота опроса", fact="все", norm="все",
|
||
passed=True, weight=1.0)
|
||
report = report_with([call, dds_metric("dds_progress", True)], [])
|
||
manual = Finding(code=ErrorCode.E1, source=FindingSource.INSTRUCTOR, summary="E1",
|
||
fact="не уточнён подъезд", norm="уточнить подъезд", author="teacher", at=AT)
|
||
|
||
updated = add_finding(report, manual)
|
||
|
||
assert [metric["passed"] for metric in updated["metrics"]] == [False, True]
|
||
assert INSTRUCTOR_METRIC not in {metric["key"] for metric in updated["metrics"]}
|
||
assert updated["score_reviewed"] == 50.0
|
||
|
||
|
||
def test_codes_and_card_scores_follow_the_review():
|
||
card = {"card_id": str(uuid4()), "scenario_id": "s", "score_auto": 50.0, "reply_text": "",
|
||
"metrics": [dds_metric("dds_primary", True).model_dump(mode="json"),
|
||
dds_metric("dds_progress", False).model_dump(mode="json")],
|
||
"findings": [dds_finding(ErrorCode.D6).model_dump(mode="json")]}
|
||
report = {**report_with([dds_metric("dds_primary", True), dds_metric("dds_progress", False)],
|
||
[dds_finding(ErrorCode.D6)]),
|
||
"summary": {"hints": 2, "codes": {"D6": 1}}, "card_results": [card]}
|
||
report["full_report"]["card_results"] = [card]
|
||
|
||
dismissed = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||
|
||
assert dismissed["summary"] == {"hints": 2, "codes": {}}, "снятая отметка не ошибка группы"
|
||
for cards in (dismissed["card_results"], dismissed["full_report"]["card_results"]):
|
||
assert cards[0]["score_auto"] == 50.0
|
||
assert cards[0]["score_reviewed"] == 100.0
|
||
assert cards[0]["metrics"][1]["passed"] is True
|
||
assert cards[0]["findings"][0]["reviews"][-1]["decision"] == "dismissed"
|
||
|
||
manual = Finding(code=ErrorCode.D4, source=FindingSource.INSTRUCTOR, summary="D4",
|
||
fact="отказ без причины", norm="причина обязательна", card=1,
|
||
author="teacher", at=AT)
|
||
added = add_finding(dismissed, manual)
|
||
assert added["summary"]["codes"] == {"D4": 1}
|
||
assert added["card_results"][0]["score_reviewed"] == pytest.approx(66.7)
|
||
|
||
|
||
def test_instructor_metric_weight_comes_from_lesson_weights():
|
||
report = report_with([dds_metric("dds_primary", True)], [])
|
||
report["full_report"]["criteria"]["score_weights"] = {INSTRUCTOR_METRIC: 3.0}
|
||
manual = Finding(code=ErrorCode.D4, source=FindingSource.INSTRUCTOR, summary="D4",
|
||
fact="отказ без причины", norm="причина обязательна", card=1,
|
||
author="teacher", at=AT)
|
||
|
||
updated = add_finding(report, manual)
|
||
|
||
assert updated["metrics"][-1]["weight"] == 3.0
|
||
assert updated["score_reviewed"] == 25.0
|
||
|
||
|
||
def test_lesson_criteria_accept_instructor_metric_weight():
|
||
from app.domain.events import LessonCriteria
|
||
|
||
assert LessonCriteria(score_weights={INSTRUCTOR_METRIC: 2.0}).score_weights == {
|
||
INSTRUCTOR_METRIC: 2.0}
|
||
|
||
|
||
def test_repeated_manual_finding_with_same_key_is_added_once():
|
||
report = report_with([dds_metric("dds_primary", True)], [])
|
||
manual = Finding(code=ErrorCode.D4, source=FindingSource.INSTRUCTOR, summary="D4",
|
||
fact="отказ без причины", norm="причина обязательна", card=1,
|
||
author="teacher", at=AT, client_id=uuid4())
|
||
|
||
once = add_finding(report, manual)
|
||
twice = add_finding(once, manual)
|
||
|
||
assert len(twice["findings"]) == 1
|
||
assert twice["score_reviewed"] == once["score_reviewed"] == 50.0
|
||
|
||
|
||
def test_pdf_shows_score_after_review(monkeypatch):
|
||
from reportlab import platypus
|
||
|
||
from app.scoring.export import to_pdf
|
||
from tests.test_report_export import sample_report
|
||
|
||
texts: list[str] = []
|
||
|
||
class Recorded(platypus.Paragraph):
|
||
def __init__(self, text, *args, **kwargs):
|
||
texts.append(text)
|
||
super().__init__(text, *args, **kwargs)
|
||
|
||
# Абзацы перехватываются до вёрстки: извлечь текст из PDF нечем без poppler.
|
||
monkeypatch.setattr(platypus, "Paragraph", Recorded)
|
||
assert to_pdf(sample_report().model_copy(update={"score_reviewed": 91.5})).startswith(b"%PDF-")
|
||
|
||
assert "<b>После разбора отметок:</b> 91.5" in texts
|
||
|
||
|
||
# ── HTTP: связка 112 → ДДС, идемпотентность, занятие из истории ──
|
||
|
||
def test_call_code_with_queue_card_is_refused_in_handoff(lesson):
|
||
browser, state, store = lesson
|
||
commits = len(store.commits)
|
||
state.score["full_report"]["exercise"] = "call"
|
||
|
||
refused = browser.post(f"/api/sessions/{state.session_id}/findings",
|
||
json={"code": "E1", "fact": "факт", "norm": "норма", "card": 1})
|
||
|
||
assert refused.status_code == 422
|
||
assert refused.json()["detail"] == "call_code_without_card"
|
||
assert len(store.commits) == commits
|
||
|
||
|
||
def test_repeated_add_request_does_not_add_second_finding(lesson):
|
||
browser, state, store = lesson
|
||
body = {"code": "D5", "fact": "нет адресата", "norm": "назвать адресата", "card": 1,
|
||
"client_id": str(uuid4())}
|
||
|
||
first = browser.post(f"/api/sessions/{state.session_id}/findings", json=body)
|
||
commits = len(store.commits)
|
||
second = browser.post(f"/api/sessions/{state.session_id}/findings", json=body)
|
||
|
||
assert first.status_code == second.status_code == 200
|
||
assert len(second.json()["findings"]) == len(first.json()["findings"])
|
||
assert second.json()["score_reviewed"] == first.json()["score_reviewed"]
|
||
assert not [record for _, batch in store.commits[commits:] for record in batch], (
|
||
"повтор ничего не пишет")
|
||
|
||
|
||
def test_archived_lesson_is_reviewed_through_http(monkeypatch):
|
||
"""Занятия нет в памяти узла: решение идёт через commit_archived, ответ — по строке после записи."""
|
||
from types import SimpleNamespace
|
||
|
||
from app.session.pg_store import PostgresSessionStore
|
||
from tests.test_report_export import sample_report
|
||
|
||
archived = sample_report().model_dump(mode="json")
|
||
archived["findings"] = [dds_finding(ErrorCode.D6).model_dump(mode="json")]
|
||
archived["metrics"] = [dds_metric("dds_progress", False).model_dump(mode="json")]
|
||
archived.update(score_final=0.0, overridden_by=None, override_comment=None, score_auto=0.0)
|
||
session_id = archived["session_id"]
|
||
session_row = SimpleNamespace(id=session_id, trainee_id=uuid4(), owner_login="dev")
|
||
score_row = SimpleNamespace(
|
||
session_id=session_id, score_auto=0.0, score_final=0.0,
|
||
report={"score_auto": 0.0, "summary": {"codes": {"D6": 1}},
|
||
"findings": archived["findings"], "metrics": archived["metrics"],
|
||
"full_report": archived},
|
||
)
|
||
|
||
class FakeDb:
|
||
def __init__(self):
|
||
self.added = []
|
||
self.commits = 0
|
||
|
||
async def get(self, _model, _key):
|
||
return session_row
|
||
|
||
async def scalar(self, _statement):
|
||
return score_row
|
||
|
||
def add(self, row):
|
||
self.added.append(row)
|
||
|
||
async def flush(self):
|
||
pass
|
||
|
||
async def rollback(self):
|
||
pass
|
||
|
||
async def commit(self):
|
||
self.commits += 1
|
||
|
||
async def __aenter__(self):
|
||
return self
|
||
|
||
async def __aexit__(self, *_args):
|
||
return None
|
||
|
||
db = FakeDb()
|
||
|
||
async def fake_session():
|
||
yield db
|
||
|
||
monkeypatch.setattr(hub, "store", PostgresSessionStore(lambda: db))
|
||
monkeypatch.setattr(hub, "get", lambda _session_id: None)
|
||
monkeypatch.setitem(app.dependency_overrides, sessions.optional_session, fake_session)
|
||
with TestClient(app) as browser:
|
||
browser.post("/api/auth/dev-token")
|
||
hub.store = PostgresSessionStore(lambda: db)
|
||
response = browser.post(f"/api/sessions/{session_id}/findings/0/review",
|
||
json={"decision": "dismissed", "reason": "доклад по рации"})
|
||
|
||
assert response.status_code == 200, response.text
|
||
body = response.json()
|
||
assert body["score_reviewed"] == 100.0 and body["score_final"] == 100.0
|
||
assert body["findings"][0]["reviews"][-1]["reason"] == "доклад по рации"
|
||
assert db.commits == 1, "решение и аудит — один commit"
|
||
assert score_row.score_final == 100.0
|
||
assert score_row.report["summary"]["codes"] == {}
|
||
audit = db.added[0]
|
||
assert audit.action == "finding.review" and audit.actor == "dev"
|
||
assert "D6 dismissed" in audit.detail and "доклад по рации" in audit.detail
|
||
|
||
|
||
def test_finding_review_is_not_saved_when_audit_fails(postgres_access):
|
||
"""Fail-closed: строка аудита не записалась — решения и нового балла тоже нет."""
|
||
from sqlalchemy import select
|
||
|
||
from app.db.base import get_sessionmaker
|
||
from app.db.models import AuditLog, Score
|
||
from app.domain.events import Exercise, SessionMode
|
||
from app.session.pg_store import PostgresSessionStore
|
||
from app.session.state import SessionState
|
||
from app.session.store import LessonRequest, ScoreCalculated
|
||
|
||
store = PostgresSessionStore(get_sessionmaker())
|
||
session_id = uuid4()
|
||
report = report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)])
|
||
# actor в audit_log — String(80): длинный логин роняет INSERT аудита
|
||
# на стороне PostgreSQL, а Score меняется в той же транзакции.
|
||
broken = FindingReview(decision=FindingDecision.DISMISSED, reason="доклад по рации",
|
||
author="x" * 200, at=AT)
|
||
|
||
async def scenario():
|
||
def build(_identity):
|
||
return SessionState(session_id=session_id, scenario_id="fire-apartment-l2",
|
||
scenario_title="Пожар", level="L2", mode=SessionMode.TRAINING,
|
||
exercise=Exercise.DDS)
|
||
|
||
await store.open(LessonRequest(
|
||
session_id=session_id, scenario_id="fire-apartment-l2", mode="training",
|
||
trainee_name=None, trainee_id=None, owner_login="teacher", backend_node_id=None,
|
||
), build)
|
||
await store.commit_archived(session_id, [ScoreCalculated(50.0, report)])
|
||
with pytest.raises(Exception):
|
||
await store.commit_archived(session_id, [FindingReviewed(
|
||
index=0, role="instructor", review=broken,
|
||
)])
|
||
async with get_sessionmaker()() as db:
|
||
score = await db.scalar(select(Score).where(Score.session_id == session_id))
|
||
audit = await db.scalar(select(AuditLog).where(
|
||
AuditLog.object_id == str(session_id), AuditLog.action == "finding.review",
|
||
))
|
||
return score, audit
|
||
|
||
score, audit = asyncio.run(scenario())
|
||
assert audit is None
|
||
assert score.score_final == 50.0
|
||
assert score.report["findings"][0].get("reviews", []) == []
|
||
assert "score_reviewed" not in score.report
|
||
|
||
|
||
def test_archived_lesson_review_through_http_in_postgres(postgres_access, monkeypatch):
|
||
"""Тот же маршрут на настоящей PostgreSQL: ответ перечитан после commit под блокировкой."""
|
||
from sqlalchemy import select
|
||
|
||
from app.db.base import get_sessionmaker
|
||
from app.db.models import AuditLog
|
||
from app.domain.events import Exercise, SessionMode
|
||
from app.session.pg_store import PostgresSessionStore
|
||
from app.session.state import SessionState
|
||
from app.session.store import LessonRequest, ScoreCalculated
|
||
from tests.test_report_export import sample_report
|
||
|
||
session_id = uuid4()
|
||
archived = sample_report().model_dump(mode="json")
|
||
archived.update(session_id=str(session_id), score_final=0.0, score_auto=0.0,
|
||
overridden_by=None, override_comment=None,
|
||
findings=[dds_finding(ErrorCode.D6).model_dump(mode="json")],
|
||
metrics=[dds_metric("dds_progress", False).model_dump(mode="json")])
|
||
report = {"score_auto": 0.0, "summary": {"codes": {"D6": 1}},
|
||
"findings": archived["findings"], "metrics": archived["metrics"],
|
||
"full_report": archived}
|
||
store = PostgresSessionStore(get_sessionmaker())
|
||
|
||
async def prepare():
|
||
def build(_identity):
|
||
return SessionState(session_id=session_id, scenario_id="fire-apartment-l2",
|
||
scenario_title="Пожар", level="L2", mode=SessionMode.TRAINING,
|
||
exercise=Exercise.DDS)
|
||
|
||
await store.open(LessonRequest(
|
||
session_id=session_id, scenario_id="fire-apartment-l2", mode="training",
|
||
trainee_name=None, trainee_id=None, owner_login="dev", backend_node_id=None,
|
||
), build)
|
||
await store.commit_archived(session_id, [ScoreCalculated(0.0, report)])
|
||
|
||
async def audit():
|
||
async with get_sessionmaker()() as db:
|
||
return await db.scalar(select(AuditLog).where(
|
||
AuditLog.object_id == str(session_id), AuditLog.action == "finding.review"))
|
||
|
||
monkeypatch.setattr(hub, "get", lambda _session_id: None)
|
||
# Пул соединений привязан к циклу событий: подготовка и проверка идут
|
||
# в цикле того же TestClient, что и запрос.
|
||
with TestClient(app) as browser:
|
||
browser.post("/api/auth/dev-token")
|
||
previous, hub.store = hub.store, store
|
||
try:
|
||
browser.portal.call(prepare)
|
||
response = browser.post(f"/api/sessions/{session_id}/findings/0/review",
|
||
json={"decision": "dismissed", "reason": "доклад по рации"})
|
||
row = browser.portal.call(audit)
|
||
finally:
|
||
hub.store = previous
|
||
|
||
assert response.status_code == 200, response.text
|
||
assert response.json()["score_final"] == 100.0
|
||
assert response.json()["findings"][0]["reviews"][-1]["reason"] == "доклад по рации"
|
||
assert row is not None and "доклад по рации" in row.detail
|