729 lines
35 KiB
Python
729 lines
35 KiB
Python
"""Преподавательский цикл: шаблон → черновик → проверка → утверждение."""
|
||
|
||
from pathlib import Path
|
||
|
||
import pytest
|
||
from fastapi.testclient import TestClient
|
||
|
||
from app.api.http import scenarios as scenarios_api
|
||
from app.config import get_settings
|
||
from app.dialog.llm import LlmUnavailable
|
||
from app.db.models import AuditLog
|
||
from app.main import app
|
||
from app.scenarios import generation, store
|
||
from app.scenarios.editor import merge_patch, template_copy, validate
|
||
from app.scenarios.generation import (
|
||
GenerationError,
|
||
correction_target,
|
||
full_proposal_body,
|
||
parse_full_proposal,
|
||
parse_proposal,
|
||
proposal_body,
|
||
style_fallback,
|
||
)
|
||
from app.scenarios.loader import ScenarioError, load_file
|
||
|
||
LIBRARY = Path(__file__).resolve().parents[2] / "scenarios"
|
||
|
||
|
||
class FakeSession:
|
||
"""Минимальная транзакционная замена БД для проверки HTTP без Postgres."""
|
||
|
||
def __init__(self):
|
||
self.rows = {}
|
||
self.audit_rows = []
|
||
self.commit_audit_counts = []
|
||
|
||
def add(self, row):
|
||
if isinstance(row, AuditLog):
|
||
self.audit_rows.append(row)
|
||
else:
|
||
self.rows[row.id] = row
|
||
|
||
async def get(self, model, key):
|
||
return self.rows.get(key)
|
||
|
||
async def commit(self):
|
||
self.commit_audit_counts.append(len(self.audit_rows))
|
||
|
||
async def scalars(self, query):
|
||
expression = query.column_descriptions[0]["expr"]
|
||
if getattr(expression, "key", None) == "id":
|
||
owner_filter = next(
|
||
clause for clause in query.whereclause.clauses
|
||
if getattr(getattr(clause, "left", None), "key", None) == "owner_login"
|
||
and getattr(getattr(clause, "right", None), "value", None) is not None
|
||
)
|
||
owner_login = owner_filter.right.value
|
||
owner_operator = owner_filter.operator.__name__
|
||
return [
|
||
row.id for row in self.rows.values()
|
||
if row.status == "published"
|
||
and (
|
||
row.owner_login == owner_login
|
||
if owner_operator == "eq"
|
||
else row.owner_login is not None and row.owner_login != owner_login
|
||
)
|
||
]
|
||
return [row for row in self.rows.values() if row.status == "published"]
|
||
|
||
|
||
@pytest.fixture
|
||
def client(monkeypatch):
|
||
db = FakeSession()
|
||
|
||
async def no_audit(*args, **kwargs):
|
||
pass
|
||
|
||
async def no_restore(*args, **kwargs):
|
||
return 0
|
||
|
||
app.dependency_overrides[scenarios_api.scenario_session] = lambda: db
|
||
monkeypatch.setattr(scenarios_api, "audit", no_audit)
|
||
monkeypatch.setattr(store, "restore_published", no_restore)
|
||
with TestClient(app) as test_client:
|
||
test_client.fake_db = db
|
||
yield test_client
|
||
app.dependency_overrides.clear()
|
||
|
||
|
||
def assert_atomic_audit(client, action: str, object_id: str) -> None:
|
||
row = client.fake_db.audit_rows[-1]
|
||
assert row.action == action
|
||
assert row.object_id == object_id
|
||
assert client.fake_db.commit_audit_counts[-1] == len(client.fake_db.audit_rows)
|
||
|
||
|
||
def test_template_copy_is_local_independent_and_valid():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
body = template_copy(source, "draft-example")
|
||
assert body["id"] == "draft-example"
|
||
assert body["extends"] is None
|
||
assert body["ticket"] is None
|
||
assert body["ground_truth"].keys() == {"address", "victims"}
|
||
assert validate(body).ground_truth.dds == source.ground_truth.dds
|
||
assert source.id != body["id"] # оригинал не меняется
|
||
|
||
|
||
def test_editor_rejects_derived_truth_and_missing_fact():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
body = template_copy(source, "draft-example")
|
||
with pytest.raises(ScenarioError, match="ground_truth"):
|
||
merge_patch(body, {"ground_truth": {"dds": "02"}})
|
||
with pytest.raises(ScenarioError, match="id сценария"):
|
||
merge_patch(body, {"id": "other"})
|
||
broken = merge_patch(body, {"facts": []})
|
||
with pytest.raises(ScenarioError, match="нужны факты"):
|
||
validate(broken)
|
||
|
||
|
||
def test_editor_can_save_explicit_scenario_decline_with_required_reason():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
body = template_copy(source, "draft-decline")
|
||
declined = merge_patch(body, {
|
||
"dds_decision": {
|
||
"expected": "decline",
|
||
"reason": "Повторный вызов уже отрабатывается по первой карточке.",
|
||
},
|
||
})
|
||
assert validate(declined).dds_decision.expected == "decline"
|
||
with pytest.raises(ScenarioError, match="reason обязателен"):
|
||
validate(merge_patch(body, {"dds_decision": {"expected": "decline"}}))
|
||
|
||
|
||
def test_ai_proposal_changes_only_story_and_keeps_reference():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
proposal = parse_proposal('''```json
|
||
{"title":"Ночной пожар на балконе","first_line":"Алло, помогите, балкон горит и всё в дыму!",
|
||
"facts":{"f_what_burns":"на балконе открытое пламя","f_smoke":"дым заполнил подъезд"}}
|
||
```''', source)
|
||
body = proposal_body(source, "ai-example", proposal)
|
||
generated = validate(body)
|
||
assert generated.facts[0].value == source.facts[0].value
|
||
assert generated.ground_truth.address == source.ground_truth.address
|
||
assert generated.ground_truth.victims == source.ground_truth.victims
|
||
assert generated.ground_truth.incident_code == source.ground_truth.incident_code
|
||
assert generated.facts[1].value == "на балконе открытое пламя"
|
||
|
||
|
||
def test_ai_proposal_rejects_address_change_and_premature_number():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
with pytest.raises(GenerationError, match="защищённые"):
|
||
parse_proposal('{"title":"Другой пожар","first_line":"Алло, помогите, у нас горит балкон!",'
|
||
'"facts":{"f_address":"другой адрес"}}', source)
|
||
with pytest.raises(GenerationError, match="числовые"):
|
||
parse_proposal('{"title":"Другой пожар","first_line":"Горит дом 99, срочно приезжайте!",'
|
||
'"facts":{}}', source)
|
||
with pytest.raises(GenerationError, match="числовые"):
|
||
parse_proposal('{"title":"Другой пожар","first_line":"Один человек пострадал, помогите!",'
|
||
'"facts":{}}', source)
|
||
with pytest.raises(GenerationError, match="вопрос вместо ответа"):
|
||
parse_proposal('{"title":"Другой пожар","first_line":"Помогите, на балконе пожар!",'
|
||
'"facts":{"f_smoke":"Куда идёт дым?"}}', source)
|
||
with pytest.raises(GenerationError, match="плейсхолдер"):
|
||
parse_proposal('{"title":"Другой пожар","first_line":"Помогите, на балконе пожар!",'
|
||
'"facts":{"f_smoke":"{f_smoke}"}}', source)
|
||
with pytest.raises(GenerationError, match="новых обстоятельств"):
|
||
parse_proposal('{"title":"Другой пожар","first_line":"Помогите, на балконе пожар!",'
|
||
'"facts":{}}', source)
|
||
revised = parse_proposal(
|
||
'{"title":"Пожар — короткая реплика","first_line":"Пожар! Помогите!","facts":{}}',
|
||
source, require_fact_change=False, instruction="Сделай реплику короче",
|
||
restrict_first_line_facts=True,
|
||
)
|
||
assert revised["first_line"] == "Пожар! Помогите!"
|
||
with pytest.raises(GenerationError, match="не запрошенные"):
|
||
parse_proposal(
|
||
'{"title":"Пожар — короткая реплика",'
|
||
'"first_line":"Горим! Не успел перекрыть газ!","facts":{}}',
|
||
source, require_fact_change=False, instruction="Сделай реплику короче",
|
||
restrict_first_line_facts=True,
|
||
)
|
||
|
||
|
||
def test_revision_target_is_selected_only_when_comment_names_a_fact():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
assert correction_target(source, "Сделай дым чёрным и плотным") == "f_smoke"
|
||
assert correction_target(source, "Сделай первую реплику короче и тревожнее") is None
|
||
shortened = style_fallback(source, "Сделай первую реплику короче")
|
||
assert shortened["first_line"] == "Помогите! Горим!"
|
||
assert style_fallback(source, "Сделай тон спокойнее") is None
|
||
|
||
|
||
def test_full_ai_proposal_replaces_all_facts_and_derives_soft_truth():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
raw = '''{
|
||
"title":"Пожар на балконе жилого дома",
|
||
"first_line":"Помогите, с балкона валит чёрный дым!",
|
||
"facts":{
|
||
"f_address":"улица Новая, 8, корпус 2, первый этаж",
|
||
"f_what_burns":"на балконе жилого дома видно открытое пламя",
|
||
"f_people":"все вышли; Пострадавших: 0",
|
||
"f_smoke":"густой чёрный дым идёт в лестничный холл",
|
||
"f_gas":"газового оборудования в квартире нет"
|
||
},
|
||
"ground_truth":{"address":"улица Новая, 8","victims":0}
|
||
}'''
|
||
proposal = parse_full_proposal(raw, source)
|
||
body = full_proposal_body(source, "ai-full-example", proposal)
|
||
generated = validate(body)
|
||
assert generated.ground_truth.address == "улица Новая, 8"
|
||
assert generated.ground_truth.victims == 0
|
||
assert generated.ground_truth.incident_code == source.ground_truth.incident_code
|
||
assert generated.facts[0].value.startswith("улица Новая")
|
||
assert all(fact.refined is None and fact.refine_on is None for fact in generated.facts)
|
||
assert parse_full_proposal(raw.replace("Пострадавших: 0", "пострадавших нет"), source)
|
||
|
||
inconsistent = raw.replace("Пожар на балконе жилого дома", "Пожар в мастерской") \
|
||
.replace("с балкона", "из мастерской") \
|
||
.replace("на балконе жилого дома видно открытое пламя", "горит оборудование мастерской")
|
||
with pytest.raises(ScenarioError, match="сюжет не подтверждает путь ЕКП"):
|
||
full_proposal_body(source, "ai-full-inconsistent", parse_full_proposal(inconsistent, source))
|
||
|
||
with pytest.raises(GenerationError, match="числа пострадавших"):
|
||
parse_full_proposal(raw.replace("Пострадавших: 0", "Пострадавших не видно"), source)
|
||
with pytest.raises(GenerationError, match="адрес не совпадает"):
|
||
parse_full_proposal(raw.replace('"address":"улица Новая, 8"',
|
||
'"address":"улица Другая, 9"'), source)
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_ai_generation_retries_copied_facts_with_strict_schema(monkeypatch):
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
requests = []
|
||
|
||
class FakeClient:
|
||
def __init__(self, **kwargs):
|
||
self.answers = iter([
|
||
('{"title":"Ночной пожар","first_line":"Алло, на балконе горит!",'
|
||
'"facts":{"f_smoke":"дым идёт в подъезд, на площадке ничего не видно"}}'),
|
||
('{"title":"Ночной пожар","first_line":"Алло, на балконе горит!",'
|
||
'"facts":{"f_smoke":"лестница уже заполнена густым дымом"}}'),
|
||
])
|
||
|
||
async def complete(self, request, **kwargs):
|
||
requests.append(request)
|
||
return next(self.answers)
|
||
|
||
async def aclose(self):
|
||
pass
|
||
|
||
monkeypatch.setattr(generation, "LlmClient", FakeClient)
|
||
proposal = await generation.generate(
|
||
source, "Ночной пожар на балконе, густой дым в подъезде, заявитель паникует"
|
||
)
|
||
assert proposal["facts"]["f_smoke"] == "лестница уже заполнена густым дымом"
|
||
assert len(requests) == 2
|
||
assert requests[0].response_format["type"] == "json_object"
|
||
assert set(requests[0].response_format["schema"]["properties"]["facts"]["properties"]) == {"f_smoke"}
|
||
assert "f_smoke" in requests[1].messages[-1]["content"]
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_ai_generation_retries_one_qwen_control_token_failure(monkeypatch):
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
|
||
class FakeClient:
|
||
calls = 0
|
||
|
||
def __init__(self, **kwargs):
|
||
pass
|
||
|
||
async def complete(self, request, **kwargs):
|
||
self.calls += 1
|
||
if self.calls == 1:
|
||
raise LlmUnavailable("ответ содержит служебные токены модели")
|
||
return ('{"title":"Ночной дым","first_line":"Алло, всё в дыму, помогите!",'
|
||
'"facts":{"f_smoke":"лестница заполнена густым дымом"}}')
|
||
|
||
async def aclose(self):
|
||
pass
|
||
|
||
monkeypatch.setattr(generation, "LlmClient", FakeClient)
|
||
proposal = await generation.generate(source, "Сделай дым густым и чёрным")
|
||
assert proposal["facts"]["f_smoke"].startswith("лестница")
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_description_generation_asks_small_model_one_fact_at_a_time(monkeypatch):
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
answers = iter([
|
||
'{"title":"Пожар на балконе жилого дома","first_line":"С балкона идёт дым"}',
|
||
'{"value":"ул. Маршака, д. 12, этаж 1","address":"ул. Маршака, д. 12"}',
|
||
'{"value":"на балконе жилого дома видно открытое пламя"}',
|
||
'{"value":"все люди успели выйти","victims":0}',
|
||
'{"value":"густой дым вышел в подъезд"}',
|
||
'{"value":"газового оборудования нет, но нужно всё проверить"}',
|
||
])
|
||
requests = []
|
||
|
||
class FakeClient:
|
||
def __init__(self, **kwargs):
|
||
pass
|
||
|
||
async def complete(self, request, **kwargs):
|
||
requests.append(request)
|
||
return next(answers)
|
||
|
||
async def aclose(self):
|
||
pass
|
||
|
||
monkeypatch.setattr(generation, "LlmClient", FakeClient)
|
||
proposal = await generation.generate_from_description(
|
||
source, "Пожар в мастерской, все вышли, густой дым в подъезде"
|
||
)
|
||
assert len(requests) == 6
|
||
assert requests[0].messages[-1]["content"].find("classifier_signs") >= 0
|
||
assert all(
|
||
"classifier_signs" in request.messages[1]["content"]
|
||
for request in requests[1:]
|
||
)
|
||
assert proposal["first_line"].endswith("!")
|
||
assert proposal["ground_truth"] == {
|
||
"address": "ул. Маршака, д. 12, этаж 1", "victims": 0,
|
||
}
|
||
assert proposal["facts"]["f_people"].endswith("Пострадавших: 0")
|
||
assert proposal["facts"]["f_gas"] == "газового оборудования нет"
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_description_generation_retries_fact_that_is_a_question(monkeypatch):
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
answers = iter([
|
||
'{"title":"Пожар на балконе жилого дома","first_line":"С балкона идёт дым"}',
|
||
'{"value":"ул. Маршака, д. 12, этаж 1","address":"ул. Маршака, д. 12"}',
|
||
'{"value":"на балконе жилого дома видно открытое пламя"}',
|
||
'{"value":"Есть ли пострадавшие?","victims":1}',
|
||
'{"value":"один человек получил ожог; Пострадавших: 1","victims":1}',
|
||
'{"value":"густой дым вышел в подъезд"}',
|
||
'{"value":"газового оборудования нет"}',
|
||
])
|
||
requests = []
|
||
|
||
class FakeClient:
|
||
def __init__(self, **kwargs):
|
||
pass
|
||
|
||
async def complete(self, request, **kwargs):
|
||
requests.append(request)
|
||
return next(answers)
|
||
|
||
async def aclose(self):
|
||
pass
|
||
|
||
monkeypatch.setattr(generation, "LlmClient", FakeClient)
|
||
proposal = await generation.generate_from_description(
|
||
source, "Пожар в мастерской, один человек получил ожог, густой дым в подъезде"
|
||
)
|
||
assert len(requests) == 7
|
||
assert "Ответ отклонён" in requests[4].messages[-1]["content"]
|
||
assert proposal["ground_truth"]["victims"] == 1
|
||
assert proposal["facts"]["f_people"].endswith("Пострадавших: 1")
|
||
|
||
|
||
def test_draft_is_hidden_until_approval_and_then_available_to_lesson(client, monkeypatch):
|
||
from app.scoring.grammar import GrammarAssessment
|
||
|
||
async def fake_assess(_text):
|
||
return GrammarAssessment(True, (), "rules")
|
||
|
||
monkeypatch.setattr(scenarios_api, "assess", fake_assess)
|
||
source = next(s for s in store.all_scenarios() if s.id == "fire-apartment-l2")
|
||
assert client.post("/api/auth/dev-token").status_code == 200
|
||
response = client.post(
|
||
"/api/scenarios/drafts/from-template",
|
||
json={"source_id": source.id, "title": "Учебная копия"},
|
||
)
|
||
assert response.status_code == 201, response.text
|
||
draft = response.json()
|
||
draft_id = draft["id"]
|
||
assert draft["generation"] == "template_copy"
|
||
assert draft["status"] == "draft"
|
||
assert_atomic_audit(client, "scenario.draft.create", draft_id)
|
||
assert store.get(draft_id) is None
|
||
assert client.get(f"/api/scenarios/{draft_id}").status_code == 404
|
||
|
||
changed = client.patch(
|
||
f"/api/scenarios/drafts/{draft_id}",
|
||
json={"first_line": "Соседи! В доме дым!"},
|
||
)
|
||
assert changed.status_code == 200, changed.text
|
||
assert changed.json()["body"]["first_line"] == "Соседи! В доме дым!"
|
||
assert_atomic_audit(client, "scenario.draft.update", draft_id)
|
||
check = client.post(f"/api/scenarios/drafts/{draft_id}/validate")
|
||
assert check.status_code == 200 and check.json()["valid"]
|
||
grammar = client.post(f"/api/scenarios/drafts/{draft_id}/grammar-check")
|
||
assert grammar.status_code == 200 and grammar.json()["valid"]
|
||
approved = client.post(f"/api/scenarios/drafts/{draft_id}/approve")
|
||
assert approved.status_code == 200, approved.text
|
||
assert_atomic_audit(client, "scenario.approve", draft_id)
|
||
assert approved.json()["status"] == "published"
|
||
assert store.get(draft_id).first_line == "Соседи! В доме дым!"
|
||
assert client.get(f"/api/scenarios/{draft_id}").status_code == 200
|
||
assert client.patch(f"/api/scenarios/drafts/{draft_id}", json={"title": "нет"}).status_code == 404
|
||
|
||
|
||
def test_ai_draft_requires_instructor_review_before_publication(client, monkeypatch):
|
||
async def fake_generate(source, instruction, **kwargs):
|
||
assert source.id == "fire-apartment-l2"
|
||
assert "ночью" in instruction
|
||
return {"title": "Ночной пожар на балконе",
|
||
"first_line": "Помогите, у нас горит балкон!",
|
||
"facts": {"f_smoke": "густой дым уже в подъезде"}}
|
||
|
||
monkeypatch.setattr(scenarios_api, "generate", fake_generate)
|
||
client.post("/api/auth/dev-token")
|
||
response = client.post("/api/scenarios/drafts/generate", json={
|
||
"source_id": "fire-apartment-l2", "instruction": "Пожар начался ночью",
|
||
})
|
||
assert response.status_code == 201, response.text
|
||
draft = response.json()
|
||
assert draft["generation"] == "ai_variant"
|
||
assert draft["id"].startswith("ai-")
|
||
assert_atomic_audit(client, "scenario.draft.ai_generate", draft["id"])
|
||
assert draft["body"]["first_line"] == "Помогите, у нас горит балкон!"
|
||
assert store.get(draft["id"]) is None
|
||
assert client.get(f"/api/scenarios/{draft['id']}").status_code == 404
|
||
assert client.post(f"/api/scenarios/drafts/{draft['id']}/validate").json()["valid"]
|
||
assert client.post(f"/api/scenarios/drafts/{draft['id']}/approve").status_code == 200
|
||
assert store.get(draft["id"]).first_line == "Помогите, у нас горит балкон!"
|
||
|
||
|
||
def test_description_generates_new_story_and_reference_answers(client, monkeypatch):
|
||
async def fake_generate(source, description):
|
||
assert source.id == "fire-apartment-l2"
|
||
assert "мастерской" in description
|
||
return {
|
||
"title": "Пожар на балконе жилого дома",
|
||
"first_line": "Помогите, с балкона валит чёрный дым!",
|
||
"facts": {
|
||
"f_address": "улица Новая, 8, корпус 2, первый этаж",
|
||
"f_what_burns": "на балконе жилого дома видно открытое пламя",
|
||
"f_people": "все вышли; Пострадавших: 0",
|
||
"f_smoke": "густой чёрный дым идёт в лестничный холл",
|
||
"f_gas": "газового оборудования в квартире нет",
|
||
},
|
||
"ground_truth": {"address": "улица Новая, 8", "victims": 0},
|
||
}
|
||
|
||
monkeypatch.setattr(scenarios_api, "generate_from_description", fake_generate)
|
||
client.post("/api/auth/dev-token")
|
||
response = client.post("/api/scenarios/drafts/generate-from-description", json={
|
||
"source_id": "fire-apartment-l2",
|
||
"description": "Пожар в мастерской жилого дома, все успели выйти",
|
||
})
|
||
assert response.status_code == 201, response.text
|
||
draft = response.json()
|
||
assert draft["generation"] == "ai_full"
|
||
assert draft["id"].startswith("ai-full-")
|
||
assert draft["body"]["ground_truth"] == {"address": "улица Новая, 8", "victims": 0}
|
||
assert client.post(f"/api/scenarios/drafts/{draft['id']}/validate").json()["valid"]
|
||
assert store.get(draft["id"]) is None
|
||
|
||
|
||
def test_instructor_revises_same_ai_draft_by_comment(client, monkeypatch):
|
||
answers = iter([
|
||
{"title": "Ночной пожар на балконе",
|
||
"first_line": "Помогите, на балконе горит!",
|
||
"facts": {"f_smoke": "густой дым уже в подъезде"}},
|
||
{"title": "Ночной пожар с сильным дымом",
|
||
"first_line": "Алло, лестница вся в дыму, помогите!",
|
||
"facts": {"f_smoke": "чёрный дым полностью закрыл лестничную площадку"}},
|
||
])
|
||
comments = []
|
||
|
||
async def fake_generate(source, instruction, **kwargs):
|
||
comments.append(instruction)
|
||
if len(comments) > 1:
|
||
assert kwargs["require_fact_change"] is False
|
||
return next(answers)
|
||
|
||
monkeypatch.setattr(scenarios_api, "generate", fake_generate)
|
||
client.post("/api/auth/dev-token")
|
||
created = client.post("/api/scenarios/drafts/generate", json={
|
||
"source_id": "fire-apartment-l2", "instruction": "Добавить густой ночной дым",
|
||
}).json()
|
||
draft_id = created["id"]
|
||
revised = client.post(f"/api/scenarios/drafts/{draft_id}/revise", json={
|
||
"comment": "Сделай дым чёрным и закрой им площадку",
|
||
})
|
||
assert revised.status_code == 200, revised.text
|
||
body = revised.json()["body"]
|
||
assert revised.json()["id"] == draft_id
|
||
assert body["title"] == "Ночной пожар с сильным дымом"
|
||
assert body["facts"][0]["value"] == "улица Ленина, 14, квартира 47, 5-й этаж"
|
||
assert next(item["value"] for item in body["facts"] if item["id"] == "f_smoke").startswith("чёрный")
|
||
assert comments[-1] == "Сделай дым чёрным и закрой им площадку"
|
||
assert_atomic_audit(client, "scenario.draft.ai_revise", draft_id)
|
||
audit_row = client.fake_db.audit_rows[-1]
|
||
assert audit_row.detail == "instruction_chars=38"
|
||
assert "чёрным" not in audit_row.detail
|
||
assert client.post(f"/api/scenarios/drafts/{draft_id}/validate").json()["valid"]
|
||
|
||
|
||
def test_manual_grammar_check_covers_caller_line_and_fact_values(client, monkeypatch):
|
||
from app.scoring.grammar import GrammarAssessment
|
||
|
||
checked = []
|
||
|
||
async def fake_assess(text):
|
||
checked.append(text)
|
||
return GrammarAssessment(True, (), "rules")
|
||
|
||
monkeypatch.setattr(scenarios_api, "assess", fake_assess)
|
||
client.post("/api/auth/dev-token")
|
||
created = client.post("/api/scenarios/drafts/from-template", json={
|
||
"source_id": "fire-apartment-l2",
|
||
})
|
||
assert created.status_code == 201, created.text
|
||
draft_id = created.json()["id"]
|
||
|
||
changed = client.patch(
|
||
f"/api/scenarios/drafts/{draft_id}",
|
||
json={"first_line": "Помогите! Горит балкон."},
|
||
)
|
||
assert changed.status_code == 200, changed.text
|
||
assert client.post(f"/api/scenarios/drafts/{draft_id}/approve").status_code == 409
|
||
|
||
response = client.post(f"/api/scenarios/drafts/{draft_id}/grammar-check")
|
||
|
||
assert response.status_code == 200, response.text
|
||
result = response.json()
|
||
assert result["valid"] is True
|
||
assert result["checks"][0]["field"] == "first_line"
|
||
assert len(result["checks"]) == 1 + len(changed.json()["body"]["facts"])
|
||
assert checked == [changed.json()["body"]["first_line"], *[
|
||
fact["value"] for fact in changed.json()["body"]["facts"]
|
||
]]
|
||
assert client.post(f"/api/scenarios/drafts/{draft_id}/approve").status_code == 200
|
||
|
||
|
||
def test_failed_grammar_check_does_not_authorize_manual_draft(client, monkeypatch):
|
||
from app.scoring.grammar import GrammarAssessment
|
||
|
||
async def fake_assess(_text):
|
||
return GrammarAssessment(False, ("тестовая языковая ошибка",), "rules")
|
||
|
||
monkeypatch.setattr(scenarios_api, "assess", fake_assess)
|
||
client.post("/api/auth/dev-token")
|
||
created = client.post("/api/scenarios/drafts/from-template", json={
|
||
"source_id": "fire-apartment-l2",
|
||
})
|
||
draft_id = created.json()["id"]
|
||
assert client.patch(f"/api/scenarios/drafts/{draft_id}",
|
||
json={"first_line": "пожар"}).status_code == 200
|
||
|
||
result = client.post(f"/api/scenarios/drafts/{draft_id}/grammar-check")
|
||
|
||
assert result.status_code == 200
|
||
assert result.json()["valid"] is False
|
||
assert result.json()["checks"][0]["errors"] == ["тестовая языковая ошибка"]
|
||
assert client.post(f"/api/scenarios/drafts/{draft_id}/approve").status_code == 409
|
||
|
||
|
||
def test_ai_editor_works_in_demo_lite_without_database(monkeypatch):
|
||
monkeypatch.setenv("DEMO_NO_DB", "true")
|
||
monkeypatch.setenv("DEV_AUTH_BYPASS", "true")
|
||
get_settings.cache_clear()
|
||
|
||
async def fake_generate(source, instruction, **kwargs):
|
||
return {"title": "Ночной дым на балконе",
|
||
"first_line": "Алло, помогите, на балконе горит!",
|
||
"facts": {"f_smoke": "лестница уже заполнена густым дымом"}}
|
||
|
||
monkeypatch.setattr(scenarios_api, "generate", fake_generate)
|
||
try:
|
||
with TestClient(app) as demo:
|
||
assert demo.post("/api/auth/dev-token").status_code == 200
|
||
created = demo.post("/api/scenarios/drafts/generate", json={
|
||
"source_id": "fire-apartment-l2", "instruction": "Добавить густой ночной дым",
|
||
})
|
||
assert created.status_code == 201, created.text
|
||
draft_id = created.json()["id"]
|
||
assert demo.get(f"/api/scenarios/drafts/{draft_id}").status_code == 200
|
||
assert demo.post(f"/api/scenarios/drafts/{draft_id}/validate").json()["valid"]
|
||
assert demo.post(f"/api/scenarios/drafts/{draft_id}/approve").status_code == 200
|
||
assert demo.get(f"/api/scenarios/{draft_id}").status_code == 200
|
||
finally:
|
||
get_settings.cache_clear()
|
||
|
||
|
||
def test_invalid_draft_cannot_be_approved(client):
|
||
client.post("/api/auth/dev-token")
|
||
response = client.post(
|
||
"/api/scenarios/drafts/from-template",
|
||
json={"source_id": "fire-apartment-l2"},
|
||
)
|
||
draft_id = response.json()["id"]
|
||
assert client.patch(f"/api/scenarios/drafts/{draft_id}", json={"facts": []}).status_code == 200
|
||
check = client.post(f"/api/scenarios/drafts/{draft_id}/validate")
|
||
assert check.json()["valid"] is False
|
||
assert client.post(f"/api/scenarios/drafts/{draft_id}/approve").status_code == 422
|
||
assert store.get(draft_id) is None
|
||
|
||
|
||
def test_unresolved_fact_placeholder_cannot_be_validated_or_approved(client):
|
||
client.post("/api/auth/dev-token")
|
||
created = client.post(
|
||
"/api/scenarios/drafts/from-template",
|
||
json={"source_id": "fire-apartment-l2"},
|
||
).json()
|
||
draft_id = created["id"]
|
||
facts = created["body"]["facts"]
|
||
facts[1]["value"] = "{f_what_burns}"
|
||
assert client.patch(
|
||
f"/api/scenarios/drafts/{draft_id}", json={"facts": facts}
|
||
).status_code == 200
|
||
check = client.post(f"/api/scenarios/drafts/{draft_id}/validate")
|
||
assert check.json()["valid"] is False
|
||
assert "плейсхолдер" in check.json()["errors"][0]
|
||
assert client.post(f"/api/scenarios/drafts/{draft_id}/approve").status_code == 422
|
||
|
||
|
||
def test_unauthenticated_user_cannot_manage_drafts(client):
|
||
response = client.post(
|
||
"/api/scenarios/drafts/from-template", json={"source_id": "fire-apartment-l2"}
|
||
)
|
||
assert response.status_code == 401
|
||
|
||
|
||
def test_instructor_archives_and_restores_scenario_without_deleting_history(client):
|
||
client.post("/api/auth/dev-token")
|
||
created = client.post(
|
||
"/api/scenarios/drafts/from-template",
|
||
json={"source_id": "fire-apartment-l2", "title": "Сценарий для проверки архива"},
|
||
)
|
||
assert created.status_code == 201, created.text
|
||
scenario_id = created.json()["id"]
|
||
approved = client.post(f"/api/scenarios/drafts/{scenario_id}/approve")
|
||
assert approved.status_code == 200, approved.text
|
||
assert_atomic_audit(client, "scenario.approve", scenario_id)
|
||
original = store.get(scenario_id)
|
||
assert original is not None
|
||
|
||
archived = client.delete(f"/api/scenarios/{scenario_id}")
|
||
assert archived.status_code == 200, archived.text
|
||
assert_atomic_audit(client, "scenario.archive", scenario_id)
|
||
assert archived.json()["status"] == "archived"
|
||
assert store.get(scenario_id) is None
|
||
assert scenario_id not in {item["id"] for item in client.get("/api/scenarios").json()}
|
||
assert client.get(f"/api/scenarios/{scenario_id}").status_code == 404
|
||
|
||
restored = client.post(f"/api/scenarios/{scenario_id}/restore")
|
||
assert restored.status_code == 200, restored.text
|
||
assert_atomic_audit(client, "scenario.restore", scenario_id)
|
||
assert restored.json()["status"] == "published"
|
||
assert store.get(scenario_id).title == original.title
|
||
assert scenario_id in {item["id"] for item in client.get("/api/scenarios").json()}
|
||
|
||
|
||
def test_instructor_cannot_read_or_edit_another_instructors_draft(client, monkeypatch):
|
||
from app.api.auth import Principal
|
||
from app.domain.roles import Role
|
||
|
||
identity = {"login": "teacher-one"}
|
||
|
||
def instructor(_request, *_roles):
|
||
return Principal(login=identity["login"], full_name="Преподаватель", role=Role.INSTRUCTOR)
|
||
|
||
monkeypatch.setattr(scenarios_api, "require", instructor)
|
||
created = client.post(
|
||
"/api/scenarios/drafts/from-template",
|
||
json={"source_id": "fire-apartment-l2", "title": "Личный черновик"},
|
||
)
|
||
assert created.status_code == 201, created.text
|
||
scenario_id = created.json()["id"]
|
||
|
||
identity["login"] = "teacher-two"
|
||
assert client.get(f"/api/scenarios/drafts/{scenario_id}").status_code == 404
|
||
assert client.patch(
|
||
f"/api/scenarios/drafts/{scenario_id}", json={"title": "Чужая правка"}
|
||
).status_code == 404
|
||
assert client.post(f"/api/scenarios/drafts/{scenario_id}/approve").status_code == 404
|
||
|
||
|
||
def test_instructor_cannot_archive_another_instructors_published_scenario(client, monkeypatch):
|
||
from app.api.auth import Principal
|
||
from app.domain.roles import Role
|
||
|
||
identity = {"login": "teacher-one"}
|
||
|
||
def instructor(_request, *_roles):
|
||
return Principal(login=identity["login"], full_name="Преподаватель", role=Role.INSTRUCTOR)
|
||
|
||
monkeypatch.setattr(scenarios_api, "require", instructor)
|
||
created = client.post(
|
||
"/api/scenarios/drafts/from-template",
|
||
json={"source_id": "fire-apartment-l2", "title": "Публикация автора"},
|
||
)
|
||
assert created.status_code == 201, created.text
|
||
scenario_id = created.json()["id"]
|
||
assert client.post(f"/api/scenarios/drafts/{scenario_id}/approve").status_code == 200
|
||
scenario = next(item for item in client.get("/api/scenarios").json() if item["id"] == scenario_id)
|
||
assert scenario["can_manage"] is True
|
||
|
||
identity["login"] = "teacher-two"
|
||
assert scenario_id not in {item["id"] for item in client.get("/api/scenarios").json()}
|
||
assert client.get(f"/api/scenarios/{scenario_id}").status_code == 404
|
||
assert client.delete(f"/api/scenarios/{scenario_id}").status_code == 404
|
||
|
||
|
||
def test_scenario_in_active_lesson_cannot_be_archived(client, monkeypatch):
|
||
client.post("/api/auth/dev-token")
|
||
monkeypatch.setattr(scenarios_api.hub, "has_active_scenario", lambda _scenario_id: True)
|
||
response = client.delete("/api/scenarios/fire-apartment-l2")
|
||
assert response.status_code == 409
|
||
assert response.json()["detail"] == "scenario_is_used_by_active_session"
|
||
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_approved_scenario_restores_from_local_database():
|
||
source = load_file(LIBRARY / "fire-apartment-l2.yaml", LIBRARY)
|
||
db = FakeSession()
|
||
row = await store.create_draft(db, source=source)
|
||
approved = await store.approve_draft(db, row)
|
||
store.set_library([source]) # имитация нового процесса после чтения YAML
|
||
assert store.get(approved.id) is None
|
||
assert await store.restore_published(db) == 1
|
||
assert store.get(approved.id).title == approved.title
|
||
assert await store.restore_published(db) == 0
|