// Кусок 1 — единственная точка входа затеи, и до этой правки у неё не было ни одной // проверки. Главная причина, зачем этот файл вообще существует, названа в О-1: путь // к письму (`cmd === 'mail'`) раньше падал МОЛЧА при сбое ДО самой отправки — сводка // не строилась или транспорт не собирался, — и `mail-failures.jsonl` не получал строки. // Владелец утром видел тишину, а тишину он не отличит от «всё хорошо». // // 🔴 Настоящих писем эти проверки не шлют, настоящих баз не заводят, платного помощника // не рождают и в сеть не ходят — везде подставные `transport`/`sweep`/`readConfig` и // временный каталог вместо `.night/`. В этом рабочем углу `.night/` уже живёт (второй // правщик держит там свой прогон) — проверки его не трогают ни разу. import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'; import { mkdtempSync, rmSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'; import { tmpdir } from 'node:os'; import { dirname, join } from 'node:path'; import { fileURLToPath } from 'node:url'; import { main, runMailCommand, collectSummary, runningRuns, idushchieProgony } from './cli.mjs'; import { readLines } from './state.mjs'; import { razborDovodov, zamerDovody, vhodVorot, strokiOtkaza, odinVid } from './cli-parts.mjs'; // 🔴 Кусок 3, задача 6. `startGates` — НАСТОЯЩИЕ ворота: числа идут в них не рукой, // а через `vhodVorot`. `odinVidPuti` — общая мелочь про пути (задача 2, `paths.mjs`), // ввозится ради одной проверки: что она и `odinVid` куска 2 отвечают одинаково. import { startGates } from './gates.mjs'; import { odinVidPuti } from './paths.mjs'; let dir, failPath, sentPath; beforeEach(() => { dir = mkdtempSync(join(tmpdir(), 'night-cli-')); failPath = join(dir, 'mail-failures.jsonl'); sentPath = join(dir, 'last-summary.json'); }); afterEach(() => { rmSync(dir, { recursive: true, force: true }); }); const FAKE_CFG = { mail: { host: 'h', port: 587, user: 'u', pass: 'p', from: 'robot@liderra.ru', to: 'owner@example.com' } }; const OK_TRANSPORT = { sendMail: async () => ({ messageId: '1' }) }; const OK_SUMMARY = { subject: 'с', text: 'т' }; const noopSweep = () => []; const okBuild = () => OK_SUMMARY; describe('main — общий разбор команды', () => { it('О-2: настроек нет — понятный отказ и код возврата, отличный от успеха', async () => { const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); const code = await main(['node', 'cli.mjs', 'summary'], { readConfig: () => null }); expect(code).not.toBe(0); expect(errSpy).toHaveBeenCalledWith(expect.stringMatching(/настроек нет/i)); errSpy.mockRestore(); }); it('О-2: неизвестная команда — понятный отказ и код возврата, отличный от успеха', async () => { const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); const code = await main(['node', 'cli.mjs', 'полетели-в-космос'], { readConfig: () => FAKE_CFG }); expect(code).not.toBe(0); expect(errSpy).toHaveBeenCalledWith(expect.stringMatching(/неизвестная команда/i)); errSpy.mockRestore(); }); it('команду не назвали вовсе — тот же честный отказ, а не падение', async () => { const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); const code = await main(['node', 'cli.mjs'], { readConfig: () => FAKE_CFG }); expect(code).not.toBe(0); errSpy.mockRestore(); }); it('summary — печатает то, что отдала сводка, кодом успеха', async () => { const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); const code = await main(['node', 'cli.mjs', 'summary'], { readConfig: () => FAKE_CFG, summaryOf: () => ({ text: 'Сводка за сегодня' }), sweep: () => [], }); expect(code).toBe(0); expect(logSpy).toHaveBeenCalledWith('Сводка за сегодня'); logSpy.mockRestore(); }); it('mail — успех передаётся наружу кодом 0 и словом об успехе', async () => { const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); const code = await main(['node', 'cli.mjs', 'mail'], { readConfig: () => FAKE_CFG, runMail: async () => ({ ok: true }), }); expect(code).toBe(0); expect(logSpy).toHaveBeenCalledWith('Сводка отправлена.'); logSpy.mockRestore(); }); it('mail — неудача передаётся наружу кодом, отличным от успеха, и словом о неудаче', async () => { const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {}); const code = await main(['node', 'cli.mjs', 'mail'], { readConfig: () => FAKE_CFG, runMail: async () => ({ ok: false, error: 'транспорт не собрался' }), }); expect(code).not.toBe(0); expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('транспорт не собрался')); logSpy.mockRestore(); }); }); describe('collectSummary — О-2: сводка на пустом месте не молчит', () => { it('прогона не было (нет last-run) — сводка всё равно есть и так и говорит', () => { const s = collectSummary(FAKE_CFG, [], { readLastRun: () => null, readSummaryLines: () => [] }); expect(s.text).toMatch(/прогона не было/i); }); it('строки сводки читаются, только когда есть run_id', () => { const readSummaryLines = vi.fn(() => ['строка']); collectSummary(FAKE_CFG, [], { readLastRun: () => null, readSummaryLines }); expect(readSummaryLines).not.toHaveBeenCalled(); }); }); describe('runMailCommand — О-1: любой сбой на пути к письму записывается', () => { it('дошли до отправки, транспорт настоящий — письмо уходит, неудачи нет', async () => { const r = await runMailCommand({ cfg: FAKE_CFG, failPath, sentPath, sweep: noopSweep, buildSummaryLines: okBuild, makeTransport: async () => OK_TRANSPORT, }); expect(r.ok).toBe(true); expect(readLines(failPath)).toEqual([]); }); it('О-1 главная: сборка сводки упала ДО отправки — неудача всё равно легла в mail-failures.jsonl', async () => { const r = await runMailCommand({ cfg: FAKE_CFG, failPath, sentPath, sweep: noopSweep, buildSummaryLines: () => { throw new Error('сводка развалилась'); }, makeTransport: async () => OK_TRANSPORT, }); expect(r.ok).toBe(false); const rows = readLines(failPath); expect(rows.length).toBe(1); expect(rows[0].error).toContain('сводка развалилась'); }); it('О-1 главная: транспорт не собрался — неудача всё равно легла в mail-failures.jsonl', async () => { const r = await runMailCommand({ cfg: FAKE_CFG, failPath, sentPath, sweep: noopSweep, buildSummaryLines: okBuild, makeTransport: async () => { throw new Error('SMTP не отвечает на соединение'); }, }); expect(r.ok).toBe(false); const rows = readLines(failPath); expect(rows.length).toBe(1); expect(rows[0].error).toContain('SMTP не отвечает на соединение'); }); it('О-1 главная: сама уборка старых углов упала — неудача всё равно легла в mail-failures.jsonl', async () => { const r = await runMailCommand({ cfg: FAKE_CFG, failPath, sentPath, sweep: () => { throw new Error('угол не читается'); }, buildSummaryLines: okBuild, makeTransport: async () => OK_TRANSPORT, }); expect(r.ok).toBe(false); expect(readLines(failPath)[0].error).toContain('угол не читается'); }); it('функция не бросает наружу — она возвращает отказ, даже когда всё внутри рухнуло', async () => { await expect(runMailCommand({ cfg: FAKE_CFG, failPath, sentPath, sweep: noopSweep, buildSummaryLines: () => { throw new Error('x'); }, makeTransport: async () => OK_TRANSPORT, })).resolves.toBeTruthy(); }); it('писать свою неудачу тоже не вышло — всё равно не бросает и сказано об этом (unrecorded)', async () => { const badPath = join(dir, 'занято-каталогом'); mkdirSync(badPath, { recursive: true }); const r = await runMailCommand({ cfg: FAKE_CFG, failPath: badPath, sentPath, sweep: noopSweep, buildSummaryLines: () => { throw new Error('сводка развалилась'); }, makeTransport: async () => OK_TRANSPORT, }); expect(r.ok).toBe(false); expect(r.error).toContain('сводка развалилась'); expect(r.unrecorded).toBeTruthy(); }); it('сама отправка (sendMail) упала — это по-прежнему записывает mailer.mjs, здесь ничего не задвоилось', async () => { const r = await runMailCommand({ cfg: FAKE_CFG, failPath, sentPath, sweep: noopSweep, buildSummaryLines: okBuild, makeTransport: async () => ({ sendMail: async () => { throw new Error('SMTP лёг'); } }), }); expect(r.ok).toBe(false); const rows = readLines(failPath); expect(rows.length).toBe(1); // ровно одна строка, а не две от двух ловушек подряд expect(rows[0].error).toContain('SMTP лёг'); }); }); // 🪤 `sweepNow` (обёртка над `sweepStaleWorkspaces` из `workspace.mjs`) здесь НЕ проверяется // напрямую: она зовёт настоящую уборку по настоящему REPO_ROOT этого рабочего угла — а там // уже живёт реальный `.night/` второго правщика. Прогнать её вживую в проверке — риск // тронуть чужие файлы. Проверки самой уборки — в workspace.test.mjs (чужой файл, не мой). // В `main`/`runMailCommand` она всегда вызывается через внедряемый `sweep`, что и проверено выше. // ============ кусок 2: три тихие части точки входа ============ // // 🔴 Правило владельца: решая, писать ли проверку, спрашивать не «важно ли это», а «если // сломается — заметим ли мы сами». Живой запуск ломается ГРОМКО (не запустится ничего) — // он принимается глазами. А эти три вещи ломаются ТИХО и тихо делают не то: // разбор доводов команды, раскладка ответов правил по кормушкам ворот и печать отказа. // // Чужие части подставляем, живьём не зовём: здесь проверяется НЕ то, что правила правы, // а то, что их ответы дошли до ворот целыми и что владельцу сказали правду. const ZAPAS = { may_start: true, renews_on: '2026-08-08', run_share_limit: 1 / 7 }; const MESTO = { ok: true, free_gb: 42.5 }; const PECHAT = { ok: true, seal: { fingerprint: 'aaa' } }; const BUMAGI = { ok: true }; const ZAMYSEL = { ok: true }; const CFG = { base_branch: 'feat/night', probe_model: 'haiku', rate_limit_type: 'seven_day', max_tasks_at_once: 2, max_workers_per_task: 7, }; function argvFor(...rest) { return ['node', 'tools/night/cli.mjs', ...rest]; } describe('часть 1: доводы команды доходят до неё теми же, какими их набрали', () => { it('run: три пути ложатся каждый в своё поле, а не путаются местами', () => { const d = razborDovodov(argvFor('run', 'docs/plan.md', '--priyomka', 'docs/priyomka.md', '--spec', 'docs/spec.md')); expect(d.planPath).toBe('docs/plan.md'); expect(d.priyomkaPath).toBe('docs/priyomka.md'); expect(d.specPath).toBe('docs/spec.md'); expect(d.error).toBeUndefined(); }); it('run: ключи набраны в другом порядке — поля всё равно свои', () => { const d = razborDovodov(argvFor('run', 'docs/plan.md', '--spec', 'docs/spec.md', '--priyomka', 'docs/priyomka.md')); expect(d.priyomkaPath).toBe('docs/priyomka.md'); expect(d.specPath).toBe('docs/spec.md'); }); it('run: обратные косые Windows приводятся к одному виду', () => { // 🪤 Владелец копирует путь из окна Windows. Подай его как набран — хранилище ответит // «нет такой бумаги», и владелец получит отказ по причине, которой нет. const d = razborDovodov(argvFor('run', 'docs\\superpowers\\plans\\plan.md', '--priyomka', '.\\docs\\p.md', '--spec', 'docs\\s.md')); expect(d.planPath).toBe('docs/superpowers/plans/plan.md'); expect(d.priyomkaPath).toBe('docs/p.md'); expect(d.specPath).toBe('docs/s.md'); }); it('run: не назван приёмочный лист — понятный отказ с образцом команды, а не молчание', () => { const d = razborDovodov(argvFor('run', 'docs/plan.md', '--spec', 'docs/spec.md')); expect(d.error).toContain('--priyomka'); expect(d.error).toContain('--spec'); expect(d.planPath).toBeUndefined(); }); it('run: не назван план — понятный отказ, и ключ --spec планом НЕ становится', () => { const d = razborDovodov(argvFor('run', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md')); expect(d.error).toContain('node tools/night/cli.mjs run'); }); it('seal: путь плана берётся из довода', () => { expect(razborDovodov(argvFor('seal', 'docs/plan.md')).planPath).toBe('docs/plan.md'); }); it('seal: путь не назван — понятный отказ с образцом, а не молчание', () => { const d = razborDovodov(argvFor('seal')); expect(d.error).toContain('seal <путь-к-плану>'); expect(d.planPath).toBeUndefined(); }); it('approve-spec: бумага и ВСЕ названные рецензенты доходят до отметки', () => { // 🔴 Рецензентов называют дважды. Возьми разбор только последнего — отметка выйдет // с одним именем, ворота замысла откажут, а причина будет непонятной. const d = razborDovodov(argvFor('approve-spec', 'docs/spec.md', '--reviewer', 'Пётр', '--reviewer', 'Анна')); expect(d.specPath).toBe('docs/spec.md'); expect(d.reviewers).toEqual(['Пётр', 'Анна']); }); it('approve-spec: бумага не названа — понятный отказ с образцом', () => { expect(razborDovodov(argvFor('approve-spec', '--reviewer', 'Пётр')).error).toContain('--reviewer'); }); it('budget: голова замера берётся из настройки probe_model, зашитого слова нет', () => { expect(zamerDovody({ ...CFG, probe_model: 'самая-дешёвая' }).model).toBe('самая-дешёвая'); }); it('budget: настройки probe_model нет — головы нет, и подставлять её нечем', () => { // Умолчания нет намеренно: пусть замер откажется понятной строкой с именем настройки, // а не сходит за деньги владельца чужой головой. expect(zamerDovody({ ...CFG, probe_model: undefined }).model).toBeUndefined(); }); it('🔴 budget: вид предела берётся ИЗ НАСТРОЙКИ, а нет строки — отказ с её именем', () => { // 🔴🔴 ЭТА ПРОВЕРКА СТОРОЖИЛА МИНУ. Прежде вторая её строка требовала обратного: // «нет строки в настройках — ВСЁ РАВНО недельный». Замерено живьём 03.08.2026: этому // счёту приходит `five_hour`, недельного события не приходило ни разу — то есть молчаливое // умолчание заставляло ворота ждать запас, которого не бывает, и они не пропустили // ни одного прогона за всю жизнь затеи. Владелец при этом читал «события от системы // не пришло», хотя оно приходило каждый раз. // Теперь умолчания нет нигде: потеряна настройка — отказ, и в нём её имя. expect(zamerDovody({ ...CFG, rate_limit_type: 'five_hour' }).kind).toBe('five_hour'); expect(() => zamerDovody({ ...CFG, rate_limit_type: undefined })).toThrow(/rate_limit_type/); }); }); describe('часть 2: воротам поданы ВСЕ девять ответов, а не часть', () => { const running = [ { run_id: 'r-1', status: 'running', workers: ['w-1', 'w-2'], items: [{ id: '1', files: ['app/A.php'] }] }, { run_id: 'r-2', status: 'running', workers: ['w-3'], items: [{ id: '2', files: ['app/B.php'] }] }, ]; const vhod = () => vhodVorot({ cfg: CFG, items: [{ id: '1' }], budget: ZAPAS, disk: MESTO, planSeal: PECHAT, papers: BUMAGI, spec: ZAMYSEL, running, }); it('во входе есть все девять кормушек ворот — поимённо', () => { // 🔴 Порядок ворот: запас · отклик владельца · место · замысел · бумаги · отпечаток · // от прошлого прогона никого · потолки · пересечение файлов. const v = vhod(); for (const pole of ['budget', 'owner', 'disk', 'spec', 'papers', 'planSeal', 'previousWorkers', 'capacity', 'newTaskFiles', 'runningTasksFiles']) { expect(v).toHaveProperty(pole); } }); it('ответы правил доходят до ворот ТЕМИ ЖЕ, какими пришли', () => { // 🔴 Тихая беда: положи ответ запаса в поле места — ворота места прочтут `may_start`, // не найдут `ok`, откажут, и владелец пойдёт чистить диск вместо ожидания запаса. const v = vhod(); expect(v.budget).toBe(ZAPAS); expect(v.disk).toBe(MESTO); expect(v.planSeal).toBe(PECHAT); expect(v.papers).toBe(BUMAGI); expect(v.spec).toBe(ZAMYSEL); }); it('ветка отсчёта и пункты берутся из настроек и из разбора плана', () => { const v = vhod(); expect(v.base_branch).toBe('feat/night'); expect(v.items).toEqual([{ id: '1' }]); }); it('число идущих прогонов настоящее, а не ноль', () => { expect(vhod().capacity.tasks_running).toBe(2); }); it('число работников в работе берётся из карточек прогонов, а не выдумывается', () => { // 🔴 Состав прогона пишет кусок 1 (`startAll` кладёт `workers` в `run.json`) — заводить // это поле заново не надо, его надо сложить. Ноль здесь означал бы «никого нет», // и ворота потолков пропустили бы восьмого работника. // // 🔴 ПОПРАВЛЕНО КУСКОМ 3 (задача 6) И НАЗВАНО ВСЛУХ. Проверка не выброшена и число // в ней то же — 3, — но вход стал честнее. Кусок 2 складывал работников ВСЕХ идущих // прогонов и на этом входе получал 3 (2+1). Проверка 27 говорит «внутри ЗАДАЧИ», // поэтому счёт теперь идёт по своей задаче плюс те, кого просят завести: у задачи `r-1` // своих двое, просят одного — трое. Не назови мы задачу, вышла бы единица, и это было // бы верно: чужих работников в свой потолок не берут. Место, где кусок 3 имел право // тронуть чужую проверку, план назвал только одно (`gates.test.mjs`) — вот второе, // и его пропустили: старый ответ сторожил ровно то правило, которое кусок 3 заменяет. const v = vhodVorot({ cfg: CFG, items: [{ id: '1' }], budget: ZAPAS, disk: MESTO, planSeal: PECHAT, papers: BUMAGI, spec: ZAMYSEL, running, taskId: 'r-1', }); expect(v.capacity.workers_in_task).toBe(3); }); it('карточка прогона без состава — считается ноль работников, а не обвал', () => { const v = vhodVorot({ cfg: CFG, budget: ZAPAS, disk: MESTO, running: [{ run_id: 'r-1' }] }); expect(v.capacity.workers_in_task).toBe(0); expect(v.capacity.tasks_running).toBe(1); }); it('потолки берутся из настроек владельца', () => { const v = vhodVorot({ cfg: { ...CFG, max_tasks_at_once: 1, max_workers_per_task: 3 }, running: [] }); expect(v.capacity.max_tasks).toBe(1); expect(v.capacity.max_workers).toBe(3); }); it('занятые файлы идущих прогонов подаются воротам пересечения', () => { expect(vhod().runningTasksFiles).toEqual([['app/A.php'], ['app/B.php']]); }); it('четверо ненаписанных ворот получают ПУСТОЕ, а не выдуманное', () => { // Их правила пишут куски 3 и 7. Пустое значение — это честное «сказать нечего»; // выдуманное «всё хорошо» было бы враньём, которое никто потом не найдёт. const v = vhod(); expect(v.owner).toEqual({ last_summary_at: null }); expect(v.previousWorkers).toEqual([]); expect(v.newTaskFiles).toEqual([]); }); }); describe('часть 3: в отказе владельцу названы ворота и человеческая причина', () => { it('названы ИМЕНА непройденных ворот и причины словами', () => { const stroki = strokiOtkaza({ ok: false, reason: 'Запас кончился.', failed_gates: [{ gate: 'запас', reason: 'Запас кончился.' }], }); expect(stroki.join('\n')).toContain('запас'); expect(stroki.join('\n')).toContain('Запас кончился.'); }); it('непройденных двое — названы ОБА, а не только первые', () => { // Починив одно и упёршись во второе, владелец потерял бы ночь. const stroki = strokiOtkaza({ ok: false, reason: 'Запас кончился.', failed_gates: [ { gate: 'запас', reason: 'Запас кончился.' }, { gate: 'бумаги сохранены', reason: 'Не сохранено: docs/plan.md' }, ], }); const t = stroki.join('\n'); expect(t).toContain('запас'); expect(t).toContain('бумаги сохранены'); expect(t).toContain('docs/plan.md'); }); it('в отказе НЕТ месива: ни [object Object], ни склеенной строки all_reasons', () => { // 🔴 Ровно на этом шве уже ломалось: `failed` — это ПАРЫ, а не строки. Разбери // кто-нибудь `all_reasons` — владелец получит «запас: запас: Запас кончился.». const t = strokiOtkaza({ ok: false, reason: 'Запас кончился.', failed_gates: [{ gate: 'запас', reason: 'Запас кончился.' }], all_reasons: ['запас: Запас кончился.'], }).join('\n'); expect(t).not.toContain('[object Object]'); expect(t).not.toContain('запас: запас'); }); it('отказ есть, а имён ворот не дали — печатается общая причина, а не пустота', () => { const t = strokiOtkaza({ ok: false, reason: 'Что-то пошло не так.', failed_gates: [] }).join('\n'); expect(t).toContain('Что-то пошло не так.'); }); it('запас кончился — сказано, КОГДА станет можно', () => { const t = strokiOtkaza( { ok: false, reason: 'Запас кончился.', failed_gates: [{ gate: 'запас', reason: 'Запас кончился.' }] }, { renews_on: '2026-08-08' }, ).join('\n'); expect(t).toContain('2026-08-08'); }); it('🔴 дня обновления назвать не смогли — печатается ПРИЧИНА, а не пустое место', () => { // Прежде строка про запас печаталась только при `renews_on`. Сбой прибора (день пуст, // день в прошлом, число не в миллисекундах) не давал НИ ОДНОЙ строки, и владелец читал // это как «ещё не считали». Слова сбоя готовит budget.mjs — здесь их обязаны донести. const t = strokiOtkaza( { ok: false, reason: 'Запас кончился.', failed_gates: [{ gate: 'запас', reason: 'Запас кончился.' }] }, { renews_on: null, renews_on_problem: 'прибор не назвал день обновления запаса вовсе (resets_at пуст)' }, ).join('\n'); expect(t).toContain('сказать не удалось'); expect(t).toContain('resets_at пуст'); }); it('день назвали — печатается день, а причина сбоя не примешивается', () => { const t = strokiOtkaza( { ok: false, reason: 'Запас кончился.', failed_gates: [{ gate: 'запас', reason: 'Запас кончился.' }] }, { renews_on: '2026-08-08', renews_on_problem: null }, ).join('\n'); expect(t).toContain('2026-08-08'); expect(t).not.toContain('сказать не удалось'); }); it('про запас не сказано ничего вовсе — лишней строки не появляется', () => { // Отказ бывает не по запасу: тогда молчать про запас правильно. const t = strokiOtkaza( { ok: false, reason: 'Место кончилось.', failed_gates: [{ gate: 'место', reason: 'Место кончилось.' }] }, { renews_on: null, renews_on_problem: null }, ).join('\n'); expect(t).not.toContain('недельный запас'); expect(t).not.toContain('Недельный запас'); }); it('ворота пройдены — печатать нечего вовсе', () => { // Без этой проверки печать могла бы работать всегда, и владелец получал бы // «Прогон НЕ запущен» в ночь, когда прогон как раз запустился. expect(strokiOtkaza({ ok: true, failed_gates: [] })).toEqual([]); }); }); // ============ блок 4: точка входа не оставлена звать удалённые имена ============ // 🔴 Зачем он. `cli.mjs` в проверки ввозится только тремя своими функциями, а сам разбор // команд ими не покрыт — это решение владельца: живой запуск ломается громко. Но один // класс поломки здесь как раз тихий: правка убирает из файла объявление, а зов остаётся. // Такой файл падает не при загрузке, а позже — внутри той команды, куда в тот вечер никто // не заглянул. Сторож не запускает точку входа и не проверяет её поведение: он читает её // как текст и смотрит, что каждое зовомое имя откуда-то взято. // // 🔴 Список известных имён намеренно ЩЕДРЫЙ — в него идут и доводы функций. Пусть сторож // пропустит спорное, зато не покраснеет зря: сторож, который врёт красным, отключают первым. // Совсем оторванное имя вроде `odinVid` он ловит всё равно — это доказано вырезанием. const OT_SISTEMY = new Set([ 'if', 'for', 'while', 'switch', 'catch', 'function', 'return', 'typeof', 'else', 'do', 'await', 'async', 'new', 'delete', 'void', 'throw', 'case', 'try', 'in', 'of', 'instanceof', 'String', 'Number', 'Boolean', 'Object', 'Array', 'JSON', 'Date', 'Math', 'Set', 'Map', 'Promise', 'Error', 'RegExp', 'console', 'process', 'parseInt', 'parseFloat', 'isNaN', 'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'require', 'import', 'super', ]); // Убрать примечания и тексты для владельца: слова из них — не зовы. function tolkoKod(text) { return text .replace(/\/\*[\s\S]*?\*\//g, ' ') .replace(/\/\/[^\n]*/g, ' ') .replace(/`(?:\\[\s\S]|[^`\\])*`/g, '``') .replace(/'(?:\\[\s\S]|[^'\\])*'/g, "''") .replace(/"(?:\\[\s\S]|[^"\\])*"/g, '""'); } function imenaKotorykhFayluHvataet(kod) { const est = new Set(OT_SISTEMY); // 🔴 ПОПРАВЛЕНО ПРОТИВ ПЛАНА, вслух. В плане `dobav` стирал из куска ВСЕ не-буквы // и добавлял остаток целиком. На куске `readConfig = () => readJson(configPath())` // это давало слипшийся мусор `readConfigreadJsonconfigPath`, а само имя `readConfig` // так и оставалось «ниоткуда» — сторож краснел бы на здоровом файле. Берём ПЕРВОЕ имя // куска: оно и есть объявляемое. У ввоза с переименованием (`x as y`) имя даёт правая часть. const dobav = s => { const chistoe = String(s).replace(/^[\s{[(]+/, '').split(/\s+as\s+/).pop(); const m = String(chistoe).trim().match(/^[\w$]+/); if (m) est.add(m[0]); }; for (const m of kod.matchAll(/import\s*\{([^}]*)\}\s*from/g)) m[1].split(',').forEach(dobav); for (const m of kod.matchAll(/import\s+([\w$]+)\s*(?:,|from)/g)) dobav(m[1]); for (const m of kod.matchAll(/(?:function|class)\s+([\w$]+)/g)) dobav(m[1]); for (const m of kod.matchAll(/(?:const|let|var)\s+([\w$]+)/g)) dobav(m[1]); for (const m of kod.matchAll(/(?:const|let|var)\s*\{([^}]*)\}/g)) m[1].split(',').forEach(dobav); // Доводы функций — тоже имена, которые у файла есть. for (const m of kod.matchAll(/function\s*[\w$]*\s*\(([^)]*)\)/g)) m[1].split(',').forEach(dobav); // 🔴 ВТОРАЯ ПОПРАВКА ПРОТИВ ПЛАНА. Доводы, разобранные прямо в скобках с пустым // умолчанием — `function f({ a, b = c() } = {}) {` — прежней строкой не ловились вовсе: // она обрывалась на первой же закрывающей скобке внутри (`mailFailuresPath()`), и семь // доводов `runMailCommand` оставались «ниоткуда». // 🪤 Один вложенный слой фигурных скобок внутри доводов разрешён намеренно: умолчание // вида `x = async e => f(e, { disk: await g() })` иначе обрывает разбор на середине, // и остаток доводов снова становится «ниоткуда». На этом сторож уже краснел живьём. for (const m of kod.matchAll(/\{((?:[^{}]|\{[^{}]*\})*)\}\s*=\s*\{\s*\}\s*\)/g)) m[1].split(',').forEach(dobav); for (const m of kod.matchAll(/\(([^()]*)\)\s*=>/g)) m[1].split(',').forEach(dobav); for (const m of kod.matchAll(/([\w$]+)\s*=>/g)) dobav(m[1]); return est; } describe('часть 4: точка входа не зовёт имён, которых у неё нет', () => { it('каждое имя, которое зовёт `cli.mjs`, либо ввезено, либо объявлено в нём же', () => { const kod = tolkoKod(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'cli.mjs'), 'utf8')); const est = imenaKotorykhFayluHvataet(kod); const bezymyannye = []; for (const m of kod.matchAll(/(? { it('newTaskFiles — настоящие файлы пунктов нового прогона, а не пустой список', () => { // 🔴 Место, размеченное куском 2 словами «пусто, и это твоё». Пустой список означал бы, // что ворота пересечения не держат никогда: правило без пищи пропускает всё. const v = vhodVorot({ cfg: NASTROYKI, running: IDUT, taskId: null, items: [{ id: '1', files: ['app/A.php'] }, { id: '2', files: ['app/C.php'] }], }); expect(v.newTaskFiles).toEqual(['app/A.php', 'app/C.php']); }); it('пунктов без файлов — список пустой, а не выдуманный', () => { const v = vhodVorot({ cfg: NASTROYKI, running: [], items: [{ id: '1' }] }); expect(v.newTaskFiles).toEqual([]); // 🔴 УСИЛЕНО ПРОТИВ ПЛАНА, вслух. В плане у этой проверки было только утверждение выше, // и в красной поре она была ЗЕЛЁНОЙ: пустоты ждали, пустота там и стояла. Зелёная // в красной поре не сторожит ничего. Вторая половина краснеет честно: пункт без файлов // обязан пропасть из списка, а пункт с файлами — остаться. Свались они в одно // (`items.map(i => i.files)`), в списке оказалось бы `undefined` — и ворота пересечения // спотыкались бы о него на ровном месте. const smeshanno = vhodVorot({ cfg: NASTROYKI, running: [], items: [{ id: '1' }, { id: '2', files: ['app/A.php'] }], }); expect(smeshanno.newTaskFiles).toEqual(['app/A.php']); }); it('workers_in_task — идущие работники СВОЕЙ задачи плюс те, кого просят завести', () => { // 🔴 Считай мы только идущих — потолок стерёг бы уже начатое и пропустил бы восьмого. // Своих у задачи `z-1` двое, просят завести ещё двоих — станет четверо, а не трое // (трое — это ответ куска 2, который складывал работников ВСЕХ идущих прогонов). const v = vhodVorot({ cfg: NASTROYKI, running: IDUT, taskId: 'z-1', items: [{ id: '9', files: ['app/D.php'] }, { id: '10', files: ['app/E.php'] }], }); expect(v.capacity.workers_in_task).toBe(4); }); it('работники ЧУЖОЙ задачи в этот счёт не идут', () => { // Иначе потолок «семь работников внутри задачи» превратился бы в «семь на весь сервер», // и вторая задача не запустилась бы никогда. const v = vhodVorot({ cfg: NASTROYKI, running: IDUT, taskId: 'z-2', items: [{ id: '9' }] }); expect(v.capacity.workers_in_task).toBe(2); }); it('tasks_running считает ЗАДАЧИ, а не прогоны', () => { const dvaProgonaOdnoyZadachi = [ { run_id: 'r-1', status: 'running', task_id: 'z-1', workers: ['w-1'], items: [] }, { run_id: 'r-2', status: 'running', task_id: 'z-1', workers: ['w-2'], items: [] }, ]; const v = vhodVorot({ cfg: NASTROYKI, running: dvaProgonaOdnoyZadachi, taskId: null, items: [] }); expect(v.capacity.tasks_running).toBe(1); }); it('своя задача третьей не считается', () => { // Продолжение уже идущей задачи новую задачу не заводит — иначе потолок «две задачи» // запретил бы доводить до конца то, что уже начато. const v = vhodVorot({ cfg: NASTROYKI, running: IDUT, taskId: 'z-1', items: [] }); expect(v.capacity.tasks_running).toBe(1); }); it('runningTasksFiles не включает файлы СВОЕЙ задачи', () => { // Иначе задача пересекалась бы сама с собой и не запускалась бы никогда. const v = vhodVorot({ cfg: NASTROYKI, running: IDUT, taskId: 'z-1', items: [] }); expect(v.runningTasksFiles).toEqual([['app/B.php']]); }); }); describe('часть 6: НАСТОЯЩИЕ ворота на этих числах отказывают и пропускают', () => { const ostalnoe = { budget: ZAPAS, disk: MESTO, planSeal: PECHAT, papers: BUMAGI, spec: ZAMYSEL, }; it('восьмой работник внутри задачи — отказ (проверка 27)', () => { const semero = [{ run_id: 'r-1', status: 'running', task_id: 'z-1', workers: ['w-1', 'w-2', 'w-3', 'w-4', 'w-5', 'w-6', 'w-7'], items: [] }]; const r = startGates(vhodVorot({ cfg: NASTROYKI, ...ostalnoe, running: semero, taskId: 'z-1', items: [{ id: '8', files: ['app/Z.php'] }], })); expect(r.ok).toBe(false); expect(r.failed.map(f => f.gate)).toContain('потолки задач и работников'); }); it('🔴 ГРАНИЦА: шестеро идут, просят седьмого — ПУСКАЮТ (проверка 46)', () => { // 🔴🔴 Шов между задачей 2 и этой. `vhodVorot` подаёт «сколько СТАНЕТ»: шестеро идут // плюс один просимый — семь. Правило задачи 2 сравнивает строго (`> 7`), поэтому // семеро проходят. Стоял бы там `>=`, как в первом наброске, — эта проверка // покраснела бы, а семеро одной задачи не собрались бы никогда, и проверку 46 // бумаги («семеро работников одной задачи шли разом») показать было бы нечем. // Проверка ЖИВОГО пути: числа идут не рукой, а через `vhodVorot`. const shestero = [{ run_id: 'r-1', status: 'running', task_id: 'z-1', workers: ['w-1', 'w-2', 'w-3', 'w-4', 'w-5', 'w-6'], items: [] }]; const r = startGates(vhodVorot({ cfg: NASTROYKI, ...ostalnoe, running: shestero, taskId: 'z-1', items: [{ id: '7', files: ['app/Z.php'] }], })); expect(r.ok).toBe(true); expect(r.failed).toEqual([]); }); it('третья задача — отказ, а продолжение уже идущей — пропуск (проверка 26)', () => { const r = startGates(vhodVorot({ cfg: NASTROYKI, ...ostalnoe, running: IDUT, taskId: 'z-3', items: [{ id: '1', files: ['app/Z.php'] }], })); expect(r.ok).toBe(false); expect(r.failed.map(f => f.gate)).toContain('потолки задач и работников'); // 🔴 УСИЛЕНО ПРОТИВ ПЛАНА, вслух. План сам признал, что в красной поре эта проверка // ЗЕЛЁНАЯ: кусок 2 складывал прогоны и на этом входе случайно давал тот же ответ. // Зелёная в красной поре не сторожит ничего, поэтому здесь же стоит её зеркало — // тот же вход, но задача СВОЯ. Отличить «третья» от «продолжение начатого» кусок 2 // не умел вовсе, и зеркало краснеет честно. const svoya = startGates(vhodVorot({ cfg: NASTROYKI, ...ostalnoe, running: IDUT, taskId: 'z-1', items: [{ id: '1', files: ['app/Z.php'] }], })); expect(svoya.ok).toBe(true); }); it('новая задача задевает файл идущей — отказ, и файл назван (проверка 50)', () => { const r = startGates(vhodVorot({ cfg: { ...NASTROYKI, max_tasks_at_once: 9 }, ...ostalnoe, running: IDUT, taskId: 'z-3', items: [{ id: '1', files: ['app/A.php'] }], })); expect(r.ok).toBe(false); expect(r.failed.map(f => f.gate)).toContain('задачи не пересекаются по файлам'); expect(r.all_reasons.join(' ')).toContain('app/A.php'); }); it('вторая задача своими файлами — ворота пропускают: они не глухие', () => { // 🔴 Страховка. Ворота, которые не пропускают НИКОГДА, зеленят три проверки выше // и убивают затею целиком: ночь не запустится ни разу, а причина будет выглядеть верной. const r = startGates(vhodVorot({ cfg: NASTROYKI, ...ostalnoe, running: [IDUT[0]], taskId: 'z-3', items: [{ id: '1', files: ['app/Z.php'] }], })); expect(r.ok).toBe(true); expect(r.failed).toEqual([]); }); }); describe('часть 7: два новых ключа команды run и правда про несторожащие ворота', () => { it('--task и --files доходят до разбора доводов', () => { const d = razborDovodov(argvFor( 'run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md', '--task', 'z-1', '--files', 'app/A.php, app\\B.php', )); expect(d.taskId).toBe('z-1'); expect(d.files).toEqual(['app/A.php', 'app/B.php']); }); it('🔴 `odinVid` куска 2 и `odinVidPuti` куска 3 отвечают ОДИНАКОВО', () => { // 🔴🔴 Две мелочи делают одну работу — сведение имени файла к одному виду. Разойдись // они хоть в одном знаке, и ключ `--files` дал бы одно имя, а замок и ворота ждали бы // другое: пересечения не находились бы, и все проверки остались бы зелёными. // Свести их в одну совсем нельзя: `odinVid` куска 2 зовут и другие его места, а кусок 3 // чужое не переписывает. Значит их СВЕРЯЕМ — вот здесь. for (const obrazets of ['app\\A.php', './app/A.php', 'app//A.php', ' app/A.php ', 'docs\\a\\b.md', '']) { expect(odinVid(obrazets)).toBe(odinVidPuti(obrazets)); } }); it('ключей не назвали — файлов нет и задача новая, а не выдуманные значения', () => { const d = razborDovodov(argvFor('run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md')); expect(d.files).toEqual([]); expect(d.taskId).toBeNull(); }); it('строка «эти ворота пока НЕ сторожат» потеряла двоих', () => { // 🪤 Тихая поломка: ворота начали сторожить, а владельцу в сводке по-прежнему пишут, // что они пропускают всё. Он читает неправду и не узнает об этом никогда. const spisok = TEKST_CLI.match(/VOROTA_POKA_NE_STOROZHAT = \[([\s\S]*?)\]/)[1]; expect(spisok).toContain('отклик владельца'); expect(spisok).toContain('от прошлого прогона никого'); expect(spisok).not.toContain('потолки задач и работников'); expect(spisok).not.toContain('задачи не пересекаются по файлам'); }); it('🔴 СВЕРХ ПЛАНА: несторожащих ворот названо владельцу РОВНО столько, сколько пустышек в самих воротах', () => { // 🔴 Сторож на КЛАСС, а не на место: «ворота начали сторожить, а владельцу про них // по-прежнему пишут „пропускают всё"». Проверка выше сторожит ровно сегодняшних двоих // поимённо — то есть ровно сегодняшний день. Эта переживёт кусок 7: подставит он // `ownerResponded` вместо пустышки и забудет вычеркнуть строку у владельца — // покраснеет здесь. const pustyshek = (TEKST_VOROT.match(/notYetWritten\(\),/g) ?? []).length; const nazvano = TEKST_CLI.match(/VOROTA_POKA_NE_STOROZHAT = \[([\s\S]*?)\]/)[1] .split('\n').filter(s => /['«][а-яё]/i.test(s)).length; expect(nazvano).toBe(pustyshek); }); it('🔴 СВЕРХ ПЛАНА: точка входа вправду ПОДАЁТ воротам номер задачи и настоящие файлы', () => { // 🔴 Сторож на КЛАСС «правило написано, а зовущего нет» — ровно тот, ради которого // весь этот кусок и затеян. Разбор доводов и `vhodVorot` проверены выше поодиночке, // но между ними стоит `cli.mjs`, чьи команды проверками не покрыты намеренно (живой // запуск ломается громко). Убери кто-нибудь `taskId` из зова ворот или верни // `files: []` единственному пункту — обе половины останутся зелёными, а ночь молча // вернётся к «ворота пересечения не держат никогда». Поэтому смотрим текстом. const zovVorot = TEKST_CLI.match(/planRun\(vhodVorot\(\{([\s\S]*?)\}\)\)/)[1]; expect(zovVorot).toContain('taskId'); // 🔴 ПЕРЕНАЦЕЛЕНО КУСКОМ 4, называю вслух. Прежде здесь стояло `files: razbor.files` // у единственного слепленного пункта «весь-план»: до разбора плана файлы называл // владелец рукой ключом `--files`. Куска этого больше нет — файлы каждого пункта // берутся из самого плана. Сторожимое СВОЙСТВО не ослаблено, а усилено: раньше // сторожили «список файлов не пуст», теперь — что воротам идут вправду разобранные // пункты плана. Верни кто-нибудь сюда выдуманный пункт — покраснеет. expect(zovVorot).toMatch(/items:\s*punkty/); expect(TEKST_CLI).toMatch(/punkty\s*=\s*vhodVorot\(\{\s*planPath\s*\}\)\.items/); expect(TEKST_CLI).not.toMatch(/id:\s*'весь-план'/); }); }); // ============ беда 2: порванная карточка прогона снимала ОБА замка разом ============ // // 🔴 Найдено воротами ЖИВЬЁМ: одну запись порвали — и тут же завелась третья задача // при потолке в две, а следом задача на файл, который порванный прогон держит. Оба отказа // исчезли МОЛЧА: список идущих прогонов читался плоским `readJson`, а тот на порванном файле // отдаёт «ничего», и прогон просто выпадал из счёта. // // 🔴 Правило на этот класс в хозяйстве УЖЕ ЕСТЬ и уже применено дважды: `file-claims.mjs` // (замок на файлы) и `plan-lock-hook.mjs` (замок на правку плана) читают через общий прибор // `readJsonOrBroken` и прямо пишут почему — испорченную запись нельзя считать за «никого нет». // Здесь закрывается третья дверь тем же способом, а не выдумывается четвёртый. describe('часть 8: порванная карточка прогона не превращается в «прогона нет»', () => { function razlozhit(kartochki) { const koren = join(dir, 'runs'); for (const [id, tekst] of Object.entries(kartochki)) { mkdirSync(join(koren, id), { recursive: true }); writeFileSync(join(koren, id, 'run.json'), tekst, 'utf8'); } return koren; } const idet = id => JSON.stringify({ run_id: id, status: 'running', task_id: id, workers: ['w-1'], items: [{ id: '1', files: ['app/A.php'] }] }); it('🔴 карточка порвана — счёт идущих прогонов падает ГРОМКО, а не теряет прогон молча', () => { const koren = razlozhit({ 'r-1': idet('r-1'), 'r-2': '{"run_id": "r-2", "status": "runn' }); expect(() => runningRuns(koren)).toThrow(/испорчен|прочесть не удалось|не читается/i); }); it('🔴 в отказе назван ФАЙЛ, который надо посмотреть глазами', () => { const koren = razlozhit({ 'r-2': 'это не JSON вовсе' }); expect(() => runningRuns(koren)).toThrow(/r-2/); }); it('всё цело — идущие считаются, а кончившиеся не считаются (правило не глухое)', () => { const koren = razlozhit({ 'r-1': idet('r-1'), 'r-3': JSON.stringify({ run_id: 'r-3', status: 'finished', workers: ['w-1'] }), }); const idut = runningRuns(koren); expect(idut.map(r => r.run_id)).toEqual(['r-1']); }); it('каталога прогонов нет вовсе — пусто, а не обвал', () => { expect(runningRuns(join(dir, 'такого-каталога-нет'))).toEqual([]); }); it('каталог прогона есть, а карточки в нём нет — это НЕ прогон, и не обвал', () => { mkdirSync(join(dir, 'runs2', 'r-9'), { recursive: true }); expect(runningRuns(join(dir, 'runs2'))).toEqual([]); }); it('🔴 счёт идущих прогонов читает карточки ОБЩИМ прибором, а не плоским readJson', () => { // 🔴 Сторож на КЛАСС, а не на место: «одну дверь закрыли, вторую забыли». Плоский // `readJson` на порванном файле отдаёт `null`, и прогон молча выпадает из счёта. const telo = TEKST_CLI.match(/export function runningRuns\([\s\S]*?\n\}/)[0]; expect(telo).toContain('readRuns'); expect(telo).not.toMatch(/readJson\(/); }); it('🔴 обёртка одна на ОБОИХ зовущих: и `seal`, и `run` спрашивают счёт через неё', () => { // Два try/catch по месту разъехались бы молча: поправят один, забудут другой. expect((TEKST_CLI.match(/idushchieProgony\(\)/g) ?? []).length).toBe(2); expect((TEKST_CLI.match(/runningRuns\(\)/g) ?? []).length).toBe(0); }); it('🔴 обёртка отдаёт владельцу СТРОКУ, а не роняет программу следом стека', () => { const r = idushchieProgony(() => { throw new Error('Карточка прогона r-2 испорчена.'); }); expect(r.ok).toBe(false); expect(r.reason).toContain('r-2'); expect(r.running).toEqual([]); }); it('всё цело — обёртка отдаёт список как есть (не глухая)', () => { const spisok = [{ run_id: 'r-1', status: 'running' }]; const r = idushchieProgony(() => spisok); expect(r.ok).toBe(true); expect(r.running).toBe(spisok); expect(r.reason).toBeNull(); }); }); // ============ кусок 4: план разбирается на пункты, отказы печатаются до замера ============ // // 🔴 ТРИ ОТСТУПЛЕНИЯ ОТ ПЛАНА ЗАДАЧИ 6, НАЗВАННЫЕ ВСЛУХ. План описывал `cli.mjs` таким, // каким тот был два куска назад, и списанные с него проверки сторожили бы пустоту: // 1. План искал в тексте `probeUtilization(` — этого имени в `cli.mjs` НЕТ вовсе, замер // давно идёт через `zamerSoSchyotom` (сторож `platnyy-zamer-tolko-cherez-schyot`). // Проверка «отказ раньше замера» искала бы имя, которого нет, и была бы зелена всегда // и при любом порядке — то есть не сторожила бы ровно того, ради чего написана. // 2. План звал разобранные доводы `dovody`; в файле они зовутся `razbor`. // 3. План велел сторожить «`const running = runningRuns()` объявлен один раз». Такой // строки в `cli.mjs` нет: список идущих берётся через `idushchieProgony()` — обёртку, // которая отличает «никого нет» от «карточка порвана». Переносить её вверх незачем: // разбору плана она не нужна вовсе. Вместо этого сторожим то, что вправду опасно, — // что план читается РОВНО ОДИН раз за запуск. const PLAN_OBRAZETS = [ '# Пример плана', '', '### Task 1: Первый пункт', '', 'Текст пункта.', '', '### Task 2: Второй пункт', '', 'Текст пункта.', ].join('\n'); describe('часть 7: план разбирается на пункты на ВХОДЕ ворот', () => { it('🔴 `vhodVorot` читает файл плана и отдаёт пункты с их проверками и файлами', () => { // 🔴🔴 Здесь снимается долг куска 3, названный им вслух: через `cli.mjs run` больше // одного работника за раз завести было нельзя — ключ `--files` клал все имена // в один пункт. Теперь пункты берутся из плана, и их столько, сколько написал автор. const v = vhodVorot({ cfg: NASTROYKI, running: [], taskId: null, planPath: 'docs/пример.md', readPlan: () => PLAN_OBRAZETS, }); expect(v.items.map(i => i.id)).toEqual(['1', '2']); expect(v.items[0].tests).toEqual(['app/tests/Feature/PervyyTest.php']); expect(v.newTaskFiles).toEqual(['app/A.php', 'app/B.php']); expect(v.items[1].long).toBe(true); }); it('пути плана не дали — пункты берутся из довода, как прежде', () => { // Умолчание честное: своих пунктов `vhodVorot` не выдумывает ни одного. const v = vhodVorot({ cfg: NASTROYKI, running: [], items: [{ id: '9', files: ['app/Z.php'] }] }); expect(v.items.map(i => i.id)).toEqual(['9']); }); it('🔴 пункты из плана идут и в счёт потолка работников, а не только в ответ', () => { // 🪤 СВЕРХ ПЛАНА. В теле `vhodVorot` слово `items` стояло в ТРЁХ местах, и заменить // надо все три. Пропусти третье — `workers_in_task` считал бы пункты, поданные доводом // (то есть ноль), потолок в семь работников не сработал бы НИ РАЗУ, и проверка 27 // отменилась бы молча. Первые два места стерегут проверки выше, третье — эта. const v = vhodVorot({ cfg: NASTROYKI, running: [], taskId: null, planPath: 'docs/пример.md', readPlan: () => PLAN_OBRAZETS, }); expect(v.capacity.workers_in_task).toBe(2); }); }); describe('часть 8: ключи «продолжай» и «список брака»', () => { it('`--continue` разобран как слово владельца', () => { const d = razborDovodov(argvFor( 'run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md', '--continue', )); expect(d.ownerSaidContinue).toBe(true); }); it('`--defects <файл>` разобран в список брака по строкам', () => { const d = razborDovodov( argvFor('run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md', '--defects', 'docs/brak.md'), { readDefects: () => 'кнопка не там\n\nсумма не сходится\n' }, ); expect(d.defectList).toEqual(['кнопка не там', 'сумма не сходится']); }); it('ключей не дали — «продолжай» нет и список брака пуст, а не выдуманы', () => { const d = razborDovodov(argvFor('run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md')); expect(d.ownerSaidContinue).toBe(false); expect(d.defectList).toEqual([]); }); it('🔴 файла со списком брака нет — список ПУСТ, а не выдуман непустым', () => { // 🪤 СВЕРХ ПЛАНА. Непустой список на нечитаемом файле открыл бы ворота задаче, брак // которой никто не назвал: работник пошёл бы переделывать неизвестно что. const d = razborDovodov( argvFor('run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md', '--defects', 'нет-такого-файла.md'), { readDefects: () => { throw new Error('нет такого файла'); } }, ); expect(d.defectList).toEqual([]); expect(d.defectsPath).toBe('нет-такого-файла.md'); }); it('🔴 `--continue` не съедает следующее слово командной строки', () => { // 🪤 СВЕРХ ПЛАНА. Спроси мы `--continue` тем же помощником, что и ключи со значением, // он забрал бы следующее слово — то есть чужой ключ, и `--task` потерялся бы молча. const d = razborDovodov(argvFor( 'run', 'docs/plan.md', '--priyomka', 'docs/p.md', '--spec', 'docs/s.md', '--continue', '--task', 'z-7', )); expect(d.ownerSaidContinue).toBe(true); expect(d.taskId).toBe('z-7'); }); }); // 🔴🔴 СМОТРИМ ТОЛЬКО ТЕЛО КОМАНДЫ `run`, И ЭТО НЕ ПРИДИРКА. Первая моя попытка искала // имена по ВСЕМУ файлу — и сторож молча смотрел не туда: у команды `budget` есть СВОЙ зов // замера, и он стоит в файле выше всей команды `run`. «Отказ раньше замера» сравнивал // отказ из `run` с замером из `budget`, то есть был красным при любом верном порядке // и позеленел бы от перестановки чужой команды. Замерено, а не предположено. const BLOK_RUN = TEKST_CLI.slice( TEKST_CLI.indexOf("if (cmd === 'run') {"), TEKST_CLI.indexOf("if (cmd === 'smoke-longrun') {"), ); describe('часть 9: отказы стоят РАНЬШЕ замера запаса и раньше ворот', () => { it('🔴 кусок текста, по которому судят проверки ниже, вправду вырезан', () => { // 🪤 Без этой строки все проверки порядка ниже стали бы зелёными на ПУСТОЙ строке: // переименуй кто-нибудь команду — и `indexOf` дал бы −1, срез вышел бы пустым, // а `indexOf` в пустой строке равен −1 у всех имён сразу, то есть «порядок сошёлся». expect(BLOK_RUN.length).toBeGreaterThan(2000); expect(BLOK_RUN).toContain("if (cmd === 'run') {"); }); it('🔴 отказ по плану печатается ДО крошечного замера остатка', () => { // 🔴🔴 Замер идёт программой `claude` из подписки, то есть стоит денег. План, который // заведомо не пройдёт, не стоит ни одного платного зова. И только при этом порядке // отказ можно посмотреть живьём глазами: запуск не рождает ни замера, ни угла, // ни живого работника. const iPlan = BLOK_RUN.indexOf('validatePlan('); const iZamer = BLOK_RUN.indexOf('zamerSoSchyotom('); expect(iPlan).toBeGreaterThan(-1); expect(iZamer).toBeGreaterThan(-1); expect(iPlan).toBeLessThan(iZamer); }); it('🔴 ворота отложенной задачи стоят ДО замера и ДО `planRun`', () => { const iSled = BLOK_RUN.indexOf('deferredTaskGate('); const iZamer = BLOK_RUN.indexOf('zamerSoSchyotom('); const iPlanRun = BLOK_RUN.indexOf('planRun('); expect(iSled).toBeGreaterThan(-1); expect(iZamer).toBeGreaterThan(-1); expect(iPlanRun).toBeGreaterThan(-1); expect(iSled).toBeLessThan(iZamer); expect(iSled).toBeLessThan(iPlanRun); }); it('🔴 воротам отложенной задачи подаётся перепроверка плана ИЗ ЭТОГО запуска (проверка 30)', () => { // 🪤 Тихая поломка: подай сюда `true` постоянной — правило зеленело бы, а план // отложенной задачи не перепроверялся бы ни разу, и работник шёл бы по бумаге, // которая за неделю разошлась с продуктом. expect(TEKST_CLI).toMatch(/plan_revalidated:\s*planOk\.ok/); }); it('🔴 `startAll` получает ВСЕ пункты плана, а не только пункты семерых', () => { expect(TEKST_CLI).toMatch(/items:\s*punkty/); }); it('🔴🔴 воротам подан путь плана ИЗ СЛЕДА и путь плана ЭТОГО запуска (проверка 29б)', () => { // 🔴🔴 Правило «тот же план» живёт в воротах, но без обоих путей оно стоит и молчит: // задачу можно было бы «доделать» по совсем другому плану, и заметить это нечем. expect(TEKST_CLI).toMatch(/plan_path:\s*sled\.plan_path/); expect(TEKST_CLI).toMatch(/plan_path_now:\s*razbor\.planPath/); }); it('🔴 команда проверок работника строится ИЗ ЕГО пункта, а не общим набором', () => { // 🔴🔴 Кусок 1 клал сюда `() => "npm run test:tools"` — общий набор. Оставь его — // работник читал бы в поручении, что его пункт меряется всем прогоном продукта. // 🪤 Сама надёжность проверки 38 держится НЕ на этой строке: замок команду из карточки // не берёт вовсе, он считает её заново на каждом судимом пункте (задача 5). // Здесь сторожится только то, что говорят РАБОТНИКУ. expect(TEKST_CLI).toMatch(/testCommandFor:\s*w\s*=>\s*komandaProverokPunkta\(w\.item\)/); }); it('🔴 план читается РОВНО ОДИН раз за запуск', () => { // 🔴🔴 Читай мы файл дважды, между двумя чтениями он мог бы измениться, и ворота // судили бы не тот план, который пошёл в работу. Поэтому `planPath` подан // единственному зову — тому, который его разбирает. const chteniya = BLOK_RUN.match(/vhodVorot\(\{\s*planPath\s*\}\)/g) ?? []; expect(chteniya.length).toBe(1); // 🪤 И полный зов ворот путь плана НЕ получает: получи он его — файл прочли бы второй раз. // 🔴 Примечания из зова вырезаются. Найдено на себе: я написал в самом зове словами, // что путь плана сюда НЕ подаётся, — и эта проверка покраснела на СЛОВЕ «planPath» // в примечании, хотя довода там нет. Сторож, красный от собственного объяснения, // толкает вычеркнуть объяснение, а не починить дело. const zovVorot = BLOK_RUN.match(/planRun\(vhodVorot\(\{([\s\S]*?)\}\)\)/)[1] .split('\n').filter(s => !s.trim().startsWith('//')).join('\n'); expect(zovVorot).not.toMatch(/planPath/); // 🪤 И вторая половина: своего, второго чтения файла плана в `cli.mjs` не осталось. // Кусок 1 читал первую строку плана сам (`readFileSync(planPath`), чтобы слепить // единственный пункт «весь-план». Этот путь заменён разбором, и возвращать его нельзя: // два места, читающих один файл, — это два разных плана в одном запуске. expect(TEKST_CLI).not.toMatch(/readFileSync\(planPath/); }); it('🔴 отказ по плану вправду ОСТАНАВЛИВАЕТ запуск, а не только произносится', async () => { // 🔴🔴🔴 НАЙДЕНО ВЫРЕЗАНИЕМ ВТОРОГО РОДА, планом не предусмотрено — дыра была настоящая. // Все проверки выше смотрят ТЕКСТ и доказывают, что ворота плана ЗОВУТСЯ. Но зов — // это ещё не защита: я обвёл их умно (`if (false && !planOk.ok)`), оставив зов на месте, // и ВСЕ 139 проверок остались зелёными, а негодный план пошёл бы в ночь. Это ровно тот // класс, ради которого весь кусок и затеян, только этажом выше: не «правило написано, // а зовущего нет», а «зовущий есть, а ответа он не слушает». // // 🔴 ПЛАТНОГО ЗОВА ЗДЕСЬ НЕ РОДИТСЯ НИ ПРИ КАКОЙ ПОЛОМКЕ, и это не надежда. В настройках // намеренно НЕТ строки `probe_model`, а замер спрашивает её ПЕРВЫМ делом и падает // до единого запуска чего бы то ни было. Убери кто-нибудь отказ по плану — проверка // покраснеет на СЛОВАХ, а не потратит деньги владельца. const vremenno = mkdtempSync(join(tmpdir(), 'night-plan-gate-')); const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); try { const planFile = join(vremenno, 'plan.md'); const priyomkaFile = join(vremenno, 'priyomka.md'); const specFile = join(vremenno, 'spec.md'); writeFileSync(planFile, '# Пробный план\n\nЗаголовков пунктов здесь нет ни одного.\n'); writeFileSync(priyomkaFile, '# приёмочный лист\n'); writeFileSync(specFile, '# замысел\n'); const code = await main( argvFor('run', planFile, '--priyomka', priyomkaFile, '--spec', specFile), { readConfig: () => ({ base_branch: 'feat/night', max_tasks_at_once: 2, max_workers_per_task: 7 }) }, ); const skazano = errSpy.mock.calls.map(c => String(c[0])).join('\n'); expect(code).toBe(1); // 🪤 Судим ПО НАПЕЧАТАННЫМ СЛОВАМ, а не по коду возврата: единица приходит и когда // ворота честно отказали, и когда до них не дошло вовсе. Код возврата тут не улика. expect(skazano).toMatch(/план проверку не прошёл/i); expect(skazano).toMatch(/нет ни одного пункта/i); } finally { errSpy.mockRestore(); rmSync(vremenno, { recursive: true, force: true }); } }); it('🔴 отказ по плану с повторяющимися номерами тоже ОСТАНАВЛИВАЕТ запуск', async () => { // Второй вкус той же беды: номер пункта — ключ, по которому ведут очередь и запирают // файлы. Двое под одним номером закроют друг друга, и оба отчитаются правдой. const vremenno = mkdtempSync(join(tmpdir(), 'night-plan-gate-')); const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {}); try { const planFile = join(vremenno, 'plan.md'); const priyomkaFile = join(vremenno, 'priyomka.md'); const specFile = join(vremenno, 'spec.md'); writeFileSync(planFile, [ '# Пробный план', '', '### Task 1: Первый', '', '', '### Task 1: Второй под тем же номером', '', ].join('\n')); writeFileSync(priyomkaFile, '# приёмочный лист\n'); writeFileSync(specFile, '# замысел\n'); const code = await main( argvFor('run', planFile, '--priyomka', priyomkaFile, '--spec', specFile), { readConfig: () => ({ base_branch: 'feat/night', max_tasks_at_once: 2, max_workers_per_task: 7 }) }, ); const skazano = errSpy.mock.calls.map(c => String(c[0])).join('\n'); expect(code).toBe(1); expect(skazano).toMatch(/повторяются номера пунктов/i); // 🪤 И виновник назван поимённо: без имени владелец не поймёт, который пункт чинить. expect(skazano).toMatch(/Task 1/); } finally { errSpy.mockRestore(); rmSync(vremenno, { recursive: true, force: true }); } }); it('🔴 след отложенной задачи снимается ПОСЛЕ удачного запуска, а не до ворот', () => { // 🪤 СВЕРХ ПЛАНА. Сними след раньше отказа — вторая попытка запуска прошла бы уже // без ворот вовсе: следа нет, значит «задача не откладывалась», и проверки 28–30 // отменились бы молча. Сними позже некуда: не сними вовсе — владельцу пришлось бы // говорить «продолжай» каждую ночь заново. const iVorota = BLOK_RUN.indexOf('deferredTaskGate('); const iStartAll = BLOK_RUN.indexOf('const started = startAll('); const iSnyatie = BLOK_RUN.indexOf('clearDeferred('); expect(iSnyatie).toBeGreaterThan(-1); expect(iSnyatie).toBeGreaterThan(iVorota); expect(iSnyatie).toBeGreaterThan(iStartAll); }); });