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, D_SEC_ALERT_ERROR_TYPES } from "@/lib/config";
import { db } from "@/lib/db";
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 { ROBOT_ERROR_DS_ALERT_SELECT } from "@/lib/db/robot-error-select";
import { dsAlertWhere } from "@/lib/db/ds-alert-mapping";
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;
/** ★`deleted_at` は可視性（`FACILITY_SECTION_VISIBLE_WHERE`）の再現用★（指示書BB U1） */
facility: { facility_name: string; deleted_at: Date | null };
section: {
deleted_at: Date | null;
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[];
/** `robot_error_reports` のうち D-Sec アラートの読み取りに返す行（既定は空） */
dsAlertRows: Record<string, unknown>[];
}
/** `findMany()` に渡された引数の記録（★どんな `where` が発行されたかを検査する★） */
const calls: {
cleanTimetable: Record<string, unknown>[];
cleanTimetableHistory: Record<string, unknown>[];
cleanTaskReport: Record<string, unknown>[];
cleanSchedule: Record<string, unknown>[];
} = { cleanTimetable: [], cleanTimetableHistory: [], cleanTaskReport: [], cleanSchedule: [] };
let data: StubData;
/** D-Sec アラートの読み取りの `where`（指示書BB 表10 N7） */
let dsAlertWheres: unknown[] = [];
/** 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;
// ★リレーションの条件（`facility: { deleted_at: null }` など。可視性 U1）★ — 行が結合先を持つときだけ再現する
// （持たない行＝結合先を `include` しない読み取りは、従来どおり素通し）
if (!("in" in c) && !("gte" in c) && !("lt" in c) && value !== null && typeof value === "object" && !(value instanceof Date)) {
if (!matchesWhere(value as Record<string, unknown>, c)) 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 A2）を見るため `logEvent` だけ差し替える（`withRequestId` はそのまま）★
vi.mock("@/lib/logger", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/lib/logger")>();
return { ...actual, logEvent: vi.fn() };
});
/** `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` だけを見る）★。
// ★D-Sec アラート（`dsAlerts()`）の読み取りにだけ `dsAlertRows` を返す★（`where` を無視。指示書AX 表1 R10）
robotErrorReport: {
findMany: async (args?: Record<string, unknown>) => {
if (args?.select !== ROBOT_ERROR_DS_ALERT_SELECT) return [];
dsAlertWheres.push(args.where);
guardNullRobotId(data.dsAlertRows as unknown as Record<string, unknown>[], args);
return data.dsAlertRows;
},
},
// ★`clean_schedules`（`schedules()`）。★ダッシュボードはもう読まない★（2026-10-29 案B）— 読まれたら記録に残る（S7）★
cleanSchedule: {
findMany: async (args?: Record<string, unknown>) => {
calls.cleanSchedule.push(args ?? {});
return [];
},
},
// ★`controlErrorHistory` は置かない★ — D-Sec アラートは `robot_error_reports` から読む（指示書AX。P-10 = A）
} 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, deleted_at: null },
section: {
deleted_at: null,
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"),
],
dsAlertRows: [],
};
}
/** ★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 = [];
calls.cleanSchedule = [];
dsAlertWheres = [];
globalThis.__dwatchPrisma = prismaStub();
vi.mocked(logEvent).mockClear();
// ★`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("★E1′: メタが1行ぶん欠けても 200。その行は選ばれず、`data.anomaly` を1回（row_ids つき）★（指示書BB A2）", async () => {
// ★`cleanLogs()` と `cleanLogRunMeta()` の間に行が増えた状態★ — 施設1の 09-30（103）のメタだけ返さない
const original = db.cleanLogRunMeta.bind(db);
const spy = vi
.spyOn(db, "cleanLogRunMeta")
.mockImplementation(async (query) => (await original(query)).filter((m) => m.row_key !== "tt-103"));
try {
const res = await GET(new Request("http://localhost/api/dashboard"));
expect(res.status).toBe(200);
const body = (await res.json()) as DashboardResponse;
// ★103 が選ばれないので、施設1は1つ前の 09-29（102。成功）が直近になる★
expect(body.summary).toEqual({ success: 1, failed: 0, not_executed: 1, pending: 0, success_rate: 50 });
const events = vi
.mocked(logEvent)
.mock.calls.filter(([, p]) => p.event === "data.anomaly" && p.metric === "clean_log_run_meta_missing");
expect(events).toHaveLength(1);
expect(events[0][1]).toEqual({
event: "data.anomaly",
route: "/api/dashboard",
method: "GET",
metric: "clean_log_run_meta_missing",
expected: 0,
actual: 1,
// ★`row_key` を出す★（指示書BG §2-2。予定外の行は id が無いため。旧: "103"）
row_ids: ["tt-103"],
});
} finally {
spy.mockRestore();
}
});
it("メタが揃っていれば `clean_log_run_meta_missing` を出さない", async () => {
await get("");
const events = vi
.mocked(logEvent)
.mock.calls.filter(([, p]) => p.event === "data.anomaly" && p.metric === "clean_log_run_meta_missing");
expect(events).toHaveLength(0);
});
it("★`?date=2026-09-29` ではメタを読まない★（0回）", async () => {
await get("?date=2026-09-29");
expect(metaCalls()).toHaveLength(0);
});
});
/**
* ★スケジュール進捗（ユーザー判断 2026-10-29「案B」）★ — 期待値表（`NOW` = 2026-09-30 09:00 JST）:
* | # | 指定 | 対象日 | 対象日の本清掃 | planned | completed | rate |
* |---|---|---|---|---|---|---|
* | S1 | 省略（直近モード） | 09-29（前日） | 102（出発）/ 203（未実施） | 2 | 1 | 50 |
* | S2 | `?date=2026-09-29` | 09-29 | 同上 | 2 | 1 | 50 |
* | S3 | `?date=2026-09-30` | 09-30 | 103（出発） | 1 | 1 | 100 |
* | S4 | `?date=2026-09-30` ＋ 施設3の結果待ち 301 | 09-30 | 103 / 301（結果待ち） | 2 | 1 | 50 |
* | S5 | `?date=2026-10-01`（予定なし） | 10-01 | なし | 0 | 0 | null |
* | S6 | 省略 ＋ 施設2が削除済み | 09-29 | 102 だけ（203 は見えない） | 1 | 1 | 100 |
* | S7 | 省略 ＋ `clean_schedules` に毎日の予定7件 | 09-29 | 102 / 203 | 2 | 1 | 50（★曜日の設定を数えない★） |
*/
describe("GET /dashboard — スケジュール進捗（2026-10-29 案B）", () => {
it("S1 直近モードの対象日は前日（09-29）。当日（09-30）の行で数えない", async () => {
const body = await get("");
expect(body.schedule_progress).toEqual({ date: "2026-09-29", planned: 2, completed: 1, rate: 50 });
});
it("S2 `?date=2026-09-29` は S1 と同じ", async () => {
const latest = await get("");
const ofDay = await get("?date=2026-09-29");
expect(ofDay.schedule_progress).toEqual(latest.schedule_progress);
});
it("S3 `?date=2026-09-30` はその日（前日にしない）", async () => {
const body = await get(`?date=${TODAY}`);
expect(body.schedule_progress).toEqual({ date: TODAY, planned: 1, completed: 1, rate: 100 });
});
it("S4 結果待ちは planned にだけ入る", async () => {
data.timetables.push(timetable(301, 3, "2026-09-30T07:30:00+09:00"));
const body = await get(`?date=${TODAY}`);
expect(body.schedule_progress).toEqual({ date: TODAY, planned: 2, completed: 1, rate: 50 });
});
it("S5 対象日に予定が無ければ planned 0・rate null", async () => {
const body = await get("?date=2026-10-01");
expect(body.schedule_progress).toEqual({ date: "2026-10-01", planned: 0, completed: 0, rate: null });
});
it("S6 削除済みの施設の予定は数えない", async () => {
for (const t of data.timetables) {
if (t.facility_id === BigInt(2)) t.facility.deleted_at = dbWallClock("2026-09-01T00:00:00+09:00");
}
const body = await get("");
expect(body.schedule_progress).toEqual({ date: "2026-09-29", planned: 1, completed: 1, rate: 100 });
});
it("S7 `clean_schedules`（曜日の設定）は読まない — 予定件数は予定の表の行から", async () => {
const body = await get("");
expect(calls.cleanSchedule).toHaveLength(0);
expect(body.schedule_progress.planned).toBe(2);
await get(`?date=${TODAY}`);
expect(calls.cleanSchedule).toHaveLength(0);
});
});
/**
* ★結果待ち（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([]);
});
});
/**
* ★D-Sec アラートの想定外の状態でダッシュボードを落とさない★（指示書AX 表1 R10・D3）。
* `db.dsAlerts()` はダッシュボードも呼ぶ。`status` 3 の行を状態の変換に通すと例外 → 全体が500になる。
* ★スタブは where を無視して返す★（SQL の `status IN` が効かなかった状態。正は純粋関数）。
*/
describe("GET /dashboard — D-Sec アラート（指示書AX 表1 R10）", () => {
it("★status 3 の D-S_CONTROL_FAILURE 行（robot_id NULL）が返っても 200・バナーは空★", async () => {
data.dsAlertRows = [
{
error_id: "R-10",
robot_id: null,
clean_timetable_id: null,
serial_number: "DFAS010001",
facility_id: BigInt(1),
facility: { facility_name: FACILITY_1, deleted_at: null },
section: { section_name: "1F売り場", deleted_at: null },
error_type: D_SEC_ALERT_ERROR_TYPES[0],
errored_at: dbWallClock("2026-09-30T02:00:00+09:00"),
created_at: dbWallClock("2026-09-30T02:01:00+09:00"),
status: 3,
responded_at: null,
resolved_at: null,
comment: null,
},
];
const res = await GET(new Request(`http://localhost/api/dashboard?date=${TODAY}`));
expect(res.status).toBe(200);
const body = (await res.json()) as DashboardResponse;
expect(body.security_banner).toEqual([]);
});
});
describe("GET /dashboard — 削除済みの施設・清掃エリア（指示書BB U1・表1 V4/V5）", () => {
it("★V4: 清掃ログ・直近のメタの `where` に可視性が入る★（V5 の予定件数も同じ清掃ログから数える。2026-10-29 案B）", async () => {
await get("");
expect(mainQueryWhere()).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
for (const m of metaCalls()) expect(m.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
// ★予定件数は `clean_schedules` を読まない★（スケジュール進捗の describe の S6・S7）
expect(calls.cleanSchedule).toHaveLength(0);
});
});
describe("GET /dashboard — 存在しない日付は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/dashboard?date=2026-02-31"));
const format = await GET(new Request("http://localhost/api/dashboard?date=2026/02/03"));
expect(bad.status).toBe(422);
expect(format.status).toBe(422);
expect(await bad.json()).toEqual(await format.json());
});
});
// ★表10 N7（指示書BB A6・D17）★ — ダッシュボードの D-Sec は解消でないものだけ読む（バナーは解消でないものしか見ない）
describe("GET /dashboard — D-Sec アラートは未解消だけ読む（指示書BB 表10 N7）", () => {
it("★`dsAlerts({ open_only: true })` — SQL の status は未解消・対応中（0/1）だけ★", async () => {
await get("");
expect(dsAlertWheres).toHaveLength(1);
expect(dsAlertWheres[0]).toEqual(dsAlertWhere({ open_only: true }));
expect((dsAlertWheres[0] as { status: { in: number[] } }).status.in).toEqual([0, 1]);
});
});
