import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
// ★★ルート本体は**静的 import** すること★★（`app/api/clean-logs/__tests__/route.test.ts` 冒頭の
// 理由と同じ。`it()` の中で `await import()` するとフルスイートでタイムアウトを踏む）
import { GET } from "@/app/api/dashboard/route";
import { CLEAN_TIMETABLE_PRECHECK } from "@/lib/config";
import type { DashboardResponse } from "@/lib/types";
/**
* GET /dashboard が ★その1日ぶんだけ★ を引いていることを固定する（指示書AC 段階2 D-6）。
* ★`date` 省略（＝直近モード。D-159 / 指示書AV）では、表3 の窓（8日ぶん）に絞られていること★と、
* 直近モードの `summary` / `problem_logs` / メタの `where` も固定する（ファイル末尾の `describe`）。
*
* ------------------------------------------------------------------------
* ★★何を守るためのテストか★★
* ------------------------------------------------------------------------
* ★`?date=`（★値が空★）のときに ★全件読みへ戻らない★ こと★。
* `const date = dateRaw ?? todayJst()` と書くと ★`""` は null でも undefined でもない★ ため
* ★空文字がそのまま残り★、`db.cleanLogs({ date_from: "", date_to: "" })` が
* `dbDateRange("", "")` を通って ★`start_at` の条件ごと消え＝テーブル全件読み★ になります
* （本番想定で `clean_timetables` 約26万行）。
* ★★レスポンスは後段の日付一致（`logsOfDay`）で空になるので画面からは観測できません★★ —
* ★このテストが唯一の検出手段★です。
*
* ------------------------------------------------------------------------
* ★★DBには接続しません★★
* ------------------------------------------------------------------------
* `@/lib/db/use-fixtures` の `USE_FIXTURES` を ★`false`★ に固定して
* ★`prismaSource` の経路★ を走らせる（段階2 / 段階4 のルートテストと同じ作法）。
*
* ★★ただしスタブの入れ方だけが兄弟テストと違います★★ —
* 兄弟（`/clean-logs` / `/prechecks`）は `vi.mock("@/lib/db/prisma")` で `getPrisma()` を
* 差し替えていますが、★このルートは3つのデータ源を `Promise.all` で**同時に**引きます★。
* `prismaSource` の各メソッドは `await import("./prisma")` の★遅延読み込み★なので
* （`lib/db/prisma.ts` 冒頭の理由）、★★同じモジュールへの動的 import が同時に走ると
* 一部が差し替え前の実体を掴み★★、`DATABASE_URL` 未設定で 500 になります（実測）。
* そこで ★`getPrisma()` が最初に見るシングルトン `globalThis.__dwatchPrisma` に
* 直接スタブを置きます★ — ★実装（`lib/db/prisma.ts`）の公開された仕組みをそのまま使うので
* DBにも接続しません★。★`afterEach` で必ず片付けること★。
*/
// ---------------------------------------------------------------- スタブ（DBの代わり）
interface StubTimetable {
id: bigint;
facility_id: bigint;
section_id: bigint;
parent_id: bigint;
start_at: Date;
/** ★予定の終了★（直近モードの `cleanLogRunMeta()` が読む。指示書AV 段階4-5。開始＋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`★（指示書AQ 決定2/3。旧 `clean_status_histories`）。
* ★`clean_error` 列は無い★ — 未実施は「行が無い」で表す（指示書AQ §1-1）。
* `clean_timetable_id` / `ended_at` は nullable（指示書AQ 罠1 / 罠3）。
*/
interface StubReport {
clean_timetable_id: bigint | null;
clean_ratio: number;
status: number;
started_at: Date;
ended_at: Date | null;
clean_area: number;
task_area: number;
}
interface StubData {
timetables: StubTimetable[];
reports: StubReport[];
}
/** `findMany()` に渡された引数の記録（★どんな `where` が発行されたかを検査する★） */
const calls: {
cleanTimetable: Record<string, unknown>[];
cleanTimetableHistory: Record<string, unknown>[];
cleanTaskReport: Record<string, unknown>[];
} = { cleanTimetable: [], cleanTimetableHistory: [], cleanTaskReport: [] };
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;
} 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 }));
/** `getPrisma()` が最初に見るシングルトンへ差し込むスタブ（上の「スタブの入れ方」を参照） */
function prismaStub(): typeof globalThis.__dwatchPrisma {
return {
cleanTimetable: {
findMany: async (args?: Record<string, unknown>) =>
findMany("cleanTimetable", data.timetables as unknown as Record<string, unknown>[], args),
},
// ★`clean_timetable_histories`（指示書AU 段階3b）。★このテストでは空★（2表に同じ引数が渡ることだけ見る）
cleanTimetableHistory: {
findMany: async (args?: Record<string, unknown>) => findMany("cleanTimetableHistory", [], args),
},
cleanTaskReport: {
findMany: async (args?: Record<string, unknown>) =>
findMany("cleanTaskReport", data.reports as unknown as Record<string, unknown>[], args),
},
// ★要レスキュー（指示書AI 段階5）が施設名の解決に使う★
// （`loadFacilityNameIndex()`。★`where` を付けない＝全件★）
facility: {
findMany: async () => [
{ id: BigInt(1), facility_name: FACILITY_1 },
{ id: BigInt(2), facility_name: FACILITY_2 },
],
},
// ★このテストで中身は要らない（`db.cleanLogs()` の `where` だけを見る）★
robotErrorReport: { findMany: async () => [] },
cleanSchedule: { findMany: async () => [] },
controlErrorHistory: { findMany: async () => [] },
} as unknown as typeof globalThis.__dwatchPrisma;
}
// ---------------------------------------------------------------- 合成データ
/** 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 = "バリューマート北町店";
/** ★対象日に清掃予定が無い施設★（要レスキューの検証用。指示書AI §1-5） */
const FACILITY_2 = "メガバリューマート緑野店";
function timetable(id: number, facilityId: number, jstIso: string): StubTimetable {
return {
id: BigInt(id),
facility_id: BigInt(facilityId),
section_id: BigInt(facilityId * 10),
parent_id: BigInt(0),
start_at: dbWallClock(jstIso),
// ★開始＋1時間★（壁時計値のまま足す。直近モードの「終わった」の判定に使う。指示書AV 段階4-5）
end_at: new Date(dbWallClock(jstIso).getTime() + 60 * 60_000),
precheck: CLEAN_TIMETABLE_PRECHECK.main,
facility: { facility_name: FACILITY_1 },
section: {
robots: [
{
serial_number: `8111R56280600${facilityId}`,
device: { maker_id: 1, model_name: "CC1" },
},
],
},
};
}
function report(timetableId: number, cleanRatio: number, jstIso: string): StubReport {
return {
clean_timetable_id: BigInt(timetableId),
clean_ratio: cleanRatio,
// ★意味を持たない任意の生値★（CSV実測で最頻の値。status は判定に使わない。D-155 項2）。
// ★未実施の判定には使われない★（行の有無で決まる。§1-1）
status: 4,
started_at: dbWallClock(jstIso),
ended_at: dbWallClock(jstIso),
clean_area: 100,
task_area: 100,
};
}
function buildData(): StubData {
return {
timetables: [
timetable(101, 1, "2026-09-28T02:00:00+09:00"),
timetable(102, 1, "2026-09-29T02:00:00+09:00"),
// ★`NOW` と同じ日（`todayJst()` が返す日）★
timetable(103, 1, "2026-09-30T02:00:00+09:00"),
// ★★施設2は 09-27〜09-29 が3日連続で未実施、当日（09-30）には予定が無い★★
// （レポートの行を作らない＝未実施。`notExecutedFromReport()`。指示書AQ §1-1）—
// ★要レスキューが「当該日のログ」で母集団を絞っていないことの検証用★（指示書AI §1-5）
timetable(201, 2, "2026-09-27T02:00:00+09:00"),
timetable(202, 2, "2026-09-28T02:00:00+09:00"),
timetable(203, 2, "2026-09-29T02:00:00+09:00"),
],
reports: [
report(101, 95, "2026-09-28T03:00:00+09:00"),
report(102, 95, "2026-09-29T03:00:00+09:00"),
report(103, 95, "2026-09-30T03:00:00+09:00"),
],
};
}
/** ★JST の 2026-09-30★（`todayJst()` がこの日を返す） */
const NOW = new Date("2026-09-30T09:00:00+09:00");
const TODAY = "2026-09-30";
async function get(search: string): Promise<DashboardResponse> {
const res = await GET(new Request(`http://localhost/api/dashboard${search}`));
return (await res.json()) as DashboardResponse;
}
/** 最後に発行された `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;
}
/** ★その1日ぶんに絞られているか★ を「壁時計値の範囲」で確かめる */
function expectSingleDayRange(where: Record<string, unknown>, date: string): void {
expectDayRange(where, date, date);
}
/** ★`from`〜`to`（両端を含む）に絞られているか★ を「壁時計値の範囲」で確かめる */
function expectDayRange(where: Record<string, unknown>, from: string, to: string): void {
expect(where).toHaveProperty("start_at");
const startAt = where.start_at as { gte: Date; lt: Date };
// ★★`toDbJst()` を通した壁時計値であること★★（C-6。★生の `parseDate()` ではない★）
expect(startAt.gte.toISOString()).toBe(`${from}T00:00:00.000Z`);
expect(startAt.lt.toISOString()).toBe(
new Date(Date.parse(`${to}T00:00:00.000Z`) + 86_400_000).toISOString()
);
}
/** ★直近モードの窓（指示書AV 表3 W4。`NOW` = 2026-09-30 09:00 JST）★ */
const LATEST_WINDOW = { from: "2026-09-23", to: TODAY } as const;
/**
* ★メタ（`cleanLogRunMeta()`）の呼び出し★ ＝ `select` のキーがちょうど `id` / `section_id` / `end_at` の3つ。
* ★「`select` 付き」だけでは見分けられない★ — 要レスキュー（`loadConsecutiveInputs()` など）も
* `cleanTimetable.findMany` を `select` 付きで呼ぶ（指示書AV 段階4-5）。
*/
function metaCalls(): Record<string, unknown>[] {
return calls.cleanTimetable.filter((c) => {
const select = c.select as Record<string, unknown> | undefined;
return select !== undefined && Object.keys(select).sort().join(",") === "end_at,id,section_id";
});
}
beforeEach(() => {
data = buildData();
calls.cleanTimetable = [];
calls.cleanTimetableHistory = [];
calls.cleanTaskReport = [];
globalThis.__dwatchPrisma = prismaStub();
// ★`new Date()` を固定する（Date だけを差し替え、タイマーは触らない）★
vi.useFakeTimers({ toFake: ["Date"] });
vi.setSystemTime(NOW);
});
afterEach(() => {
// ★★他のテストへ漏らさないこと★★（`getPrisma()` はここを最初に見る）
globalThis.__dwatchPrisma = undefined;
vi.useRealTimers();
});
// ---------------------------------------------------------------- テスト
describe("GET /dashboard — その1日ぶんだけを引く（指示書AC 段階2 D-6）", () => {
it("`date` を指定すると SQL の `where` にその1日の `start_at` が降りる", async () => {
await get("?date=2026-09-29");
expectSingleDayRange(mainQueryWhere(), "2026-09-29");
});
it("★予定は2表から読み、履歴にも同じ引数が渡る★（指示書AU 段階3b。第11回 P-7）", async () => {
await get("?date=2026-09-29");
const mainCall = calls.cleanTimetable.find((c) => "include" in c);
expect(calls.cleanTimetableHistory.find((c) => "include" in c)).toEqual(mainCall);
});
it("直近モード（`date` 省略）は表3 W4 の窓（2026-09-23〜2026-09-30）で `start_at` が絞られる（指示書AV）", async () => {
await get("");
expectDayRange(mainQueryWhere(), LATEST_WINDOW.from, LATEST_WINDOW.to);
});
it("★★`?date=`（★空文字★）でも直近モードの窓に倒れ、全件読みに戻らない★★", async () => {
// ★`??` で書くと `""` がそのまま残り、`start_at` のキーごと消えて
// ★テーブル全件読み★ になる（本番想定で約26万行）。
// ★★レスポンスからは観測しにくい★★ので、★`start_at` の条件が消えないこと★をここで見る
const body = await get("?date=");
expectDayRange(mainQueryWhere(), LATEST_WINDOW.from, LATEST_WINDOW.to);
// ★当日の行（103）が拾えていること＝空振りしていないこと★
const { success, failed, not_executed } = body.summary;
expect(success + failed + not_executed).toBeGreaterThan(0);
});
it("★`?date=` と `date` 省略が同じ結果になる★", async () => {
const omitted = await get("");
const empty = await get("?date=");
expect(empty).toEqual(omitted);
});
it("形式が不正な `date` は 422 で弾かれ、`db` まで来ない", async () => {
const res = await GET(new Request("http://localhost/api/dashboard?date=2026/09/30"));
expect(res.status).toBe(422);
expect(calls.cleanTimetable).toHaveLength(0);
expect(calls.cleanTimetableHistory).toHaveLength(0);
});
});
describe("GET /dashboard — 要レスキュー店舗（指示書AI 段階5）", () => {
it("★当該日に清掃予定が無い施設も出る（評価日は直前のスケジュール存在日）★", async () => {
const body = await get(`?date=${TODAY}`);
// ★施設2は 09-30 に予定が無い★ — 当該日のログで母集団を絞っていたら消える
expect(body.rescue_required).toHaveLength(1);
expect(body.rescue_required[0]).toMatchObject({
facility_id: 2,
facility_name: FACILITY_2,
evaluated_on: "2026-09-29",
reasons: ["not_executed_streak", "escalation_l3"],
not_executed_days: 3,
consecutive_problem_days: 3,
});
});
it("★数値カード（summary）は要レスキューの影響を受けない★", async () => {
const body = await get(`?date=${TODAY}`);
// ★当日のログは施設1の1行だけ★（施設2の未実施3日は分母に入らない。ユーザー指示 2026-09-15）
const { success, failed, not_executed } = body.summary;
expect([success, failed, not_executed]).toEqual([1, 0, 0]);
});
it("要レスキューが0件でも `rescue_required` のキーは落とさない", async () => {
// ★施設2の3日連続が始まる前の日を指定する★（＝どの施設も条件に当たらない）
const body = await get("?date=2026-09-28");
expect(body.rescue_required).toEqual([]);
});
});
describe("GET /dashboard — 直近モード（D-159 / 指示書AV 段階4-5）", () => {
// ★期待値は指示書AV で導いた値（§11 Q10 で監督が確定）★:
// 施設1（エリア10）は 09-30 02:00〜03:00 が一番新しい終わった予定 ＝ 成功（完了率100）。
// 施設2（エリア20）は 09-29 02:00〜03:00 ＝ レポートが無い ＝ 未実施。
it("summary は各清掃エリアの直近の清掃（成功1・未実施1）", async () => {
const body = await get("");
expect(body.summary).toEqual({ success: 1, failed: 0, not_executed: 1, pending: 0, success_rate: 50 });
});
it("同じデータで `?date=2026-09-30` はその日の行だけ（[1, 0, 0] のまま）", async () => {
const body = await get(`?date=${TODAY}`);
const { success, failed, not_executed } = body.summary;
expect([success, failed, not_executed]).toEqual([1, 0, 0]);
});
it("problem_logs は直近モードで施設2の 09-29 の1行だけ。`?date=2026-09-30` では []", async () => {
const latest = await get("");
expect(latest.problem_logs.map((r) => r.id)).toEqual([203]);
expect(latest.problem_logs[0]).toMatchObject({
facility_id: 2,
scheduled_at: "2026-09-29T02:00:00+09:00",
departed: false,
// ★`capCleanLogs()` を通っている★（指示書AV D13）
consecutive_problem_days_capped: false,
});
const ofDay = await get(`?date=${TODAY}`);
expect(ofDay.problem_logs).toEqual([]);
});
it("★メタの `where` は清掃ログ（`include` 付きの1本目）の `where` と同じ★（4-8）", async () => {
await get("");
const meta = metaCalls();
expect(meta).toHaveLength(1);
expect(meta[0].where).toEqual(mainQueryWhere());
});
it("★`?date=2026-09-29` ではメタを読まない★（0回）", async () => {
await get("?date=2026-09-29");
expect(metaCalls()).toHaveLength(0);
});
it("★schedule_progress は直近モードと `?date=2026-09-30` で同じ★（当日のまま。4-1）", async () => {
const latest = await get("");
const ofDay = await get(`?date=${TODAY}`);
expect(latest.schedule_progress).toEqual(ofDay.schedule_progress);
});
});
/**
* ★結果待ち（D-173。ユーザー判断 2026-10-07）★ — 表2 C6・C7（監督確定）。
* `NOW` = 09-30 09:00。★施設3の 09-30 07:30〜08:30 にレポートが無い★ —
* ★終了＋`RESULT_WAIT_MINUTES`（120分）＝ 10:30 より前なので結果待ち★（`isResultPending()` 表1 P5 と同じ形）。
* ★終了（08:30）≤ 現在（09:00）なので直近の候補になる★（C6。30分待ちはやめた）。
* ★`result_pending` はデータソース（`prismaSource.cleanLogs()`）が詰める★ — ここでは数え方と `problem_logs` だけを見る。
*/
describe("GET /dashboard — 結果待ち（表2 C6・C7。D-173）", () => {
beforeEach(() => {
data.timetables.push(timetable(301, 3, "2026-09-30T07:30:00+09:00"));
});
it("C6 直近モード: 施設3の結果待ちは pending に数え、未実施・成功率の分母に入れない", async () => {
const body = await get("");
expect(body.summary).toEqual({ success: 1, failed: 0, not_executed: 1, pending: 1, success_rate: 50 });
});
it("C7 problem_logs に結果待ちの行を出さない（確定した出発失敗 203 は今までどおり出す）", async () => {
const body = await get("");
expect(body.problem_logs.map((r) => r.id)).toEqual([203]);
});
it("C5・C7 `?date=2026-09-30` でも同じ（pending 1・problem_logs は空）", async () => {
const body = await get(`?date=${TODAY}`);
expect(body.summary).toEqual({ success: 1, failed: 0, not_executed: 0, pending: 1, success_rate: 100 });
expect(body.problem_logs).toEqual([]);
});
});
