import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
// ★★ルート本体は**静的 import** すること★★ — `it()` の中で `await import()` すると、
// ★最初の1本だけがモジュール読み込み（`next/server` / ロガー等）を丸ごと抱え込み、
// フルスイート実行時に既定のタイムアウト（5秒）を踏んで★不定期に落ちます★
// （実測: 単体実行 2.8秒 / フルスイート 7.1秒で #1・#2 が不定期に赤）。
// ★`vi.mock()` は import より先に巻き上げられる★ので、静的 import でもスタブは効きます。
import { GET } from "@/app/api/clean-logs/route";
import { CLEAN_TIMETABLE_PRECHECK } from "@/lib/config";
import { db } from "@/lib/db";
import { consecutiveLookbackCalendarDays } from "@/lib/db/consecutive-source";
import { filterFixtureCleanLogs } from "@/lib/db/fixture-clean-logs";
import { guardNullRobotId } from "@/lib/db/__tests__/robot-error-null-guard";
import { getPrisma } from "@/lib/db/prisma";
import { logEvent } from "@/lib/logger";
import { loadConsecutiveDaysMax } from "@/lib/settings/display-limits";
import type { CleanLogItem, ListResponse } from "@/lib/types";
/**
* 指示書AC 段階2 の期待値表のうち、★★API ルートから `db` までを通した経路★★
* でなければ固定できないもの（★#6b / #6c / #6d / #6e / #7 / #8 / #9★）。
*
* ------------------------------------------------------------------------
* ★★なぜ解決関数の単体テストだけでは不十分なのか★★（指示書AC 期待値表 #6d）
* ------------------------------------------------------------------------
* ★ルートが `facility_ids` を `db.cleanLogs()` に渡し忘れていても、
* `facilityIdsMatchingName()` の単体テストは緑のままです★。
* ★★だからここでは「ルート → `db`（Prisma 実装）→ 発行されたクエリの `where`」まで
* 通して確かめます★★。
*
* ------------------------------------------------------------------------
* ★★DBには接続しません★★
* ------------------------------------------------------------------------
* `@/lib/db/prisma` の `getPrisma()` を ★スタブに差し替え★、
* `@/lib/db/use-fixtures` の `USE_FIXTURES` を ★`false`★ に固定して
* ★`prismaSource` の経路★ を走らせます（`lib/db/__tests__/consecutive-source.test.ts` と
* 同じ「DBに接続しないでDB実装を試す」作法）。
*
* ★★合成データを使う理由★★: ローカルDB（`dwatch_local`）では
* - ★`start_at` が深夜0〜3時にしか無く、`toDbJst()` の付け忘れを検出できない★（#7 / C-6）
* - ★論理削除された施設が0件で、罠7 を検出できない★（#6e。2026-09-13 実測）
*/
// ---------------------------------------------------------------- スタブ（DBの代わり）
/** `clean_timetables` の1行（★`include` 済みの形で持つ★） */
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;
device: { maker_id: number; model_name: string };
}[];
};
}
/**
* `clean_task_reports` の1行（★清掃実績の取得元。指示書AQ 決定2/3★）。
* ★`clean_error` 相当の列は無い★ — 未実施は「行が無い」で表す（指示書AQ §1-1）。
* ★`clean_timetable_id` / `ended_at` は nullable★（実DDL。指示書AQ 落とし穴1/3）
*/
interface StubReport {
clean_timetable_id: bigint | null;
clean_ratio: number;
/** ★生値（意味は第10回 N-2 で受領済み。判定には使わない。指示書AQ §1-2 / D-155 項2）★ */
status: number;
started_at: Date;
ended_at: Date | null;
clean_area: number;
task_area: number;
}
interface StubErrorReport {
clean_timetable_id: bigint | null;
error_type: string;
errored_at: Date;
/** ★DDL では NULL 可（第11回 P-8 b）。読まないこと（指示書AU 段階0-4）★ */
robot_id?: bigint | null;
}
interface StubFacility {
id: bigint;
facility_name: string;
/** ★論理削除★（`null` 以外なら削除済み） */
deleted_at: Date | null;
}
interface StubData {
timetables: StubTimetable[];
/** ★`clean_timetable_histories` の行（指示書AU 段階3b）。無ければ空★ */
historyTimetables?: StubTimetable[];
reports: StubReport[];
errorReports: StubErrorReport[];
facilities: StubFacility[];
}
/** `findMany()` に渡された引数の記録（★どんな `where` が発行されたかを検査する★） */
const calls: {
cleanTimetable: Record<string, unknown>[];
cleanTimetableHistory: Record<string, unknown>[];
cleanTaskReport: Record<string, unknown>[];
robotErrorReport: Record<string, unknown>[];
facility: Record<string, unknown>[];
} = { cleanTimetable: [], cleanTimetableHistory: [], cleanTaskReport: [], robotErrorReport: [], facility: [] };
let data: StubData;
/** 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;
if ("deleted_at" in c) {
// ★このスタブは `deleted_at` での絞り込みを**わざと**実装している★ —
// 罠7（解決用の読み取りに `where` を足してしまう）が起きたら結果が変わるように
if (c.deleted_at === null && value !== null) 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 applyOrderBy(
rows: Record<string, unknown>[],
orderBy: unknown
): Record<string, unknown>[] {
if (!Array.isArray(orderBy)) return rows;
return [...rows].sort((a, b) => {
for (const key of orderBy as Record<string, "asc" | "desc">[]) {
const [field, dir] = Object.entries(key)[0];
const av = a[field];
const bv = b[field];
const an = av instanceof Date ? av.getTime() : Number(av);
const bn = bv instanceof Date ? bv.getTime() : Number(bv);
if (an !== bn) return (an < bn ? -1 : 1) * (dir === "desc" ? -1 : 1);
}
return 0;
});
}
function findMany(
bucket: keyof typeof calls,
rows: Record<string, unknown>[],
args: Record<string, unknown> | undefined
) {
calls[bucket].push(args ?? {});
const filtered = rows.filter((row) => matchesWhere(row, args?.where));
const ordered = applyOrderBy(filtered, args?.orderBy);
return ordered.map((row) => project(row, args?.select));
}
vi.mock("@/lib/db/use-fixtures", () => ({ USE_FIXTURES: false }));
// ★事前チェックが3つ以上のときの `data.anomaly`（D-178）を見るため `logEvent` だけ差し替える★
// （`withRequestId` はそのまま使う。`app/api/clean-area/__tests__/route.test.ts` と同じ作法）
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
),
},
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);
return findMany("robotErrorReport", data.errorReports as unknown as Record<string, unknown>[], args);
},
},
facility: {
findMany: async (args?: Record<string, unknown>) =>
findMany("facility", data.facilities 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 = "ドソ・キホーテ戸塚";
/** ★論理削除された施設★（#6e / 罠7） */
const FACILITY_2 = "ドソ・キホーテ四街道";
const FACILITY_3 = "フレッシュタウン大和店";
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}`,
device: { maker_id: 1, model_name: "CC1" },
},
],
},
};
}
/**
* 実施済みの清掃1回ぶんのレポート行。
* ★未実施は行を作らないことで表す★（指示書AQ §1-1。旧 `clean_error = 1` の行は作らない）。
* `started_at` は `ended_at` の1時間前（どちらも壁時計値）。`status` は生値の一例（4）。
* ★完了率は面積から `runCompletionRate()` で決まる（D-155）★ので、`task_area = 1000` に対して
* `clean_area = cleanRatio × 10` とし、`clean_ratio` 列にも同じ値を入れる（列は完了率に使っていない。D6）。
*/
function report(timetableId: number, cleanRatio: number, endedJstIso: string): StubReport {
const endedAt = dbWallClock(endedJstIso);
return {
clean_timetable_id: BigInt(timetableId),
clean_ratio: cleanRatio,
status: 4,
started_at: new Date(endedAt.getTime() - 60 * 60 * 1000),
ended_at: endedAt,
clean_area: cleanRatio * 10,
task_area: 1000,
};
}
function buildData(): StubData {
return {
facilities: [
{ id: BigInt(1), facility_name: FACILITY_1, deleted_at: null },
// ★★論理削除済み★★ — ★清掃ログ側には行が残っている（`cleanLogs()` は
// `include: { facility: true }` で `deleted_at` を見ていない）★
{ id: BigInt(2), facility_name: FACILITY_2, deleted_at: dbWallClock("2026-09-01T00:00:00+09:00") },
{ id: BigInt(3), facility_name: FACILITY_3, deleted_at: null },
],
timetables: [
// 施設1: ★3日連続で×★（9/8・9/9・9/10）→ 9/10 の行の連続日数は ★3★
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"),
// 事前チェック行（★本清掃の子★）— `status_1h` / `status_30m` の材料
timetable(1031, 1, FACILITY_1, "2026-09-10T01:00:00+09:00", 60, 103),
timetable(1032, 1, FACILITY_1, "2026-09-10T01:30:00+09:00", 30, 103),
// 施設2（★論理削除された施設★）: 9/10 に1件
timetable(201, 2, FACILITY_2, "2026-09-10T02:00:00+09:00"),
// 施設3: ★★壁時計 20:00 の清掃★★（#7。★ローカルDBには1件も無い時間帯★）
timetable(301, 3, FACILITY_3, "2026-09-10T20:00:00+09:00"),
],
reports: [
report(101, 5, "2026-09-08T03:00:00+09:00"),
report(102, 5, "2026-09-09T03:00:00+09:00"),
report(103, 5, "2026-09-10T03:00:00+09:00"),
report(201, 95, "2026-09-10T03:00:00+09:00"),
report(301, 80, "2026-09-10T21:00:00+09:00"),
],
errorReports: [
{
clean_timetable_id: BigInt(1031),
error_type: "EmergencyStop",
errored_at: dbWallClock("2026-09-10T01:05:00+09:00"),
},
],
};
}
/** ★全行が過去になる基準時刻★（`isFutureSchedule()` の除外が効かない状態にする） */
const NOW = new Date("2026-09-30T00:00:00+09:00");
async function get(search: string): Promise<ListResponse<CleanLogItem>> {
const res = await GET(new Request(`http://localhost/api/clean-logs${search}`));
return (await res.json()) as ListResponse<CleanLogItem>;
}
/** 最後に発行された `clean_timetables` の本体クエリ（＝ `include` 付きの1本目） */
function mainQueryWhere(): Record<string, unknown> {
const call = calls.cleanTimetable.find((c) => "include" in c);
expect(call).toBeDefined();
return (call as { where: Record<string, unknown> }).where;
}
beforeEach(() => {
data = buildData();
calls.cleanTimetable = [];
calls.cleanTimetableHistory = [];
calls.cleanTaskReport = [];
calls.robotErrorReport = [];
calls.facility = [];
vi.mocked(logEvent).mockClear();
// ★`new Date()` を固定する（Date だけを差し替え、タイマーは触らない）★
vi.useFakeTimers({ toFake: ["Date"] });
vi.setSystemTime(NOW);
});
afterEach(() => {
vi.useRealTimers();
});
// ---------------------------------------------------------------- テスト
describe("GET /clean-logs — 日付・施設をSQLに降ろす（指示書AC 段階2）", () => {
it("#1 範囲なし → 本清掃の全件（★事前チェック行は並ばない★）", async () => {
const body = await get("");
expect(body.items.map((i) => i.id)).toEqual([301, 103, 201, 102, 101]);
expect(body.meta.total).toBe(5);
// ★本清掃の絞り込みが SQL に降りていること★
expect(mainQueryWhere().precheck).toBe(CLEAN_TIMETABLE_PRECHECK.main);
});
it("#2 日付範囲を指定すると SQL の `where` に `start_at` が降りる", async () => {
await get("?date_from=2026-09-09&date_to=2026-09-10");
const startAt = mainQueryWhere().start_at as { gte: Date; lt: Date };
// ★★`toDbJst()` を通した壁時計値であること★★（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("#3 `date_from = date_to` → その日の行だけ", async () => {
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
expect(body.items.map((i) => i.id)).toEqual([301, 103, 201]);
expect(body.meta.total).toBe(3);
});
it("#4 `date_from` がデータの最古日より前 → #1 と同じ件数", async () => {
const body = await get("?date_from=2000-01-01");
expect(body.meta.total).toBe(5);
});
it("#5 `date_from > date_to` は 422 で弾かれ、`db` まで来ない", async () => {
const res = await GET(
new Request("http://localhost/api/clean-logs?date_from=2026-09-10&date_to=2026-09-08")
);
expect(res.status).toBe(422);
// ★★クエリが1本も発行されていないこと★★
expect(calls.cleanTimetable).toHaveLength(0);
});
it("★#7 壁時計 20:00 の清掃が、その日の範囲に**含まれる**★（C-6。★ローカルDBでは検出できない★）", async () => {
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
const evening = body.items.find((i) => i.id === 301);
expect(evening).toBeDefined();
expect(evening?.scheduled_at).toBe("2026-09-10T20:00:00+09:00");
// ★前日・翌日の指定では出てこない★
expect((await get("?date_from=2026-09-09&date_to=2026-09-09")).items.map((i) => i.id)).not.toContain(301);
expect((await get("?date_from=2026-09-11&date_to=2026-09-11")).items.map((i) => i.id)).not.toContain(301);
});
it("★★#8 期間で絞っても `consecutive_problem_days` が全期間版と完全一致する★★（★C-2 の地雷★）", async () => {
// ★施設1 は 9/8・9/9・9/10 の3日連続で×★
const all = await get("");
const expected = new Map(all.items.map((i) => [i.id, i.consecutive_problem_days]));
expect(expected.get(103)).toBe(3);
// ★9/10 の1日だけを指定しても 3 のまま★
// ★★期間で絞った行から連続日数を数えると 1 になり、L3 が L1 に化ける★★
// （★例外もテスト失敗も出ない fail-silent★。だからこのテストが唯一の検出手段）
const oneDay = await get("?date_from=2026-09-10&date_to=2026-09-10");
for (const item of oneDay.items) {
expect(item.consecutive_problem_days).toBe(expected.get(item.id));
}
expect(oneDay.items.find((i) => i.id === 103)?.consecutive_problem_days).toBe(3);
expect(oneDay.items.find((i) => i.id === 103)?.escalation_level).toBe("L3");
});
it("★#8（構造）連続日数用のクエリは「表示期間 ＋ 上限ぶんの遡り」で絞る★（指示書AC 段階6）", async () => {
await get("?date_from=2026-09-10&date_to=2026-09-10");
// ★`loadConsecutiveInputs()` が発行する `select` 付きのクエリ★
const consecutiveCall = calls.cleanTimetable.find(
(c) => "select" in c && (c.select as Record<string, unknown>).facility_id === true
);
expect(consecutiveCall).toBeDefined();
// ★★表示期間の開始日（9/10）をそのまま下限にしたら連続が途切れる（C-2）★★ —
// 遡り幅は ★保存された表示上限★ から導く（★定数に写し取らないこと★。申し送り⑪）
const start = (consecutiveCall as { where: { start_at: { gte: Date; lt: Date } } })
.where.start_at;
const lookback = consecutiveLookbackCalendarDays(await loadConsecutiveDaysMax());
expect(start.gte.toISOString().slice(0, 10)).toBe(
new Date(Date.parse("2026-09-10T00:00:00Z") - lookback * 86_400_000)
.toISOString()
.slice(0, 10)
);
// ★上限側は表示期間の末日を含む（翌日 00:00 未満）★
expect(start.lt.toISOString()).toBe("2026-09-11T00:00:00.000Z");
});
});
describe("施設名 → 施設ID の解決（指示書AC C-1 / D-6）", () => {
it("★★#6d 記号違いで指定した施設名が解決され、SQL の `where` に施設IDで降りる★★", async () => {
const body = await get(`?facility_name=${encodeURIComponent("ドソキホーテ")}`);
// ★★ルートが `facility_ids` を渡していること（＝渡し忘れの検出）★★
expect(mainQueryWhere().facility_id).toEqual({ in: [1, 2] });
// ★★そのログがヒットすること★★（`ドソ・キホーテ戸塚` に `ドソキホーテ` で当たる）
expect(body.items.map((i) => i.id).sort((a, b) => a - b)).toEqual([101, 102, 103, 201]);
expect(body.items.every((i) => i.facility_name.startsWith("ドソ"))).toBe(true);
});
it("★★#6e 論理削除された施設の名前で検索しても、そのログが消えない★★（★罠7★）", async () => {
const body = await get(`?facility_name=${encodeURIComponent("四街道")}`);
// ★解決用の読み取りに `where` を足していないこと★（足すと施設2 が解決されない）
expect(calls.facility).toEqual([{ select: { id: true, facility_name: true } }]);
expect(mainQueryWhere().facility_id).toEqual({ in: [2] });
expect(body.items.map((i) => i.id)).toEqual([201]);
expect(body.meta.total).toBe(1);
});
it("★#6e（対照）`deleted_at` で絞ると施設2 が解決できなくなる★（流用してはいけない理由）", async () => {
// ★解決用の読み取りは論理削除された施設2 も返す★
expect((await db.facilityNameIndex()).map((f) => f.id)).toEqual([1, 2, 3]);
// ★対照★: `prismaSource.facilities()` が付けている `where: { deleted_at: null }` を
// 同じスタブに投げると ★施設2 が消える★ → その名前で検索してもログが引けなくなる
const prisma = (await getPrisma()) as unknown as {
facility: {
findMany(args: unknown): Promise<{ id: bigint }[]>;
};
};
const visible = await prisma.facility.findMany({
where: { deleted_at: null },
select: { id: true, facility_name: true },
});
expect(visible.map((f) => Number(f.id))).toEqual([1, 3]);
});
it("★★#6b 1件も当たらない施設名 → 0件★★（★`in: undefined` に化けていないことの検出。罠1★）", async () => {
const body = await get(`?facility_name=${encodeURIComponent("存在しない店名")}`);
// ★★`in: []` が渡っていること（`in: undefined` なら全件になる）★★
expect(mainQueryWhere().facility_id).toEqual({ in: [] });
expect(body.items).toEqual([]);
expect(body.meta.total).toBe(0);
});
it("★#6c 施設名を指定しない → `facility_id` の条件を付けない（全件）★", async () => {
const body = await get("");
// ★★`in: []` を渡さないこと★★ — 渡すと施設名未指定で0件になる
expect(mainQueryWhere()).not.toHaveProperty("facility_id");
expect(body.meta.total).toBe(5);
// ★施設名が空なら施設マスタを読みにいかない（余計な往復を増やさない）★
expect(calls.facility).toEqual([]);
});
it("★機種・シリアルは据え置き（SQL に降ろさずメモリで絞る）★", async () => {
const body = await get("?serial=8111R56280600");
expect(mainQueryWhere()).not.toHaveProperty("section");
expect(body.meta.total).toBe(5);
});
});
describe("関連テーブルの引き直し（指示書AC 段階2 D-4 / §E-5）", () => {
it("★履歴は本清掃の id、エラー報告は事前チェック行の id で引く（全件読みに戻さない）★", async () => {
await get("?date_from=2026-09-10&date_to=2026-09-10");
// ★`select` の無い1本 ＝ `cleanLogs()` 本体の引き直し★（`select` 付きは連続日数用。
// 取得元が `clean_task_reports` になって連続日数用も `where` を持つので、`where` だけでは区別できない）
const reportCall = calls.cleanTaskReport.find((c) => "where" in c && !("select" in c));
expect(reportCall).toBeDefined();
const historyWhere = (
reportCall as {
where: { clean_timetable_id: { in: bigint[] } };
}
).where;
expect(historyWhere.clean_timetable_id.in.map(String).sort()).toEqual(
["103", "201", "301"].sort()
);
const errorWhere = (
calls.robotErrorReport[0] as { where: { clean_timetable_id: { in: bigint[] } } }
).where;
expect(errorWhere.clean_timetable_id.in.map(String).sort()).toEqual(
["1031", "1032"].sort()
);
});
it("★事前チェック行は `parent_id` で別クエリに分けて引く★", async () => {
await get("?date_from=2026-09-10&date_to=2026-09-10");
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,
});
});
it("★本清掃が0件ならクエリを1本も撃たない★（`chunkForInClause([])` が空を返す）", async () => {
const body = await get("?date_from=2026-01-01&date_to=2026-01-02");
expect(body.items).toEqual([]);
expect(calls.robotErrorReport).toEqual([]);
// ★レポートの引き直しは0本（本清掃・連続日数用とも `in` の塊が0個）★
expect(calls.cleanTaskReport.filter((c) => "where" in c)).toEqual([]);
});
});
describe("清掃結果 `task_status` の取得元（指示書AQ §1-1 / §1-2 / §5-2 / 落とし穴1）", () => {
it("★`clean_task_reports.status` の生値をそのまま返す（変換しない）★", async () => {
data.reports = data.reports.map((r) =>
r.clean_timetable_id === BigInt(201) ? { ...r, status: 6 } : r
);
const body = await get("");
expect(body.items.find((i) => i.id === 201)?.task_status).toBe(6);
expect(body.items.find((i) => i.id === 103)?.task_status).toBe(4);
});
it("★レポートの行が無い本清掃 → `task_status` は null・出発失敗・完了率 null★（§1-1）", async () => {
data.reports = data.reports.filter((r) => r.clean_timetable_id !== BigInt(201));
const body = await get("");
const item = body.items.find((i) => i.id === 201);
// ★行ごと消えない（出発失敗として出る）★
expect(item).toBeDefined();
expect(item?.task_status).toBeNull();
expect(item?.departed).toBe(false);
expect(item?.completion_rate).toBeNull();
});
it("★★`clean_timetable_id` が NULL のレポートはどの清掃にも紐づかない★★（落とし穴1）", async () => {
data.reports = data.reports.map((r) =>
r.clean_timetable_id === BigInt(201) ? { ...r, clean_timetable_id: null } : r
);
const body = await get("");
const item = body.items.find((i) => i.id === 201);
expect(item).toBeDefined();
expect(item?.task_status).toBeNull();
expect(item?.departed).toBe(false);
// ★他の清掃の結果を上書きしない★
expect(body.items.find((i) => i.id === 301)?.completion_rate).toBe(80);
});
});
describe("★#9 fixtures 版と Prisma 版が同じ引数で同じ結果を返す★（指示書AC D-5 / 禁止事項6）", () => {
/**
* ★同じデータに対して★、
* - Prisma 版 = ★SQL で絞った結果★
* - fixtures 版 = ★全件版 + `filterFixtureCleanLogs()`★
* を突き合わせる（指示書AC G-3「等価テスト」）。
* ★`null` と `[]` の両方で比べること★（罠9）。
*/
it("日付範囲: SQL版 ＝ 全件版 + fixtures 版の絞り込み", async () => {
const all = await get("");
const sql = await get("?date_from=2026-09-09&date_to=2026-09-10");
const viaFixtures = filterFixtureCleanLogs(all.items, {
id: null,
date_from: "2026-09-09",
date_to: "2026-09-10",
facility_ids: null,
});
expect(sql.items).toEqual(viaFixtures);
expect(sql.items.length).toBeGreaterThan(0);
});
it("`facility_ids: null`（施設名なし）: 件数が一致", async () => {
const all = await get("");
expect(
filterFixtureCleanLogs(all.items, {
id: null,
date_from: null,
date_to: null,
facility_ids: null,
})
).toHaveLength(all.items.length);
});
it("★`facility_ids: []`: どちらも0件★（★片方だけ全件に化けないこと★）", async () => {
const all = await get("");
const sql = await get(`?facility_name=${encodeURIComponent("存在しない店名")}`);
const viaFixtures = filterFixtureCleanLogs(all.items, {
id: null,
date_from: null,
date_to: null,
facility_ids: [],
});
expect(sql.items).toEqual([]);
expect(viaFixtures).toEqual([]);
});
it("施設IDで絞った場合も一致", async () => {
const all = await get("");
const sql = await get(`?facility_name=${encodeURIComponent("ドソキホーテ")}`);
const viaFixtures = filterFixtureCleanLogs(all.items, {
id: null,
date_from: null,
date_to: null,
facility_ids: [1, 2],
});
expect(sql.items).toEqual(viaFixtures);
});
});
describe("GET /clean-logs — robot_id が NULL のエラー行（指示書AU 段階0-4。第11回 P-8 b）", () => {
it("★robot_id が NULL の行を混ぜても落ちず、同じ行が出る★（select で robot_id / robot を読まない）", async () => {
const before = await get("");
data.errorReports = data.errorReports.map((r) => ({ ...r, robot_id: null }));
const res = await GET(new Request("http://localhost/api/clean-logs"));
expect(res.status).toBe(200);
const after = (await res.json()) as ListResponse<CleanLogItem>;
expect(after.items).toEqual(before.items);
});
});
describe("GET /clean-logs — 予定を2表から読む（指示書AU 段階3b。第11回 P-7）", () => {
it("★履歴だけの予定が出る・両方にある同じ予定は1件★。2表に同じ引数が渡る", async () => {
data.historyTimetables = [
// ★履歴だけの本清掃（9/11）とその事前チェック行★
timetable(401, 3, FACILITY_3, "2026-09-11T02:00:00+09:00"),
timetable(4011, 3, FACILITY_3, "2026-09-11T01:00:00+09:00", 60, 401),
// ★両方にある同じ予定（中身も同じ）★
timetable(103, 1, FACILITY_1, "2026-09-10T02:00:00+09:00"),
];
data.reports.push(report(401, 80, "2026-09-11T03:00:00+09:00"));
const body = await get("");
expect(body.items.map((i) => i.id)).toEqual([401, 301, 103, 201, 102, 101]);
expect(body.items.find((i) => i.id === 401)?.completion_rate).toBe(80);
// ★本清掃の主クエリ（`include` 付き）は2表に同じ引数★
const mainCall = calls.cleanTimetable.find((c) => "include" in c);
const historyCall = calls.cleanTimetableHistory.find((c) => "include" in c);
expect(historyCall).toEqual(mainCall);
// ★事前チェック行は合わせた後の本清掃の id（履歴の 401 を含む）で引く★
const precheckHistoryCall = calls.cleanTimetableHistory.find(
(c) => "where" in c && "parent_id" in (c.where as object)
) as { where: { parent_id: { in: bigint[] } } };
expect(precheckHistoryCall.where.parent_id.in.map(String)).toContain("401");
});
});
describe("GET /clean-logs — 結果待ち `result_pending`（D-173。表1・表2 C1）", () => {
// ★施設2の 9/10 02:00〜03:00 の清掃（id 201）からレポートを外し、now を動かす★
beforeEach(() => {
data.reports = data.reports.filter((r) => r.clean_timetable_id !== BigInt(201));
});
it("★now=04:59（終了＋120分より前）→ R: `result_pending: true`。出発失敗の値は変えない★", async () => {
vi.setSystemTime(new Date("2026-09-10T04:59:00+09:00"));
const body = await get("");
const item = body.items.find((i) => i.id === 201);
expect(item).toMatchObject({
result_pending: true,
departed: false,
task_status: null,
completion_rate: null,
grade: "×",
});
// ★レポートがある行（S）は false★
expect(body.items.find((i) => i.id === 103)?.result_pending).toBe(false);
// ★結果待ちは連続日数に数えない（表2 C10）★
expect(item?.consecutive_problem_days).toBe(0);
expect(item?.escalation_level).toBeNull();
});
it("★now=05:00（終了＋120分ちょうど）→ F: `result_pending: false`（確定した出発失敗。表1 P6）★", async () => {
vi.setSystemTime(new Date("2026-09-10T05:00:00+09:00"));
const body = await get("");
const item = body.items.find((i) => i.id === 201);
expect(item).toMatchObject({ result_pending: false, departed: false, completion_rate: null });
expect(item?.consecutive_problem_days).toBe(1);
});
it("★清掃中（now=02:30。開始以降・終了前）も結果待ち（表1 P4）★", async () => {
vi.setSystemTime(new Date("2026-09-10T02:30:00+09:00"));
const body = await get("");
expect(body.items.find((i) => i.id === 201)?.result_pending).toBe(true);
});
});
describe("GET /clean-logs — 事前チェックの列は分数ではなく順番で割り当てる（D-178。ユーザー判断 2026-10-16）", () => {
// ★本清掃 103 の事前チェック行（1031: 60分前・EmergencyStop / 1032: 30分前・エラー無し）の分数だけを差し替える★
function setPrecheckMinutes(byId: Record<number, number>): void {
data.timetables = data.timetables.map((t) =>
byId[Number(t.id)] === undefined ? t : { ...t, precheck: byId[Number(t.id)] }
);
}
async function row103(): Promise<CleanLogItem> {
const r = (await get("")).items.find((i) => i.id === 103);
if (!r) throw new Error("清掃 103 が無い");
return r;
}
function precheckAnomalies() {
return vi
.mocked(logEvent)
.mock.calls.filter(
([, p]) => p.event === "data.anomaly" && p.metric === "precheck_rounds_per_main_run"
);
}
it("60 / 30（設定どおり）→ 1回目 EmergencyStop・60、2回目 Standby.・30", async () => {
const r = await row103();
expect(r).toMatchObject({
status_1h: "EmergencyStop",
status_1h_minutes: 60,
status_30m: "Standby.",
status_30m_minutes: 30,
});
expect(precheckAnomalies()).toHaveLength(0);
});
it("★60 / 10（設定と違う分数）でも10分前の結果を落とさない★（旧: 2列目が null で「-」だった）", async () => {
setPrecheckMinutes({ 1032: 10 });
expect(await row103()).toMatchObject({
status_1h: "EmergencyStop",
status_1h_minutes: 60,
status_30m: "Standby.",
status_30m_minutes: 10,
});
});
it("★事前チェックが1回（30分前）だけなら1回目に入り、2回目は null★", async () => {
data.timetables = data.timetables.filter((t) => Number(t.id) !== 1031);
expect(await row103()).toMatchObject({
status_1h: "Standby.",
status_1h_minutes: 30,
status_30m: null,
status_30m_minutes: null,
});
});
it("事前チェックの無い本清掃は4つとも null", async () => {
const r = (await get("")).items.find((i) => i.id === 101);
expect(r).toMatchObject({
status_1h: null,
status_1h_minutes: null,
status_30m: null,
status_30m_minutes: null,
});
});
it("★3つあれば開始に近い2つを残し、捨てた分数を `data.anomaly` に1回出す★（route / method は載せない）", async () => {
data.timetables.push(timetable(1033, 1, FACILITY_1, "2026-09-10T00:30:00+09:00", 90, 103));
expect(await row103()).toMatchObject({
status_1h: "EmergencyStop",
status_1h_minutes: 60,
status_30m: "Standby.",
status_30m_minutes: 30,
});
const events = precheckAnomalies();
expect(events).toHaveLength(1);
expect(events[0][0]).toBe("warn");
expect(events[0][1]).toEqual({
event: "data.anomaly",
metric: "precheck_rounds_per_main_run",
expected: 2,
actual: 3,
clean_timetable_id: "103",
dropped_precheck_minutes: [90],
});
});
it("★判定（出発・完了率・判定）は事前チェックの割り当てで変わらない★（D-170）", async () => {
const before = await row103();
setPrecheckMinutes({ 1031: 2, 1032: 1 });
const after = await row103();
expect(after).toMatchObject({ status_1h_minutes: 2, status_30m_minutes: 1 });
expect({
departed: after.departed,
completion_rate: after.completion_rate,
grade: after.grade,
consecutive_problem_days: after.consecutive_problem_days,
}).toEqual({
departed: before.departed,
completion_rate: before.completion_rate,
grade: before.grade,
consecutive_problem_days: before.consecutive_problem_days,
});
});
});
