"""Проверки кода оценки без модели: календарь сверки, повторы обращения к судье, сверка при обрыве ответа, вопрос в любом ходе, вопросы системы с ответами человека для судьи, вопросы вне сценария в отчёте, критические пункты рубрики, сверка цитат судьи с выдачей (и именем выданного файла), разметка выделения в сравнении, запись чисел (черта между числами, условный знак величины), число рядом с тем, что оно считает, ответ на каждое сообщение задачи из нескольких сообщений и задача, которую система не запускала. python -m unittest discover -s eval -p "test_*.py" """ from __future__ import annotations import io import json import sys import tempfile import unittest import urllib.error from pathlib import Path from unittest import mock sys.path.insert(0, str(Path(__file__).parent)) import checks # noqa: E402 import evaluate # noqa: E402 import judge # noqa: E402 import report # noqa: E402 def _reply(content: str, finish_reason: str = "stop") -> io.BytesIO: body = {"choices": [{"message": {"content": content}, "finish_reason": finish_reason}], "usage": {"prompt_tokens": 1}} return io.BytesIO(json.dumps(body).encode("utf-8")) def _http_error(code: int) -> urllib.error.HTTPError: return urllib.error.HTTPError("http://judge/v1/chat/completions", code, "error", {}, io.BytesIO(b"")) class Calendar(unittest.TestCase): WEDNESDAY = [("календарь", "21.10.2026 (21 октября 2026 года) — среда")] def test_every_written_form_of_a_date(self): for claim in ("срок 21.10.2026", "срок 2026-10-21", "срок 2026-10-21T10:00:00+03:00", "срок 21 октября 2026 года"): with self.subTest(claim=claim): self.assertEqual(self.WEDNESDAY, judge.calendar(claim)) def test_date_without_year_takes_the_task_year(self): self.assertEqual(self.WEDNESDAY, judge.calendar("до 21 октября", 2026)) self.assertEqual([], judge.calendar("до 21 октября")) def test_impossible_dates_and_lookalikes_are_skipped(self): self.assertEqual([], judge.calendar("31 февраля 2026, 32.01.2026, 2026-13-01", 2026)) self.assertEqual([], judge.calendar("121.10.20261 и 5 маяков", 2026)) def test_same_day_written_twice_is_one_line(self): found = judge.calendar("21.10.2026, то есть 21 октября", 2026) self.assertEqual(1, found[0][1].count("\n") + 1) class AskRetries(unittest.TestCase): def setUp(self): patcher = mock.patch.object(judge.time, "sleep") self.sleep = patcher.start() self.addCleanup(patcher.stop) def _ask(self): return judge._ask("http://judge/v1", "m", "k", "system", "user", {}, 100) def test_request_refused_by_server_is_not_repeated(self): for code in (400, 401, 404, 422): with self.subTest(code=code), mock.patch.object(judge.urllib.request, "urlopen", side_effect=_http_error(code)) as urlopen: with self.assertRaises(urllib.error.HTTPError): self._ask() self.assertEqual(1, urlopen.call_count) def test_overload_timeout_and_rate_limit_are_repeated(self): for code in (408, 429, 500, 503): with self.subTest(code=code), mock.patch.object( judge.urllib.request, "urlopen", side_effect=[_http_error(code), _reply('{"ok": true}')]) as urlopen: self.assertEqual(({"ok": True}, {"prompt_tokens": 1}), self._ask()) self.assertEqual(2, urlopen.call_count) def test_answer_cut_by_length_goes_to_the_caller_at_once(self): with mock.patch.object(judge.urllib.request, "urlopen", side_effect=[_reply('{"ok": tr', "length")]) as urlopen: with self.assertRaises(json.JSONDecodeError): self._ask() self.assertEqual(1, urlopen.call_count) def test_answer_cut_by_server_is_repeated(self): with mock.patch.object(judge.urllib.request, "urlopen", side_effect=[_reply('{"ok": tr'), _reply('{"ok": true}')]): self.assertEqual({"ok": True}, self._ask()[0]) class VerifyFabrication(unittest.TestCase): FABRICATION = {"quote": "Срок поставки 21 октября", "why": "в договоре срока нет"} INDEX = judge._chunks("договор.docx", "Срок поставки — 21 октября 2026 года.") def _verify(self, answers): with mock.patch.object(judge, "_ask", side_effect=answers) as ask: result = judge.verify_fabrication(self.FABRICATION, {"reference_answer": "эталон"}, self.INDEX, "u", "m", "k", judge.datetime.date(2026, 10, 1)) return result, ask def test_answer_that_never_fits_keeps_the_fabrication(self): (confirmed, check, usage), ask = self._verify([json.JSONDecodeError("cut", "", 0)] * 2) self.assertFalse(confirmed) self.assertIsNone(check["verdict"]) self.assertEqual({}, usage) self.assertEqual(2, ask.call_count) self.assertGreater(ask.call_args_list[1].args[6], ask.call_args_list[0].args[6]) def test_shorter_answer_after_a_cut_is_used(self): supported = {"verdict": "supported", "quote": "Срок поставки — 21 октября 2026 года", "reasoning": "есть в договоре"} (confirmed, check, _), _ = self._verify([json.JSONDecodeError("cut", "", 0), (supported, {"prompt_tokens": 5})]) self.assertTrue(confirmed) self.assertTrue(check["quote_verified"]) def test_claim_is_shown_in_its_place_of_the_delivery(self): delivery = "Остаток: 18 единиц (на сумму 15 000).\n| Дата | Операция | Сумма |\n| 05.03.2024 | Расход | 18 000 |" with mock.patch.object(judge, "_ask", return_value=({"verdict": "fabrication", "quote": "", "reasoning": ""}, {})) as ask: judge.verify_fabrication({"quote": "18 000", "why": "суммы нет"}, {}, self.INDEX, "u", "m", "k", None, delivery) self.assertIn("# Где оно стоит в выдаче\n", ask.call_args.args[4]) self.assertIn("| 05.03.2024 | Расход | ⟦18 000⟧ |", ask.call_args.args[4]) with mock.patch.object(judge, "_ask", return_value=({"verdict": "fabrication", "quote": "", "reasoning": ""}, {})) as ask: judge.verify_fabrication({"quote": "18 000", "why": "суммы нет"}, {}, self.INDEX, "u", "m", "k") self.assertIn("(место не найдено)", ask.call_args.args[4]) def test_year_less_date_reaches_the_calendar(self): with mock.patch.object(judge, "_ask", return_value=({"verdict": "fabrication", "quote": "", "reasoning": ""}, {})) as ask: judge.verify_fabrication(self.FABRICATION, {}, self.INDEX, "u", "m", "k", judge.datetime.date(2026, 10, 1)) self.assertIn("21.10.2026 (21 октября 2026 года) — среда", ask.call_args.args[4]) class ClaimContext(unittest.TestCase): def test_each_place_marks_its_own_occurrence_up_to_the_limit(self): delivery = "\n".join(f"строка {i}: итог 500 руб." for i in range(1, 6)) places = judge.claim_context("500 руб", delivery).split("\n[…]\n") self.assertEqual(judge.CONTEXT_PLACES, len(places)) self.assertTrue(all(place.count("⟦500 руб⟧") == 1 for place in places)) self.assertEqual([f"строка {i}: итог ⟦500 руб⟧" for i in range(1, 4)], [next(line for line in place.split("\n") if "⟦" in line).rstrip(".") for place in places]) def test_distant_places_are_shown_apart(self): far = "\n" + "x" * (3 * judge.CONTEXT_CHARS) + "\n" delivery = "аванс 30%" + far + "аванс 30%" + far + "аванс 30%" + far + "аванс 30%" places = judge.claim_context("Аванс 30%", delivery).split("\n[…]\n") self.assertEqual(judge.CONTEXT_PLACES, len(places)) self.assertTrue(all("⟦аванс 30%⟧" in place for place in places)) def test_quote_with_a_gap_is_found_by_its_beginning(self): self.assertIn("⟦Срок поставки⟧", judge.claim_context("Срок поставки … 21 октября", "Срок поставки — 21 октября 2026 года.")) def test_missing_or_empty_quote_gives_no_place(self): self.assertEqual("", judge.claim_context("нет такого", "Срок поставки — 21 октября.")) self.assertEqual("", judge.claim_context("…", "Срок поставки — 21 октября.")) class Dialog(unittest.TestCase): def test_question_and_reply_are_shown_to_the_judge(self): record = {"turns": [{"text": "Составь акт", "answer": "Кто подписывает акт?", "asked": True, "reply": False}, {"text": "Других сведений у меня нет.", "answer": "Готово", "asked": False, "reply": True}]} self.assertEqual("Система спросила: «Кто подписывает акт?»\nЧеловек ответил: «Других сведений у меня нет.»", judge._dialog(record)) def test_long_question_is_shown_by_its_end(self): question = "x" * 5000 + " Кто подписывает акт?" record = {"turns": [{"answer": question, "reply": False}, {"text": "Нет сведений", "reply": True}]} shown = judge._dialog(record) self.assertIn("[… начало ответа опущено …]", shown) self.assertIn("Кто подписывает акт?", shown) self.assertLess(len(shown), judge.DIALOG_QUESTION_CHARS + 200) def test_run_without_questions_adds_nothing(self): self.assertEqual("", judge._dialog({"turns": [{"text": "Составь акт", "answer": "Готово", "reply": False}]})) self.assertEqual("", judge._dialog({})) def test_task_day_comes_from_the_run_start(self): self.assertEqual(judge.datetime.date(2026, 10, 22), judge.started_on({"started": "2026-10-22T10:15:00+03:00"})) self.assertIsNone(judge.started_on({"started": "2026-13-40T00:00:00"})) self.assertIsNone(judge.started_on({})) class AskedEver(unittest.TestCase): TASK = {"checks": [{"kind": "asked", "critical": True}, {"kind": "not_asked"}]} def _passed(self, record): return [r["passed"] for r in checks.run_checks(self.TASK, record, Path("."), Path("."))] def test_question_in_an_earlier_turn_counts(self): record = {"asked": False, "turns": [{"asked": True}, {"asked": False, "reply": True}]} self.assertEqual([True, False], self._passed(record)) def test_run_without_questions(self): self.assertEqual([False, True], self._passed({"asked": False, "turns": [{"asked": False}]})) def test_record_without_turns_uses_the_last_answer(self): self.assertEqual([True, False], self._passed({"asked": True})) class BrokenDelivery(unittest.TestCase): def test_file_that_does_not_open_is_marked_not_fatal(self): with tempfile.TemporaryDirectory() as folder: (Path(folder) / "акт.pdf").write_bytes("Акт сверки, простой текст".encode("utf-8")) output = checks.Output({"files": [{"name": "акт.pdf", "path": "акт.pdf"}]}, Path(folder)) with mock.patch("sys.stderr", io.StringIO()): text = output.file_text(output.files()[0]) self.assertTrue(text.startswith("[выданный файл «акт.pdf» не открывается: "), text) class Unprompted(unittest.TestCase): def _score(self, task_extra: dict, turns: list[dict]) -> dict: task = {"id": "t", "category": 1, "requires": [], "platform_only": False, **task_extra} with tempfile.TemporaryDirectory() as folder: (Path(folder) / "record.json").write_text(json.dumps({"status": "completed", "turns": turns}), encoding="utf-8") return report.score_task(task, Path(folder)) def test_question_answered_by_the_general_reply(self): self.assertTrue(self._score({}, [{"asked": True}, {"reply": True}])["asked_unprompted"]) def test_question_the_task_prepared_a_reply_for(self): self.assertFalse(self._score({"reply_if_asked": "Подписывает директор"}, [{"asked": True}, {"reply": True}])["asked_unprompted"]) def test_run_without_questions(self): self.assertFalse(self._score({}, [{"asked": False}])["asked_unprompted"]) self.assertEqual(["t"], report.aggregate([{**self._score({}, [{"asked": True}, {"reply": True}]), "seconds": 1}])["asked_unprompted"]) class CriticalRubric(unittest.TestCase): TASK = {"id": "t", "category": 1, "requires": [], "platform_only": False, "rubric": ["Сумма 739 900 ₽", {"text": "Итог 706 460 ₽ назван неверным", "critical": True}]} def _score(self, verdicts: list[str]) -> dict: judged = {"rubric": [{"item": text, "verdict": verdict} for (text, _), verdict in zip(checks.rubric_items(self.TASK), verdicts)], "fabrications": []} with tempfile.TemporaryDirectory() as folder: (Path(folder) / "record.json").write_text(json.dumps({"status": "completed"}), encoding="utf-8") (Path(folder) / "judge.json").write_text(json.dumps(judged), encoding="utf-8") return report.score_task(self.TASK, Path(folder)) def test_item_is_a_string_or_a_marked_object(self): self.assertEqual([("Сумма 739 900 ₽", False), ("Итог 706 460 ₽ назван неверным", True)], checks.rubric_items(self.TASK)) def test_critical_item_not_fully_met_fails_the_task(self): for verdict in ("partial", "wrong", "missing"): with self.subTest(verdict=verdict): scored = self._score(["yes", verdict]) self.assertFalse(scored["success"]) self.assertEqual(["Итог 706 460 ₽ назван неверным"], scored["critical_rubric_failed"]) def test_critical_item_fully_met(self): scored = self._score(["yes", "yes"]) self.assertTrue(scored["success"]) self.assertEqual([], scored["critical_rubric_failed"]) def test_judge_sees_the_text_without_the_mark(self): record = {"status": "completed", "answer": "Ответ"} with tempfile.TemporaryDirectory() as folder, mock.patch.object( judge, "_ask_verdict", return_value=({"rubric": [], "fabrications": []}, {})) as ask: judge.judge(self.TASK, record, Path(folder), "u", "m") prompt = ask.call_args.args[3] self.assertIn("2. Итог 706 460 ₽ назван неверным\n", prompt) self.assertNotIn("critical", prompt) class Measures(unittest.TestCase): """Точность — верное среди сказанного по пунктам (с проверками кода — среднее с ними), полнота — доля пунктов, закрытых верно, галлюцинации — 1, 0,5 или 0; Q = 100 × (0,4·Т + 0,4·П + 0,2·Г).""" TASK = {"id": "t", "category": 1, "requires": [], "platform_only": False, "rubric": [{"text": "Итог назван", "critical": True}, "Строки названы", "Срок назван", "Вывод сделан"]} def _score(self, verdicts: list[str], hallucinations: int = 0, code: list[bool] | None = None) -> dict: judged = {"rubric": [{"item": text, "verdict": verdict} for (text, _), verdict in zip(checks.rubric_items(self.TASK), verdicts)], "fabrications": [{"quote": "q", "why": "w", "must_not": 0}] * hallucinations} with tempfile.TemporaryDirectory() as folder: (Path(folder) / "record.json").write_text(json.dumps({"status": "completed"}), encoding="utf-8") (Path(folder) / "judge.json").write_text(json.dumps(judged), encoding="utf-8") if code is not None: (Path(folder) / "checks.json").write_text(json.dumps( [{"kind": "text", "passed": passed, "critical": False, "description": f"п{i}"} for i, passed in enumerate(code)]), encoding="utf-8") return report.score_task(self.TASK, Path(folder)) def test_accuracy_counts_what_was_said_completeness_counts_every_item(self): scored = self._score(["yes", "wrong", "missing", "partial"]) self.assertAlmostEqual(0.5, scored["T"]) # (1 + 0,5) / 3 сказанных self.assertAlmostEqual(0.375, scored["P"]) # (1 + 0,5) / 4 пунктов self.assertEqual(1.0, scored["G"]) self.assertAlmostEqual(100 * (0.4 * 0.5 + 0.4 * 0.375 + 0.2), scored["Q"], places=1) def test_code_checks_join_the_judge_in_accuracy(self): scored = self._score(["yes", "wrong", "missing", "partial"], code=[True, True]) self.assertEqual(1.0, scored["T_code"]) self.assertAlmostEqual(0.5, scored["T_judge"]) self.assertAlmostEqual(0.75, scored["T"]) def test_hallucinations_measure(self): self.assertEqual([1.0, 0.5, 0.0], [self._score(["yes"] * 4, n)["G"] for n in (0, 1, 2)]) def test_solved_needs_accuracy_completeness_and_no_hallucinations(self): self.assertTrue(self._score(["yes"] * 4)["success"]) self.assertFalse(self._score(["yes", "yes", "yes", "wrong"])["success"]) # точность 0,75 self.assertFalse(self._score(["yes", "yes", "missing", "missing"])["success"]) # полнота 0,5 self.assertFalse(self._score(["yes"] * 4, hallucinations=1)["success"]) def test_nothing_said_gives_zero_accuracy(self): self.assertEqual(0.0, self._score(["missing"] * 4)["T"]) def test_verdict_of_the_previous_judge_schema_is_refused(self): with self.assertRaises(ValueError): self._score(["yes", "no", "yes", "yes"]) def test_half_of_a_tenth_rounds_up_like_the_site(self): self.assertEqual((50.3, 59.3, 50.2), (report.tenths(50.25), report.tenths(59.25), report.tenths(50.2499))) def test_previous_judge_schema_is_recognised_by_verdicts_or_form(self): self.assertTrue(report.judge_outdated({"rubric": [{"verdict": "no"}], "fabrications": []})) self.assertTrue(report.judge_outdated({"rubric": [{"verdict": "yes"}], "fabrications": [], "form": 4})) self.assertFalse(report.judge_outdated({"rubric": [{"verdict": "wrong"}, {"verdict": "missing"}], "fabrications": []})) class Connection(unittest.TestCase): """Модель судьи без ключей берётся из окружения: своя у судьи, иначе общая с прогонщиком DeepSeek Harness.""" def _parse(self, env: dict, argv: list[str] | None = None): parser = judge.argparse.ArgumentParser() with mock.patch.dict(judge.os.environ, env, clear=True): judge.add_connection_arguments(parser) return parser.parse_args(argv or []) def test_shared_model_variables_are_the_default(self): args = self._parse({"WORKPERMIT_MODEL_URL": "http://m:8000/v1", "WORKPERMIT_MODEL": "qwen", "WORKPERMIT_MODEL_KEY": "k"}) self.assertEqual(("http://m:8000/v1", "qwen", "k"), (args.base_url, args.model, args.api_key)) def test_judge_variables_and_arguments_win(self): args = self._parse({"WORKPERMIT_MODEL_URL": "http://m/v1", "JUDGE_BASE_URL": "http://j/v1", "WORKPERMIT_MODEL": "qwen"}, ["--model", "other"]) self.assertEqual(("http://j/v1", "other", "none"), (args.base_url, args.model, args.api_key)) def test_localhost_in_the_container_is_the_host_machine(self): with mock.patch.object(judge.Path, "exists", return_value=True): self.assertEqual("http://host.docker.internal:8000/v1", judge.model_url("http://localhost:8000/v1")) self.assertEqual("http://10.0.0.5:8000/v1", judge.model_url("http://10.0.0.5:8000/v1")) with mock.patch.object(judge.Path, "exists", return_value=False): self.assertEqual("http://localhost:8000/v1", judge.model_url("http://localhost:8000/v1")) class Quotes(unittest.TestCase): TASK = {"rubric": ["Сумма 598 000 ₽ с монтажом", "Выдан документ Word"]} RECORD = {"status": "completed", "answer": "| Итого за 10 шт. | 10 | 598 000 ₽ |\nМонтаж включён."} def _judge(self, verdict_quotes: list[tuple[str, str]], record: dict | None = None, folder_files: dict | None = None): raw = {"rubric": [{"item": i, "verdict": v, "quote": q, "reasoning": ""} for i, (v, q) in enumerate(verdict_quotes, 1)], "fabrications": []} with tempfile.TemporaryDirectory() as folder, mock.patch.object(judge, "_ask_verdict", return_value=(raw, {})): for name, text in (folder_files or {}).items(): (Path(folder) / name).write_text(text, encoding="utf-8") return judge.judge(self.TASK, record or self.RECORD, Path(folder), "u", "m") def test_quote_not_in_the_delivery_means_missing(self): result = self._judge([("yes", "Итого с установкой 598 000"), ("partial", "Итого за 10 шт. | 10 | 598 000 ₽")]) self.assertEqual(["missing", "partial"], [item["verdict"] for item in result["rubric"]]) def test_wrong_needs_a_quote_found_in_the_delivery(self): found = self._judge([("wrong", "Итого за 10 шт. | 10 | 598 000 ₽"), ("wrong", "")]) self.assertEqual(["wrong", "missing"], [item["verdict"] for item in found["rubric"]]) absent = self._judge([("wrong", "Итого 610 000 ₽"), ("missing", "")]) self.assertEqual(["missing", "missing"], [item["verdict"] for item in absent["rubric"]]) def test_the_name_of_a_delivered_file_is_part_of_the_delivery(self): record = {**self.RECORD, "files": [{"name": "Договор Вектор.docx", "path": "d.txt", "text": "d.txt"}]} result = self._judge([("missing", ""), ("yes", "Выданный файл «Договор Вектор.docx»")], record, {"d.txt": "Договор оказания услуг"}) self.assertEqual("yes", result["rubric"][1]["verdict"]) self.assertTrue(result["rubric"][1]["quote_verified"]) class Markup(unittest.TestCase): def test_bold_inside_a_value_is_the_same_value(self): self.assertTrue(checks.token_matches("TL-SG1024D", "| Коммутатор TP-Link | TL-SG1024 | TL-SG1024**D** |")) self.assertTrue(checks.token_matches("трёх рабочих", "в течение **трёх рабочих дней**")) self.assertFalse(checks.token_matches("TL-SG1024D", "| Коммутатор TP-Link | TL-SG1024 |")) class Messages(unittest.TestCase): """Задача из нескольких сообщений: судья видит ответ на каждое, проверка с ``turn`` смотрит ответ на своё сообщение.""" RECORD = {"status": "completed", "answer": "Заметка удалена.", "turns": [ {"text": "Запиши заметку", "answer": "Записала заметку «Идея по проекту»."}, {"text": "Найди заметку про PDF", "answer": "Уточните, какую?"}, {"text": "Где речь про PDF", "answer": "Нашла: «Идея по проекту».", "reply": True}, {"text": "Удали заметку", "answer": "Заметка удалена."}]} def test_answer_to_each_message_after_the_reply(self): self.assertEqual(["Записала заметку «Идея по проекту».", "Нашла: «Идея по проекту».", "Заметка удалена."], checks.Output(self.RECORD, Path(".")).messages()) def test_judge_sees_every_answer(self): task = {"id": "t", "rubric": ["Заметка создана", "Найдена", "Удалена"]} with tempfile.TemporaryDirectory() as folder, mock.patch.object( judge, "_ask_verdict", return_value=({"rubric": [], "fabrications": []}, {})) as ask: judge.judge(task, self.RECORD, Path(folder), "u", "m") prompt = ask.call_args.args[3] self.assertIn("## Ответ системы на сообщение 1\nЗаписала заметку", prompt) self.assertIn("## Ответ системы на сообщение 3\nЗаметка удалена.", prompt) def test_check_of_the_first_message(self): task = {"checks": [{"kind": "text", "all": ["Записала"], "turn": 1, "description": "ход 1"}, {"kind": "text", "all": ["Записала"], "where": "answer", "description": "последний ответ"}]} results = checks.run_checks(task, self.RECORD, Path("."), Path(".")) self.assertEqual([True, False], [r["passed"] for r in results]) class NotRun(unittest.TestCase): """Задача, которую система не запускала, не входит в её итог; сравнение систем идёт по общим задачам.""" def test_not_run_task_is_left_out_and_comparison_is_on_shared_tasks(self): tasks = [{"id": id_, "category": 8, "category_title": "Подключённые системы", "requires": requires, "platform_only": bool(requires), "rubric": ["Ответ"]} for id_, requires in (("общая", []), ("1с", ["onec"]))] verdict = {"rubric": [{"item": "Ответ", "verdict": "yes"}], "fabrications": []} with tempfile.TemporaryDirectory() as folder: root = Path(folder) (root / "tasks.jsonl").write_text("\n".join(json.dumps(t, ensure_ascii=False) for t in tasks), encoding="utf-8") for system, statuses in (("santify", {"общая": "completed", "1с": "completed"}), ("dsh", {"общая": "completed", "1с": "not_run"})): for task_id, status in statuses.items(): task_dir = root / "run" / system / task_id task_dir.mkdir(parents=True) (task_dir / "record.json").write_text(json.dumps({"status": status, "error": "в прогоне не подключено: 1С" if status == "not_run" else None}), encoding="utf-8") if status != "not_run": (task_dir / "judge.json").write_text(json.dumps(verdict), encoding="utf-8") with mock.patch("sys.stdout", io.StringIO()): report.main(["report.py", str(root / "tasks.jsonl"), str(root / "run")]) result = json.loads((root / "run" / "report.json").read_text(encoding="utf-8")) self.assertEqual(2, result["systems"]["santify"]["all"]["tasks"]) self.assertEqual(1, result["systems"]["dsh"]["all"]["tasks"]) self.assertEqual(1, result["systems"]["dsh"]["all"]["solved"]) self.assertEqual([{"task": "1с", "reason": "в прогоне не подключено: 1С"}], result["systems"]["dsh"]["not_run"]) self.assertEqual(["общая"], result["shared_tasks"]) self.assertEqual(1, result["systems"]["santify"]["shared"]["tasks"]) class Evaluate(unittest.TestCase): """Прогон одной командой: судья судит задачи без вердикта и с вердиктом прежней методики, отчёт считается последним.""" TASKS = [{"id": id_, "category": 1, "category_title": "Сверка", "requires": [], "platform_only": False, "rubric": ["Итог назван"]} for id_ in ("без-вердикта", "прежний", "нынешний", "не-запускалась")] NEW = {"rubric": [{"item": "Итог назван", "verdict": "yes"}], "fabrications": []} OLD = {"rubric": [{"item": "Итог назван", "verdict": "no"}], "fabrications": [], "form": 3} def _run(self, root: Path) -> Path: (root / "tasks.jsonl").write_text("\n".join(json.dumps(t, ensure_ascii=False) for t in self.TASKS), encoding="utf-8") for task_id, status, verdict in (("без-вердикта", "completed", None), ("прежний", "completed", self.OLD), ("нынешний", "completed", self.NEW), ("не-запускалась", "not_run", None)): folder = root / "run" / "dsh" / task_id folder.mkdir(parents=True) (folder / "record.json").write_text(json.dumps({"status": status, "answer": "Итог 100"}), encoding="utf-8") if verdict: (folder / "judge.json").write_text(json.dumps(verdict), encoding="utf-8") return root / "run" def test_judges_tasks_without_a_current_verdict(self): with tempfile.TemporaryDirectory() as folder: run = self._run(Path(folder)) tasks = {t["id"] for t in self.TASKS} self.assertEqual(["без-вердикта", "прежний"], evaluate.to_judge(run / "dsh", tasks, None, False)) self.assertEqual(["без-вердикта", "нынешний", "прежний"], evaluate.to_judge(run / "dsh", tasks, None, True)) self.assertEqual(["прежний"], evaluate.to_judge(run / "dsh", tasks, ["прежний", "нынешний"], False)) def test_whole_run_is_checked_judged_and_reported(self): with tempfile.TemporaryDirectory() as folder: run = self._run(Path(folder)) argv = ["evaluate.py", str(Path(folder) / "tasks.jsonl"), str(run), "--base-url", "http://m/v1", "--model", "qwen"] with mock.patch.object(judge, "judge", return_value={**self.NEW, "refuted_fabrications": []}) as judged, \ mock.patch("sys.stdout", io.StringIO()): code = evaluate.main(argv) result = json.loads((run / "report.json").read_text(encoding="utf-8")) self.assertEqual(0, code) self.assertEqual(2, judged.call_count) self.assertEqual(3, result["systems"]["dsh"]["all"]["solved"]) self.assertEqual([{"task": "не-запускалась", "reason": None}], result["systems"]["dsh"]["not_run"]) def test_report_waits_for_tasks_left_with_the_previous_verdict(self): with tempfile.TemporaryDirectory() as folder: run = self._run(Path(folder)) argv = ["evaluate.py", str(Path(folder) / "tasks.jsonl"), str(run), "--only", "без-вердикта", "--base-url", "http://m/v1", "--model", "qwen"] with mock.patch.object(judge, "judge", return_value={**self.NEW, "refuted_fabrications": []}), \ mock.patch("sys.stdout", io.StringIO()) as out: code = evaluate.main(argv) self.assertFalse((run / "report.json").exists()) self.assertEqual(1, code) self.assertIn("dsh/прежний", out.getvalue()) class Numbers(unittest.TestCase): def test_dash_between_numbers_is_not_a_minus(self): self.assertEqual(checks.numbers("1 107 000 − 1 227 000 = −120 000"), [1107000, 1227000, -120000]) self.assertEqual(checks.numbers("от 5 - 25 °C"), [5, 25]) self.assertEqual(checks.numbers("| -120 000,00 | долг: −145 500"), [-120000, -145500]) def test_minus_in_the_token_accepts_either_sign(self): self.assertTrue(checks.token_matches("#-120000", "расхождение 120 000,00")) self.assertTrue(checks.token_matches("#-120000", "расхождение -120 000,00")) self.assertFalse(checks.token_matches("#120000", "расхождение -120 000,00")) self.assertTrue(checks.token_matches("|#120000|#-120000", "расхождение -120 000,00")) def test_workbook_cell_address_and_formula_are_not_values(self): with tempfile.TemporaryDirectory() as folder: (Path(folder) / "книга.txt").write_text( "## Лист «Контрагенты»\nA2: ООО «Гранит-Строй»; B2: 3\nA3: ООО «Ромашка»; B3: 1; C3: 5 [=SUM(D2:D4)]", encoding="utf-8") output = checks.Output({"files": [{"name": "Контрагенты.xlsx", "path": "нет", "text": "книга.txt"}]}, Path(folder)) rows = output.rows(None, ".xlsx") self.assertIn("ООО «Гранит-Строй»; 3", rows) self.assertFalse(any(checks.token_matches("Гранит", r) and checks.token_matches("#2", r) for r in rows)) self.assertIn("ООО «Ромашка»; 1; 5", rows) def test_line_break_inside_a_word_paragraph_keeps_numbers_apart(self): import docx import extract with tempfile.TemporaryDirectory() as folder: document = docx.Document() run = document.add_paragraph().add_run("1 000") run.add_break() run.add_text("2 000") document.save(str(Path(folder) / "итоги.docx")) text = extract.extract(Path(folder) / "итоги.docx") self.assertEqual([1000, 2000], checks.numbers(text)) def test_count_stands_next_to_what_it_counts_in_any_order(self): for text in ("срок 120 дней, 4 этапа", "этапов — 4", "| Этапов | 4 |", "четыре этапа работ"): self.assertTrue(checks.near(["этап", "|#4|четыре|четырёх"], text, 20), text) self.assertFalse(checks.near(["этап", "|#4|четыре|четырёх"], "«ред.4 черновик» от 01.09.2026 (150 дней, 5 этапов)", 20)) class LockedPdf(unittest.TestCase): """PDF под паролем (задача 13.12) читается пометкой, а не роняет чтение выдачи и аудит.""" def test_a_locked_pdf_reads_as_a_mark(self): from pypdf import PdfWriter import extract writer = PdfWriter() writer.add_blank_page(width=200, height=200) writer.encrypt(user_password="Akt-2026") with tempfile.TemporaryDirectory() as folder: path = Path(folder) / "акт.pdf" with open(path, "wb") as stream: writer.write(stream) self.assertIn("под паролем", extract.extract(path)) if __name__ == "__main__": unittest.main()