Datasets:

synaptex
/

workpermit

"""Проверки кода оценки без модели: календарь сверки, повторы обращения к судье, сверка при обрыве ответа, вопрос в любом
ходе, вопросы системы с ответами человека для судьи, вопросы вне сценария в отчёте, критические пункты рубрики, сверка
цитат судьи с выдачей (и именем выданного файла), разметка выделения в сравнении, запись чисел (черта между числами, условный
знак величины), число рядом с тем, что оно считает, ответ на каждое сообщение задачи из нескольких сообщений и задача,
которую система не запускала.

    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()