import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
// ★★ルート本体は**静的 import** すること★★ — `it()` の中で `await import()` すると、
// 最初の1本だけがモジュール読み込みを丸ごと抱え込み、フルスイート実行時に既定の
// タイムアウトを踏んで不定期に落ちる（`app/api/clean-logs/__tests__/route.test.ts` の実測）。
import { GET } from "@/app/api/prechecks/route";
import { CLEAN_TIMETABLE_PRECHECK, PRECHECK_MINUTES_BEFORE } from "@/lib/config";
import { filterFixturePrechecks } from "@/lib/db/fixture-prechecks";
import { guardNullRobotId } from "@/lib/db/__tests__/robot-error-null-guard";
import { FACILITY_SECTION_VISIBLE_WHERE } from "@/lib/db/visibility";
import { logEvent } from "@/lib/logger";
import {
filterPrechecksByDate,
parsePrecheckQuery,
type PrecheckQuery,
type PrecheckSummary,
} from "@/lib/prechecks/query";
import type { PrecheckDbQuery, PrecheckItem, SummaryListResponse } from "@/lib/types";
/**
* 指示書AC ★段階4★ の期待値表（#1〜#5）。
*
* ------------------------------------------------------------------------
* ★★何を守るためのテストか★★
* ------------------------------------------------------------------------
* `prechecks()` が返すのは ★事前チェック異常の行（`severity: "precheck"`）だけ★（ユーザー判断 2026-10-29）。
* ★期間の基準は**親の本清掃行**の `start_at`★（`PrecheckDbQuery` の型コメント）。
* ★#4 で「親が期間外・エラー行が期間内」★ を固定する。
* ★出発失敗（レポートの無い過去の本清掃）は行にならない★（旧: `severity: "launch_failed"`）—
* 「出発失敗はアラートに出ない」の describe と、清掃詳細ログ側（`app/api/clean-logs/__tests__/route.test.ts`）で固定する。
*
* ------------------------------------------------------------------------
* ★★DBには接続しません★★
* ------------------------------------------------------------------------
* `@/lib/db/prisma` の `getPrisma()` を ★スタブに差し替え★、
* `@/lib/db/use-fixtures` の `USE_FIXTURES` を ★`false`★ に固定して
* ★`prismaSource` の経路★ を走らせる（段階2 のテストと同じ作法）。
*
* ★★合成データを使う理由★★: ローカルDB（`dwatch_local`）では
* - ★`start_at` が深夜0〜3時にしか無く、`toDbJst()` の付け忘れを検出できない★（C-6）
* - ★事前チェック行の親が日をまたぐケース（#4）が1件も無い★
*/
// ---------------------------------------------------------------- スタブ（DBの代わり）
interface StubTimetable {
id: bigint;
facility_id: bigint;
section_id: bigint;
parent_id: bigint;
start_at: Date;
/** ★予定の終了（結果待ちの判定用。D-173）★。既定は開始の1時間後 */
end_at: Date;
precheck: number;
facility: { facility_name: string };
section: { robots: { serial_number: string }[] };
}
/**
* `clean_task_reports` の1行（★旧: `clean_status_histories`。指示書AQ 決定2 / 決定3★）。
* ★`clean_error` 列は無い★（`prisma/schema.prisma` の `CleanTaskReport`）。
* ★`ended_at` は nullable、`started_at` は NOT NULL★（順序キー。指示書AQ §1-4）。
*/
interface StubReport {
clean_timetable_id: bigint | null;
clean_ratio: number;
/** ★完了率は面積から出す★（`runCompletionRate()`。D-155）。`main_run_succeeded`（D-171）の判定に使う */
clean_area: number;
task_area: number;
started_at: Date;
ended_at: Date | null;
}
interface StubErrorReport {
error_id: string;
clean_timetable_id: bigint | null;
error_type: string;
errored_at: Date | null;
created_at: Date;
serial_number: string;
facility_id: bigint;
/** ★`deleted_at` は可視性の判定用（指示書BB U1。`ROBOT_ERROR_PRECHECK_ROW_SELECT` が読む）★ */
facility: { facility_name: string; deleted_at: Date | null };
section: { deleted_at: Date | null };
status: number;
responded_at: Date | null;
resolved_at: Date | null;
comment: string | null;
/** ★DDL では NULL 可（第11回 P-8 b）。読まないこと（指示書AU 段階0-4）★ */
robot_id?: bigint | null;
}
interface StubData {
timetables: StubTimetable[];
/** ★`clean_timetable_histories` の行（指示書AU 段階3b）。無ければ空★ */
historyTimetables?: StubTimetable[];
reports: StubReport[];
errorReports: StubErrorReport[];
}
/** `findMany()` に渡された引数の記録（★どんな `where` が発行されたかを検査する★） */
const calls: {
cleanTimetable: Record<string, unknown>[];
cleanTimetableHistory: Record<string, unknown>[];
cleanTaskReport: Record<string, unknown>[];
robotErrorReport: Record<string, unknown>[];
} = { cleanTimetable: [], cleanTimetableHistory: [], cleanTaskReport: [], robotErrorReport: [] };
let data: StubData;
/**
* ★true のあいだ、エラー行の `where` を無視して全行を返す★（指示書BB 表3 S2 / 表1 V7）—
* SQL の写し（`status IN`・可視性）が外れても、純粋関数の側（正）で外れることを確かめる
*/
let ignoreErrorWhere = false;
/** BigInt / number / null をまたいで id を比較する（`===` では比較できない） */
function sameId(a: unknown, b: unknown): boolean {
if (a === null || a === undefined || b === null || b === undefined) return false;
return String(a) === String(b);
}
/**
* Prisma の `where` のうち、★本作業が使う分だけ★ を再現する。
*
* ★★`in: undefined` は Prisma では「条件が消えて全件」になる★★（★罠1★）。
* ★ここでは例外にして、書き間違いが静かに通り抜けないようにする★。
*/
function matchesWhere(row: Record<string, unknown>, where: unknown): boolean {
if (!where) return true;
for (const [field, cond] of Object.entries(where as Record<string, unknown>)) {
const value = row[field];
if (cond !== null && typeof cond === "object" && !(cond instanceof Date)) {
const c = cond as Record<string, unknown>;
if ("in" in c) {
if (c.in === undefined) {
throw new Error(
`[stub] where.${field}.in が undefined です。★罠1★: Prisma では条件が消えて全件になります`
);
}
if (!(c.in as unknown[]).some((x) => sameId(x, value))) return false;
}
if (c.gte instanceof Date && (value as Date).getTime() < c.gte.getTime()) return false;
if (c.lt instanceof Date && (value as Date).getTime() >= c.lt.getTime()) return false;
} else if (typeof cond === "bigint" || typeof value === "bigint") {
if (!sameId(value, cond)) return false;
} else if (value !== cond) {
return false;
}
}
return true;
}
function project(row: Record<string, unknown>, select: unknown): Record<string, unknown> {
if (!select) return row;
const out: Record<string, unknown> = {};
for (const key of Object.keys(select as Record<string, unknown>)) out[key] = row[key];
return out;
}
function findMany(
bucket: keyof typeof calls,
rows: Record<string, unknown>[],
args: Record<string, unknown> | undefined
) {
calls[bucket].push(args ?? {});
return rows
.filter((row) => matchesWhere(row, args?.where))
.map((row) => project(row, args?.select));
}
vi.mock("@/lib/db/use-fixtures", () => ({ USE_FIXTURES: false }));
// ★`data.anomaly`（指示書BB U2・U3）を見るため `logEvent` だけ差し替える（`withRequestId` はそのまま）★
vi.mock("@/lib/logger", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/lib/logger")>();
return { ...actual, logEvent: vi.fn() };
});
vi.mock("@/lib/db/prisma", () => ({
getPrisma: async () => ({
cleanTimetable: {
findMany: async (args?: Record<string, unknown>) =>
findMany("cleanTimetable", data.timetables as unknown as Record<string, unknown>[], args),
},
// ★`clean_timetable_histories`（指示書AU 段階3b）。既定は空★
cleanTimetableHistory: {
findMany: async (args?: Record<string, unknown>) =>
findMany(
"cleanTimetableHistory",
(data.historyTimetables ?? []) as unknown as Record<string, unknown>[],
args
),
},
// ★清掃結果の取得元は `clean_task_reports`★（旧: `cleanStatusHistory`。指示書AQ 決定2 / 決定3）
cleanTaskReport: {
findMany: async (args?: Record<string, unknown>) =>
findMany("cleanTaskReport", data.reports as unknown as Record<string, unknown>[], args),
},
robotErrorReport: {
findMany: async (args?: Record<string, unknown>) => {
// ★`robot_id` が NULL の行を `robot_id` ごと読むと本物の Prisma は落ちる（指示書AU 段階0-4）★
guardNullRobotId(data.errorReports as unknown as Record<string, unknown>[], args);
if (ignoreErrorWhere) {
// ★`clean_timetable_id IN` だけ残し、それ以外（`status IN`・可視性）を無視する★
const where = (args?.where ?? {}) as Record<string, unknown>;
return findMany("robotErrorReport", data.errorReports as unknown as Record<string, unknown>[], {
...args,
where: { clean_timetable_id: where.clean_timetable_id },
});
}
return findMany("robotErrorReport", data.errorReports as unknown as Record<string, unknown>[], args);
},
},
}),
}));
// ---------------------------------------------------------------- 合成データ
/** DB に入っているのと同じ「壁時計値としての `Date`」（D-115。他のテストと同じヘルパー） */
function dbWallClock(jstIso: string): Date {
return new Date(jstIso.replace("+09:00", "Z"));
}
/** ★実在の店名を使わない★（`CLAUDE.md` §7 / `docs/fixtures.md`） */
const FACILITY_1 = "バリューマート北町店";
const FACILITY_2 = "メガバリューマート緑野店";
const [FIRST_ROUND_MINUTES, SECOND_ROUND_MINUTES] = PRECHECK_MINUTES_BEFORE;
function timetable(
id: number,
facilityId: number,
facilityName: string,
jstIso: string,
precheck: number = CLEAN_TIMETABLE_PRECHECK.main,
parentId = 0
): StubTimetable {
return {
id: BigInt(id),
facility_id: BigInt(facilityId),
section_id: BigInt(facilityId * 10),
parent_id: BigInt(parentId),
start_at: dbWallClock(jstIso),
end_at: new Date(dbWallClock(jstIso).getTime() + 60 * 60_000),
precheck,
facility: { facility_name: facilityName },
section: { robots: [{ serial_number: `8111R56280600${facilityId}` }] },
};
}
/**
* ★レポートの行がある ＝ 実施済み★（指示書AQ §1-1。★行が無いときだけ未実施＝出発失敗★）。
* ★`status` は持たせない★ — 値の意味は受領済み（第10回 N-2）だが、判定には使わない（D-155 項2。指示書AQ §1-2）。
*/
function report(
timetableId: number,
startedJst: string,
endedJst: string | null,
// ★既定は 80%（○）★ — 判定が成功になる値（D-171 の `main_run_succeeded`）
cleanArea = 80,
taskArea = 100
): StubReport {
return {
clean_timetable_id: BigInt(timetableId),
clean_ratio: 80,
clean_area: cleanArea,
task_area: taskArea,
started_at: dbWallClock(startedJst),
ended_at: endedJst === null ? null : dbWallClock(endedJst),
};
}
function errorReport(
errorId: string,
timetableId: number,
facilityId: number,
facilityName: string,
erroredAtJst: string
): StubErrorReport {
return {
error_id: errorId,
clean_timetable_id: BigInt(timetableId),
error_type: "EmergencyStop",
errored_at: dbWallClock(erroredAtJst),
created_at: dbWallClock(erroredAtJst),
serial_number: `8111R56280600${facilityId}`,
facility_id: BigInt(facilityId),
facility: { facility_name: facilityName, deleted_at: null },
section: { deleted_at: null },
// ★0 = 未解消★（`resolutionStatusFromRobotErrorStatus()`）
status: 0,
responded_at: null,
resolved_at: null,
comment: null,
};
}
/**
* ★★#4 の肝★★: `104` は ★9/11 00:30★ の本清掃で、その事前チェック行 `1041` と
* そのエラー行は ★9/10 23:30 / 23:35★（＝ ★日をまたぐ★）。
* ★★`errored_at` や事前チェック行の `start_at` で絞ると 9/10 に現れてしまう★★。
*/
function buildData(): StubData {
return {
timetables: [
// --- 本清掃行 ---
// ★レポートなし（＝出発失敗）★ — ★アラートには出ない★（2026-10-29。清掃詳細ログには出発失敗として出る）
timetable(101, 1, FACILITY_1, "2026-09-08T02:00:00+09:00"),
timetable(102, 1, FACILITY_1, "2026-09-09T02:00:00+09:00"), // 正常
// ★レポートなし（＝出発失敗）★ — アラートには出ない
timetable(103, 1, FACILITY_1, "2026-09-10T02:00:00+09:00"),
timetable(104, 1, FACILITY_1, "2026-09-11T00:30:00+09:00"), // 正常（#4 の親）
// ★★壁時計 20:00 の清掃★★（C-6。★ローカルDBには1件も無い時間帯★）。レポートなし（出発失敗）だが、事前チェックのエラー E5 の親
timetable(301, 2, FACILITY_2, "2026-09-10T20:00:00+09:00"),
// ★未来の予定★（レポートなし）— 旧: `isFutureSchedule()` を外すと出発失敗として並んだ。いまは出発失敗そのものを出さない
timetable(901, 1, FACILITY_1, "2026-10-05T02:00:00+09:00"),
// --- 事前チェック行（本清掃の子） ---
timetable(1021, 1, FACILITY_1, "2026-09-09T01:00:00+09:00", FIRST_ROUND_MINUTES, 102),
timetable(1022, 1, FACILITY_1, "2026-09-09T01:30:00+09:00", SECOND_ROUND_MINUTES, 102),
// ★★#4: 親（104）は 9/11、この行は 9/10★★
timetable(1041, 1, FACILITY_1, "2026-09-10T23:30:00+09:00", FIRST_ROUND_MINUTES, 104),
// ★壁時計 20:00 の清掃（301）の事前チェック（C-6）★
timetable(3011, 2, FACILITY_2, "2026-09-10T19:00:00+09:00", FIRST_ROUND_MINUTES, 301),
],
// ★103 の行は置かない★（旧: `clean_error=1` の履歴。`clean_task_reports` には
// 未実施を表す列が無いので、未実施は「行が無い」でしか表せない。指示書AQ §1-1）
reports: [
report(102, "2026-09-09T02:00:00+09:00", "2026-09-09T03:00:00+09:00"),
// ★`ended_at` が NULL の行★（nullable。指示書AQ §1-4）— ★行がある以上は実施済み★で、
// `main_run_succeeded` の材料として読めること
report(104, "2026-09-11T00:30:00+09:00", null),
],
errorReports: [
errorReport("E1", 1021, 1, FACILITY_1, "2026-09-09T01:05:00+09:00"),
// ★★#4: エラー行の時刻は 9/10 だが、親の本清掃は 9/11★★
errorReport("E2", 1041, 1, FACILITY_1, "2026-09-10T23:35:00+09:00"),
// ★★本清掃行を指すエラー行★★ — ★拾わない★（D-104）ので
// ★1件も出てはいけない★（出発失敗の代わりに本清掃のエラーが出ていないことの検出）
errorReport("E3", 103, 1, FACILITY_1, "2026-09-10T02:10:00+09:00"),
// ★壁時計 20:00 の清掃（301）の事前チェックのエラー（C-6）★
errorReport("E5", 3011, 2, FACILITY_2, "2026-09-10T19:05:00+09:00"),
],
};
}
/** ★9月の行が全部「過去」になる基準時刻★（10/05 の行だけが未来として残る） */
const NOW = new Date("2026-09-30T00:00:00+09:00");
async function get(search: string): Promise<SummaryListResponse<PrecheckItem, PrecheckSummary>> {
const res = await GET(new Request(`http://localhost/api/prechecks${search}`));
return (await res.json()) as SummaryListResponse<PrecheckItem, PrecheckSummary>;
}
/**
* 本清掃行を引くクエリ（＝ `where.precheck` を持つ1本目）。
* ★2026-10-29 から `include` を持たない★（`select: { id, start_at }`）ので、`where.precheck` で見分ける
*/
function isMainQuery(c: Record<string, unknown>): boolean {
return "where" in c && "precheck" in (c.where as object);
}
function mainQuery(): Record<string, unknown> {
const call = calls.cleanTimetable.find(isMainQuery);
expect(call).toBeDefined();
return call as Record<string, unknown>;
}
function mainQueryWhere(): Record<string, unknown> {
return (mainQuery() as { where: Record<string, unknown> }).where;
}
/** `severity` ごとの件数（★`precheck` 以外が混ざっていないことの検出に使う★） */
function bySeverity(items: PrecheckItem[]): Record<string, number> {
const out: Record<string, number> = {};
for (const item of items) out[item.severity] = (out[item.severity] ?? 0) + 1;
return out;
}
function memoryQuery(partial: Partial<PrecheckQuery>): PrecheckQuery {
return {
dateFrom: null,
dateTo: null,
status: "all",
// ★絞り込まない（指示書AK 段階2 で足った2つ。`null` = 条件なし）★
groupId: null,
customerId: null,
page: 1,
perPage: 50,
...partial,
};
}
beforeEach(() => {
data = buildData();
ignoreErrorWhere = false;
vi.mocked(logEvent).mockClear();
calls.cleanTimetable = [];
calls.cleanTimetableHistory = [];
calls.cleanTaskReport = [];
calls.robotErrorReport = [];
// ★`new Date()` を固定する（Date だけを差し替え、タイマーは触らない）★
vi.useFakeTimers({ toFake: ["Date"] });
vi.setSystemTime(NOW);
});
afterEach(() => {
vi.useRealTimers();
});
// ---------------------------------------------------------------- テスト
describe("GET /prechecks — 日付をSQLに降ろす（指示書AC 段階4）", () => {
it("#1 範囲なし → 事前チェック異常の全件（★出発失敗の行は無い★）", async () => {
const body = await get("?status=all");
// ★detected_at の降順（D-052）★
expect(body.items.map((i) => `${i.severity}:${i.id}`)).toEqual([
"precheck:E2",
"precheck:E5",
"precheck:E1",
]);
expect(body.meta.total).toBe(3);
expect(body.summary).toEqual({ unresolved: 3, resolved: 0, total: 3 });
// ★本清掃の絞り込みが SQL に降りていること★
expect(mainQueryWhere().precheck).toBe(CLEAN_TIMETABLE_PRECHECK.main);
// ★範囲なしのときは `start_at` のキーごと付けない★
expect(mainQueryWhere()).not.toHaveProperty("start_at");
});
it("★D-104: 本清掃行を指すエラー行は出さない★（出発失敗の代わりにもしない）", async () => {
const body = await get("?status=all");
expect(body.items.map((i) => i.id)).not.toContain("E3");
});
it("#2 日付範囲を指定すると SQL の `where` に `start_at` が降りる（★`toDbJst()` を通す★）", async () => {
await get("?date_from=2026-09-09&date_to=2026-09-10&status=all");
const startAt = mainQueryWhere().start_at as { gte: Date; lt: Date };
// ★★壁時計値であること★★（C-6。★生の `parseDate()`（真の瞬間）ではない★）
expect(startAt.gte.toISOString()).toBe("2026-09-09T00:00:00.000Z");
expect(startAt.lt.toISOString()).toBe("2026-09-11T00:00:00.000Z");
});
it("★★#2 SQL版 ＝ 全件版 + `filterPrechecksByDate()`（完全一致）★★", async () => {
const all = await get("?status=all");
const sql = await get("?date_from=2026-09-09&date_to=2026-09-10&status=all");
const memory = filterPrechecksByDate(
all.items,
memoryQuery({ dateFrom: "2026-09-09", dateTo: "2026-09-10" })
);
// ★件数だけでなく中身まで比べる★（指示書AC G-3）
expect(sql.items).toEqual(memory);
expect(sql.items.length).toBeGreaterThan(0);
});
it("★★#3 `severity` の内訳が全件版と一致する★★（★事前チェック異常だけ★）", async () => {
const all = await get("?status=all");
expect(bySeverity(all.items)).toEqual({ precheck: 3 });
for (const [from, to] of [
["2026-09-08", "2026-09-08"],
["2026-09-09", "2026-09-09"],
["2026-09-10", "2026-09-10"],
["2026-09-11", "2026-09-11"],
["2026-09-09", "2026-09-11"],
]) {
const sql = await get(`?date_from=${from}&date_to=${to}&status=all`);
const memory = filterPrechecksByDate(
all.items,
memoryQuery({ dateFrom: from, dateTo: to })
);
expect(bySeverity(sql.items)).toEqual(bySeverity(memory));
expect(sql.items).toEqual(memory);
}
});
it("★★#4 親の本清掃行が期間外・エラー行が期間内 → 親の `start_at` で判定される★★", async () => {
// ★E2 のエラー行と事前チェック行は 9/10、親の本清掃（104）は 9/11★
const sep11 = await get("?date_from=2026-09-11&date_to=2026-09-11&status=all");
expect(sep11.items.map((i) => i.id)).toEqual(["E2"]);
// ★`scheduled_at` は親の値（＝ `filterPrechecksByDate()` が見る値）★
expect(sep11.items[0].scheduled_at).toBe("2026-09-11T00:30:00+09:00");
// ★`detected_at` は 9/10 のまま（★絞り込みの基準ではない★）★
expect(sep11.items[0].detected_at).toBe("2026-09-10T23:35:00+09:00");
// ★★9/10 を指定しても E2 は出ない★★ —
// ★`errored_at` や事前チェック行の `start_at` で絞っていると、ここで E2 が混ざる★
const sep10 = await get("?date_from=2026-09-10&date_to=2026-09-10&status=all");
expect(sep10.items.map((i) => i.id)).not.toContain("E2");
// ★9/10 は E5（親 301 は 9/10 20:00）だけ★。出発失敗（103・301）は行にならない
expect(sep10.items.map((i) => i.id)).toEqual(["E5"]);
});
it("★#4（構造）事前チェック行は親の本清掃の id（`parent_id`）で引く★", async () => {
await get("?date_from=2026-09-11&date_to=2026-09-11&status=all");
const precheckCall = calls.cleanTimetable.find(
(c) => "where" in c && "parent_id" in (c.where as object)
);
expect(precheckCall).toBeDefined();
expect((precheckCall as { select: object }).select).toEqual({
id: true,
parent_id: true,
precheck: true,
});
// ★エラー行は事前チェック行の id でしか引かない（全件読みに戻さない）★
const errorWhere = (
calls.robotErrorReport[0] as { where: { clean_timetable_id: { in: bigint[] } } }
).where;
expect(errorWhere.clean_timetable_id.in.map(String)).toEqual(["1041"]);
});
it("★壁時計 20:00 の清掃が、その日の範囲に**含まれる**★（C-6。★ローカルDBでは検出できない★）", async () => {
// ★E5 の親（301）は 9/10 20:00★
const sep10 = await get("?date_from=2026-09-10&date_to=2026-09-10&status=all");
expect(sep10.items.map((i) => i.id)).toContain("E5");
expect(sep10.items.find((i) => i.id === "E5")?.scheduled_at).toBe("2026-09-10T20:00:00+09:00");
const sep11 = await get("?date_from=2026-09-11&date_to=2026-09-11&status=all");
expect(sep11.items.map((i) => i.id)).not.toContain("E5");
});
it("★レポートは行になったエラーの親の本清掃の id だけで引く（全件読みに戻さない）★", async () => {
await get("?date_from=2026-09-10&date_to=2026-09-10&status=all");
const reportWhere = (
calls.cleanTaskReport.find((c) => "where" in c) as {
where: { clean_timetable_id: { in: bigint[] } };
}
).where;
// ★9/10 の本清掃は 103・301 だが、行（E5）の親は 301 だけ★（旧: 出発失敗の判定のため 103 も引いていた）
expect(reportWhere.clean_timetable_id.in.map(String)).toEqual(["301"]);
});
it("★行が0件ならレポートを引かない★（出発失敗の判定のための読み取りは無い）", async () => {
// 9/8 の本清掃（101）は事前チェックのエラーが無い
const body = await get("?date_from=2026-09-08&date_to=2026-09-08&status=all");
expect(body.items).toEqual([]);
expect(calls.cleanTimetable.length).toBeGreaterThan(0);
expect(calls.cleanTaskReport).toEqual([]);
});
it("★本清掃が0件ならクエリを1本も撃たない★（`chunkForInClause([])` が空を返す）", async () => {
const body = await get("?date_from=2026-01-01&date_to=2026-01-02&status=all");
expect(body.items).toEqual([]);
expect(calls.robotErrorReport).toEqual([]);
expect(calls.cleanTaskReport).toEqual([]);
});
it("★summary は日付範囲で絞ったあとの件数になる★（D-054。SQL に降ろしても変わらない）", async () => {
const body = await get("?date_from=2026-09-10&date_to=2026-09-10&status=all");
// ★9/10 は E5 の1件だけ★（旧: 出発失敗 103・301 の2件。2026-10-29 から数えない）
expect(body.summary).toEqual({ unresolved: 1, resolved: 0, total: 1 });
expect(body.meta.total).toBe(1);
});
});
/**
* ★出発失敗はアラートに出さない★（ユーザー判断 2026-10-29「2で進めてください」）。
* ★過去の本清掃でレポートが無い（101・103・301）は、行・summary・meta.total のどれにも出ない★。
* 清掃詳細ログには出発失敗として出ること（同じ判定 `notExecutedFromReport()`）は
* `app/api/clean-logs/__tests__/route.test.ts` の「出発失敗はアラートに出ない」で固定する。
*/
describe("GET /prechecks — 出発失敗はアラートに出さない（2026-10-29）", () => {
const LAUNCH_FAILED_IDS = ["101", "103", "301", "901"];
it("★レポートの無い過去の本清掃は行にならない（summary・meta.total にも数えない）★", async () => {
const body = await get("?status=all");
const ids = body.items.map((i) => i.id);
for (const id of LAUNCH_FAILED_IDS) expect(ids).not.toContain(id);
expect(body.items.every((i) => i.severity === "precheck")).toBe(true);
// ★件数は事前チェック異常の3件だけ★
expect(body.summary.total).toBe(3);
expect(body.meta.total).toBe(3);
});
it("★事前チェックのエラーが無ければ、出発失敗の清掃があっても0件★", async () => {
data.errorReports = [];
const body = await get("?status=all");
expect(body.items).toEqual([]);
expect(body.summary).toEqual({ unresolved: 0, resolved: 0, total: 0 });
expect(body.meta.total).toBe(0);
});
it("★結果待ちの時刻でも、待ち時間を過ぎた後でも出さない★（旧: 終了＋120分を過ぎると出発失敗として出した。D-173）", async () => {
for (const now of ["2026-09-10T04:59:00+09:00", "2026-09-10T05:00:00+09:00"]) {
vi.setSystemTime(new Date(now));
const ids = (await get("?status=all")).items.map((i) => i.id);
for (const id of LAUNCH_FAILED_IDS) expect(ids).not.toContain(id);
}
});
it("★親の本清掃が出発失敗の事前チェック異常は、行として出る（main_run_succeeded は false）★", async () => {
// E5 の親 301 はレポートなし（出発失敗）
const body = await get("?status=all");
const e5 = body.items.find((i) => i.id === "E5");
expect(e5).toBeDefined();
expect(e5?.main_run_succeeded).toBe(false);
expect(e5?.severity).toBe("precheck");
});
});
describe("★#5 fixtures 版と Prisma 版が同じ引数で同じ結果を返す★（禁止事項6）", () => {
/**
* ★同じデータに対して★、
* - Prisma 版 = ★SQL で絞った結果★
* - fixtures 版 = ★全件版 + `filterFixturePrechecks()`★
* を突き合わせる（指示書AC G-3「等価テスト」）。
*/
it("日付範囲: SQL版 ＝ 全件版 + fixtures 版の絞り込み", async () => {
const all = await get("?status=all");
const sql = await get("?date_from=2026-09-09&date_to=2026-09-11&status=all");
const viaFixtures = filterFixturePrechecks(all.items, {
date_from: "2026-09-09",
date_to: "2026-09-11",
facility_ids: null,
});
expect(sql.items).toEqual(viaFixtures);
expect(sql.items.length).toBeGreaterThan(0);
});
it("範囲なし: 件数が一致", async () => {
const all = await get("?status=all");
expect(
filterFixturePrechecks(all.items, { date_from: null, date_to: null, facility_ids: null })
).toHaveLength(all.items.length);
});
/**
* ★★空文字のクエリ（`?date_to=`）で fixtures 版と Prisma 版が食い違わないこと★★（禁止事項6）。
*
* `parsePrecheckQuery()` が生値をそのまま下へ渡していた頃、`""` は
* - Prisma 版 … `dbDateRange("")` → `parseDate("")` が `null` → ★条件が付かず全件★
* - fixtures 版 … `query.date_to !== null` が真・`"2026-09-10" > ""` も真 → ★全行除外で0件★
* となり、★同じ入力で件数が変わっていました★（★例外もテスト失敗も出ない★）。
*
* ★ルートと同じ経路で組み立てる★ — `parsePrecheckQuery()` の戻り値をそのまま
* `PrecheckDbQuery` に詰め、fixtures 版の絞り込みへ渡す（ルートは `db.prechecks()` に
* 同じ値を渡している）。★テスト側で `null` を書き足さないこと★（それでは穴を再現できない）。
*/
describe("★空文字のクエリ（`?date_from=` / `?date_to=`）★", () => {
function dbQueryFromSearch(search: string): PrecheckDbQuery {
const parsed = parsePrecheckQuery(new URLSearchParams(search));
expect(parsed.ok).toBe(true);
if (!parsed.ok) throw new Error("query");
return {
date_from: parsed.query.dateFrom,
date_to: parsed.query.dateTo,
facility_ids: null,
};
}
for (const search of ["date_to=", "date_from=", "date_from=&date_to="]) {
it(`\`?${search}\`: SQL版 ＝ fixtures 版 ＝ 全件`, async () => {
const all = await get("?status=all");
const sql = await get(`?${search}&status=all`);
const viaFixtures = filterFixturePrechecks(all.items, dbQueryFromSearch(search));
// ★空文字は「指定なし」＝全件★（★片方だけ0件に化けないこと★）
expect(sql.items).toEqual(all.items);
expect(viaFixtures).toEqual(all.items);
expect(viaFixtures).toHaveLength(sql.items.length);
expect(all.items.length).toBeGreaterThan(0);
});
}
it("★空文字は `start_at` のキーごと付かない（範囲なしと同じ SQL）★", async () => {
await get("?date_from=&date_to=&status=all");
expect(mainQueryWhere()).not.toHaveProperty("start_at");
});
});
});
describe("GET /prechecks — robot_id が NULL のエラー行（指示書AU 段階0-4。第11回 P-8 b）", () => {
it("★robot_id が NULL の行を混ぜても落ちず、同じ行が出る★（select で robot_id / robot を読まない）", async () => {
const before = await get("?status=all");
data.errorReports = data.errorReports.map((r) => ({ ...r, robot_id: null }));
const res = await GET(new Request("http://localhost/api/prechecks?status=all"));
expect(res.status).toBe(200);
const after = (await res.json()) as SummaryListResponse<PrecheckItem, PrecheckSummary>;
expect(after.items).toEqual(before.items);
expect(after.items.map((i) => i.id)).toContain("E1");
});
});
describe("GET /prechecks — 予定を2表から読む（指示書AU 段階3b。第11回 P-7）", () => {
it("★履歴だけの予定の事前チェックのエラーも出る★。2表に同じ引数が渡る", async () => {
data.historyTimetables = [
// ★履歴だけの本清掃（レポートなし → 出発失敗）★ — アラートには出ない（2026-10-29）
timetable(501, 1, FACILITY_1, "2026-09-12T02:00:00+09:00"),
// ★履歴だけの本清掃（正常）とその事前チェック行（エラーあり）★
timetable(502, 1, FACILITY_1, "2026-09-13T02:00:00+09:00"),
timetable(5021, 1, FACILITY_1, "2026-09-13T01:00:00+09:00", FIRST_ROUND_MINUTES, 502),
];
data.reports.push(report(502, "2026-09-13T02:00:00+09:00", "2026-09-13T03:00:00+09:00"));
data.errorReports.push(errorReport("E9", 5021, 1, FACILITY_1, "2026-09-13T01:05:00+09:00"));
const body = await get("?status=all");
const ids = body.items.map((i) => i.id);
expect(ids).toContain("E9");
expect(ids).not.toContain("501");
expect(ids).not.toContain("502");
const mainCall = calls.cleanTimetable.find(isMainQuery);
expect(mainCall).toBeDefined();
expect(calls.cleanTimetableHistory.find(isMainQuery)).toEqual(mainCall);
});
});
/**
* ★`main_run_succeeded`（ユーザー指示 2026-10-07。D-171 の期待値表 M1〜M5）★ — Prisma 版の経路。
* ★親の本清掃のレポートは `prechecks()` が行の親の id でまとめて1回引く★（N+1 にしない）。
* （M6「出発失敗の行は常に false」は、2026-10-29 に出発失敗の行を外したので無い）
*/
describe("GET /prechecks — main_run_succeeded（D-171）", () => {
it("親の本清掃が ◎○ なら true、△・レポートなし（出発失敗）は false", async () => {
// E1 の親 102 は 95%（◎。M1）、E2 の親 104 は 50%（△。M3）
data.reports = [
report(102, "2026-09-09T02:00:00+09:00", "2026-09-09T03:00:00+09:00", 95, 100),
report(104, "2026-09-11T00:30:00+09:00", null, 50, 100),
];
// ★M4: 親の本清掃にレポートが無い事前チェックのエラー★（親 101 そのものは行にならない）
data.timetables.push(
timetable(1011, 1, FACILITY_1, "2026-09-08T01:00:00+09:00", FIRST_ROUND_MINUTES, 101)
);
data.errorReports.push(errorReport("E4", 1011, 1, FACILITY_1, "2026-09-08T01:05:00+09:00"));
const body = await get("?status=all");
const byKey = new Map(body.items.map((i) => [`${i.severity}:${i.id}`, i.main_run_succeeded]));
expect(byKey.get("precheck:E1")).toBe(true);
expect(byKey.get("precheck:E2")).toBe(false);
expect(byKey.get("precheck:E4")).toBe(false);
// ★出発失敗（101）は行にならない（2026-10-29）★
expect(body.items.map((i) => i.id)).not.toContain("101");
});
it("M2: ○（72%）は true / M5: task_area 0（×）は false", async () => {
data.reports = [report(102, "2026-09-09T02:00:00+09:00", "2026-09-09T03:00:00+09:00", 72, 100)];
expect((await get("?status=all")).items.find((i) => i.id === "E1")?.main_run_succeeded).toBe(true);
data.reports = [report(102, "2026-09-09T02:00:00+09:00", "2026-09-09T03:00:00+09:00", 500, 0)];
expect((await get("?status=all")).items.find((i) => i.id === "E1")?.main_run_succeeded).toBe(false);
});
it("★レポートは本清掃の id でまとめて1回だけ引く★（N+1 にしない）", async () => {
await get("?status=all");
expect(calls.cleanTaskReport).toHaveLength(1);
});
});
/** `data.anomaly` のうち、指定の metric のものだけ */
function anomalies(metric: string) {
return vi
.mocked(logEvent)
.mock.calls.filter(([, p]) => p.event === "data.anomaly" && p.metric === metric)
.map(([, p]) => p);
}
describe("GET /prechecks — 対応状況が 0/1/2 以外のエラー行（指示書BB U3・表3 S1/S2）", () => {
it("★S2: `status` 3 の行は SQL の写し（`status IN (0,1,2)`）で外れる★", async () => {
data.errorReports.push({ ...errorReport("E-ODD", 1022, 1, FACILITY_1, "2026-09-09T01:35:00+09:00"), status: 3 });
const res = await GET(new Request("http://localhost/api/prechecks?status=all"));
expect(res.status).toBe(200);
const where = calls.robotErrorReport[0].where as Record<string, unknown>;
expect(where.status).toEqual({ in: [0, 1, 2] });
});
it("★S2: スタブが `where` を無視しても、純粋関数の側で外れる（200・出ない・summary に数えない・ログ1回）★", async () => {
const before = await get("?status=all");
vi.mocked(logEvent).mockClear();
data.errorReports.push({ ...errorReport("E-ODD", 1022, 1, FACILITY_1, "2026-09-09T01:35:00+09:00"), status: 3 });
ignoreErrorWhere = true;
const res = await GET(new Request("http://localhost/api/prechecks?status=all"));
expect(res.status).toBe(200);
const after = (await res.json()) as SummaryListResponse<PrecheckItem, PrecheckSummary>;
expect(after.items.map((i) => i.id)).not.toContain("E-ODD");
expect(after.items).toEqual(before.items);
expect(after.summary).toEqual(before.summary);
expect(anomalies("robot_error_status_unknown")).toEqual([
{ event: "data.anomaly", metric: "robot_error_status_unknown", expected: "0/1/2", actual: 1 },
]);
});
it("S1: `status` 0/1/2 の行は今どおり出る（外した件数が0ならログを出さない）", async () => {
ignoreErrorWhere = true;
const body = await get("?status=all");
expect(body.items.map((i) => i.id)).toContain("E1");
expect(anomalies("robot_error_status_unknown")).toHaveLength(0);
});
});
/**
* ★本清掃の予定は `id` と `start_at` だけ読む★（2026-10-29）— 旧: 出発失敗の行の施設名・シリアルのため
* `facility` / `section.robots` を include し、有効なロボットが1台でない清掃エリアのログ（指示書BB U2）を出していた。
*/
describe("GET /prechecks — 本清掃の予定はロボット・施設を読まない（2026-10-29）", () => {
it("★本清掃の予定のクエリは `select: { id, start_at }`（include なし）。2表とも同じ★", async () => {
await get("?status=all");
expect(mainQuery()).not.toHaveProperty("include");
expect(mainQuery().select).toEqual({ id: true, start_at: true });
expect(calls.cleanTimetableHistory.find(isMainQuery)).toEqual(mainQuery());
});
it("★清掃エリアのロボットが0台でも、事前チェック異常の行は今どおり（シリアルはエラー行の生値・ログなし）★", async () => {
for (const t of data.timetables) {
if (Number(t.facility_id) === 1) t.section = { robots: [] };
}
const res = await GET(new Request("http://localhost/api/prechecks?status=all"));
expect(res.status).toBe(200);
const body = (await res.json()) as SummaryListResponse<PrecheckItem, PrecheckSummary>;
// ★事前チェック異常の行は `robot_error_reports.serial_number` の生値のまま（null にならない）★
expect(body.items.find((i) => i.id === "E1")?.serial_number).toBe("8111R562806001");
expect(anomalies("active_robots_per_section")).toHaveLength(0);
});
});
describe("GET /prechecks — 削除済みの施設・清掃エリアの行は出さない（指示書BB U1・表1 V7/V8）", () => {
const DELETED = dbWallClock("2026-09-01T00:00:00+09:00");
it("★V8: 予定（2表とも）の `where` に施設・清掃エリアの可視性が入る★（事前チェックの親の本清掃）", async () => {
await get("?status=all");
expect(mainQueryWhere()).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
const historyMain = calls.cleanTimetableHistory.find(isMainQuery) as { where: Record<string, unknown> };
expect(historyMain.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
});
it("V7: エラー行の SQL（写し）にも `status IN` は入るが、可視性は純粋関数で外す（列を select する）", async () => {
await get("?status=all");
const select = calls.robotErrorReport[0].select as Record<string, { select: Record<string, unknown> }>;
expect(select.facility.select).toMatchObject({ deleted_at: true });
expect(select.section.select).toMatchObject({ deleted_at: true });
});
it.each([
["施設削除", { facility: { facility_name: FACILITY_1, deleted_at: DELETED } }],
["エリア削除", { section: { deleted_at: DELETED } }],
] as const)("★V7（%s）: スタブが where を無視しても、そのエラー行は出ない・summary に数えない★", async (_label, patch) => {
const before = await get("?status=all");
data.errorReports = data.errorReports.map((r) => (r.error_id === "E1" ? { ...r, ...patch } : r));
ignoreErrorWhere = true;
const after = await get("?status=all");
expect(after.items.map((i) => i.id)).toEqual(before.items.map((i) => i.id).filter((id) => id !== "E1"));
expect(after.summary.total).toBe(before.summary.total - 1);
});
});
describe("GET /prechecks — 存在しない日付は422（指示書BB 表8 Q6）", () => {
it("★`2026-02-31` は形式違い（`2026/02/03`）と同じ code・message・details の422★", async () => {
const bad = await GET(new Request("http://localhost/api/prechecks?date_from=2026-02-31"));
const format = await GET(new Request("http://localhost/api/prechecks?date_from=2026/02/03"));
expect(bad.status).toBe(422);
expect(format.status).toBe(422);
expect(await bad.json()).toEqual(await format.json());
});
});
