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";
// ★出発失敗はアラートに出ない（2026-10-29）ことを、同じスタブの上で突き合わせるため★
import { GET as GET_PRECHECKS } from "@/app/api/prechecks/route";
import type { PrecheckSummary } from "@/lib/prechecks/query";
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 { FACILITY_SECTION_VISIBLE_WHERE } from "@/lib/db/visibility";
import { logEvent } from "@/lib/logger";
import { loadConsecutiveDaysMax } from "@/lib/settings/display-limits";
import type { CleanLogItem, ListResponse, PrecheckItem, SummaryListResponse } 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;
/** ★`deleted_at` は省略可（省略は生きている）。削除済みの施設の行を作るテストだけが入れる（指示書BB U1）★ */
facility: { facility_name: string; deleted_at?: Date | null };
section: {
/** ★省略は生きている（指示書BB U1）★ */
deleted_at?: Date | null;
robots: {
/** `robots.id`（★2台以上のときの並び `orderBy: { id: "asc" }` を見るため。省略可★。指示書BB D7） */
id?: bigint;
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 {
/** ★予定外の行（指示書BG）だけ使う★（予定のある行の読み取りは読まない） */
report_id?: string;
facility_id?: bigint;
section_id?: bigint;
/** ★予定外の行の `include`（施設名・清掃エリアのロボット・削除済み）★。予定のある行には付けない */
facility?: { facility_name: string; deleted_at: Date | null };
section?: StubTimetable["section"];
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>)) {
// ★`OR`（予定外の行の `UNSCHEDULED_TIMETABLE_ID_WHERE`。指示書BG）★ — どれか1つに当たれば通す
if (field === "OR") {
if (!(cond as unknown[]).some((sub) => matchesWhere(row, sub))) return false;
continue;
}
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` を足してしまう）が起きたら結果が変わるように。
// ★リレーション（`facility` / `section`）の条件は、その行の `deleted_at`（省略は生きている）で見る★（指示書BB U1）
const target =
value !== null && typeof value === "object" && !(value instanceof Date)
? ((value as { deleted_at?: Date | null }).deleted_at ?? null)
: value;
if (c.deleted_at === null && target !== 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) => sortIncludedRobots(project(row, args?.select), args));
}
/**
* ★`include: { section: { include: { robots: { orderBy: { id: "asc" } } } } }` を再現する★（指示書BB D7・表2 R5）—
* 実装が `orderBy` を付け忘れたら、スタブはデータの順のまま返す（R5 が赤くなる）
*/
function sortIncludedRobots(
row: Record<string, unknown>,
args: Record<string, unknown> | undefined
): Record<string, unknown> {
const include = args?.include as
| { section?: { include?: { robots?: { orderBy?: { id?: string } } } } }
| undefined;
if (include?.section?.include?.robots?.orderBy?.id !== "asc") return row;
const section = row.section as StubTimetable["section"];
const robots = [...section.robots].sort((a, b) => Number(a.id ?? 0) - Number(b.id ?? 0));
return { ...row, section: { ...section, robots } };
}
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 },
// ★★論理削除済み（施設マスタ側）★★ — 名前の解決（罠7）の検証用。
// ★予定の行（201）の `facility.deleted_at` は既定では入れない（＝生きている扱い）★ —
// 削除済みの施設の行が外れること（指示書BB U1）は #6e で行に `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 ?? 0) - (b ?? 0))).toEqual([101, 102, 103, 201]);
expect(body.items.every((i) => i.facility_name.startsWith("ドソ"))).toBe(true);
});
it("★★#6e 削除済みの施設の名前で検索すると、施設ID には解決される（罠7）が、その行は可視性の条件で外れて0件★★（指示書BB D3）", async () => {
// ★予定の行（201）の施設を削除済みにする（施設マスタの施設2 と同じ状態）★
for (const t of data.timetables) {
if (Number(t.facility_id) === 2) t.facility = { ...t.facility, deleted_at: dbWallClock("2026-09-01T00:00:00+09:00") };
}
const body = await get(`?facility_name=${encodeURIComponent("四街道")}`);
// ★解決用の読み取りに `where` を足していないこと★（罠7。解決は行の可視性と別の責務）
expect(calls.facility).toEqual([{ select: { id: true, facility_name: true } }]);
expect(mainQueryWhere().facility_id).toEqual({ in: [2] });
// ★行は削除済みの施設・清掃エリアの条件で外れる（指示書BB U1）★
expect(mainQueryWhere()).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
expect(body.items).toEqual([]);
expect(body.meta.total).toBe(0);
});
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 が消える★ → 名前の解決の結果が変わる
// （★解決は行の可視性と別の責務★。行は予定の `where` の可視性の条件で外す。指示書BB D3）
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");
// ★`section` の条件は可視性（`deleted_at: null`）だけ★（シリアルの条件を SQL に降ろしていない。指示書BB U1 で可視性が入った）
expect(mainQueryWhere().section).toEqual({ deleted_at: null });
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` だけでは区別できない）
// ★予定外の行の読み取り（`include` 付き。指示書BG）は `clean_timetable_id` の `in` を持たないので除く★
const reportCall = calls.cleanTaskReport.find(
(c) => "where" in c && !("select" in c) && !("include" 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個）★。
// ★予定外の行の読み取り（`clean_timetable_id` の `in` を持たない。指示書BG）は予定の有無によらず撃つ★ので数えない
expect(
calls.cleanTaskReport.filter(
(c) => "where" in c && "clean_timetable_id" in (c.where as Record<string, unknown>)
)
).toEqual([]);
expect(calls.cleanTaskReport.filter((c) => "include" in c)).toHaveLength(1);
});
});
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");
});
});
/**
* ★出発失敗はアラートに出ない（ユーザー判断 2026-10-29「2で進めてください」）★ —
* 同じデータ（このファイルのスタブ）で、清掃詳細ログには出発失敗（未実施）として出て、
* アラート（`GET /prechecks`）には行が出ないことを突き合わせる。
* ★判定は `notExecutedFromReport()` の1本のまま★（清掃詳細ログの `departed`）。アラートはその判定を使わない。
*/
describe("出発失敗は清掃詳細ログに出て、アラートには出ない（2026-10-29）", () => {
beforeEach(() => {
// ★9/9 02:00 の本清掃（102）からレポートを外す＝確定した出発失敗（now は 9/30）★
data.reports = data.reports.filter((r) => r.clean_timetable_id !== BigInt(102));
// ★本清掃 103 の事前チェック（1031）のエラーを1件、アラートに出る形で足す★（アラートが空振りしていないことの確認）
data.errorReports.push({
error_id: "E-PRE-1",
clean_timetable_id: BigInt(1031),
error_type: "EmergencyStop",
errored_at: dbWallClock("2026-09-10T01:06:00+09:00"),
created_at: dbWallClock("2026-09-10T01:06:00+09:00"),
serial_number: "8111R562806001",
facility_id: BigInt(1),
facility: { facility_name: FACILITY_1, deleted_at: null },
section: { deleted_at: null },
status: 0,
responded_at: null,
resolved_at: null,
comment: null,
} as StubErrorReport);
});
async function getPrechecks(search: string): Promise<SummaryListResponse<PrecheckItem, PrecheckSummary>> {
const res = await GET_PRECHECKS(new Request(`http://localhost/api/prechecks${search}`));
expect(res.status).toBe(200);
return (await res.json()) as SummaryListResponse<PrecheckItem, PrecheckSummary>;
}
it("★清掃詳細ログ: 102 は出発失敗（未実施）★", async () => {
const item = (await get("")).items.find((i) => i.id === 102);
expect(item).toMatchObject({
departed: false,
task_status: null,
completion_rate: null,
result_pending: false,
grade: "×",
});
});
it("★アラート: 102 の行は無い。行は事前チェック異常だけ（summary・meta.total も）★", async () => {
const body = await getPrechecks("?status=all");
expect(body.items.map((i) => i.id)).not.toContain("102");
expect(body.items.map((i) => i.id)).toEqual(["E-PRE-1"]);
expect(body.items.every((i) => i.severity === "precheck")).toBe(true);
expect(body.summary).toEqual({ unresolved: 1, resolved: 0, total: 1 });
expect(body.meta.total).toBe(1);
// ★9/9 だけに絞ると、出発失敗（102）があってもアラートは0件★
const sep9 = await getPrechecks("?date_from=2026-09-09&date_to=2026-09-09&status=all");
expect(sep9.items).toEqual([]);
expect(sep9.summary.total).toBe(0);
// 同じ日の清掃詳細ログには出発失敗として出る
const log9 = await get("?date_from=2026-09-09&date_to=2026-09-09");
expect(log9.items.find((i) => i.id === 102)?.departed).toBe(false);
});
});
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,
});
});
});
describe("GET /clean-logs — 有効なロボットがいない清掃エリア（指示書BB U2・表2）", () => {
/** `data.anomaly` のうち、清掃エリアのロボット台数のものだけ */
function robotAnomalies() {
return vi
.mocked(logEvent)
.mock.calls.filter(([, p]) => p.event === "data.anomaly" && p.metric === "active_robots_per_section")
.map(([, p]) => p);
}
it("★R2: 0台でも例外にならず、その行は出る。機種・シリアルは null。ログは清掃エリアごとに1回★", async () => {
// 施設1（清掃エリア 10）の本清掃3件（101〜103）からロボットを外す
for (const t of data.timetables) {
if (Number(t.facility_id) === 1) t.section = { robots: [] };
}
const res = await GET(new Request("http://localhost/api/clean-logs"));
expect(res.status).toBe(200);
const body = (await res.json()) as ListResponse<CleanLogItem>;
expect(body.items.map((i) => [i.id, i.model_name, i.serial_number])).toEqual([
[301, "PUDU CC1", "8111R562806003"],
[103, null, null],
[201, "PUDU CC1", "8111R562806002"],
[102, null, null],
[101, null, null],
]);
// ★同じ清掃エリアの行が3行あっても1回★
expect(robotAnomalies()).toEqual([
{ event: "data.anomaly", metric: "active_robots_per_section", expected: 1, actual: 0, section_id: "10" },
]);
});
it("R1: 1台なら今どおり（ログを出さない）。`robots` の並びは `id` 昇順を SQL に頼む", async () => {
await get("");
expect(robotAnomalies()).toHaveLength(0);
const include = calls.cleanTimetable.find((c) => "include" in c)?.include as {
section: { include: { robots: { orderBy: unknown } } };
};
expect(include.section.include.robots.orderBy).toEqual({ id: "asc" });
});
it("★R5: 有効なロボット2台（id 10 と id 7）→ id 7 を採る。ログ（actual: 2）は清掃エリアごとに1回★", async () => {
for (const t of data.timetables) {
if (Number(t.facility_id) !== 3) continue;
t.section = {
robots: [
{ id: BigInt(10), serial_number: "SERIAL-ID10", device: { maker_id: 1, model_name: "CC1" } },
{ id: BigInt(7), serial_number: "SERIAL-ID7", device: { maker_id: 1, model_name: "CC1" } },
],
};
}
const body = await get("");
expect(body.items.find((i) => i.id === 301)?.serial_number).toBe("SERIAL-ID7");
expect(robotAnomalies()).toEqual([
{ event: "data.anomaly", metric: "active_robots_per_section", expected: 1, actual: 2, section_id: "30" },
]);
});
it("★R7: 0台の行に `serial=` / `model=` で絞ると当たらない（null は部分一致しない）。絞り込みなしなら出る★", async () => {
for (const t of data.timetables) {
if (Number(t.facility_id) === 1) t.section = { robots: [] };
}
const bySerial = await get("?serial=8111R");
expect(bySerial.items.map((i) => i.id)).toEqual([301, 201]);
const byModel = await get(`?model=${encodeURIComponent("pudu")}`);
expect(byModel.items.map((i) => i.id)).toEqual([301, 201]);
expect((await get("")).items.map((i) => i.id)).toEqual([301, 103, 201, 102, 101]);
});
});
describe("GET /clean-logs — 削除済みの施設・清掃エリアの行は出さない（指示書BB U1・表1 V1）", () => {
const DELETED = dbWallClock("2026-09-01T00:00:00+09:00");
it("★V1: 予定の2表の `where` に施設・清掃エリアの可視性が入る★", async () => {
await get("");
expect(mainQueryWhere()).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
const history = calls.cleanTimetableHistory.find((c) => "include" in c) as { where: Record<string, unknown> };
expect(history.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
});
it.each([
["施設削除", (t: StubTimetable) => ({ ...t, facility: { ...t.facility, deleted_at: DELETED } })],
["エリア削除", (t: StubTimetable) => ({ ...t, section: { ...t.section, deleted_at: DELETED } })],
] as const)("V1（%s）: その行は出ない・meta.total に数えない（生きている行は出る）", async (_label, mark) => {
data.timetables = data.timetables.map((t) => (Number(t.id) === 301 ? mark(t) : t));
const body = await get("");
expect(body.items.map((i) => i.id)).toEqual([103, 201, 102, 101]);
expect(body.meta.total).toBe(4);
});
});
describe("GET /clean-logs — 存在しない日付は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/clean-logs?date_from=2026-02-31"));
const format = await GET(new Request("http://localhost/api/clean-logs?date_from=2026/02/03"));
expect(bad.status).toBe(422);
expect(format.status).toBe(422);
expect(await bad.json()).toEqual(await format.json());
});
});
/**
* ★表10 N5（指示書BB A6・D16）★ — 施設で絞ったとき、`cleanLogs()` は連続日数の入力（`loadConsecutiveInputs()`）にも
* 同じ施設IDを渡す。★応答の `consecutive_problem_days`・`escalation_level` は絞る前と同じ★。
* （ルートの分類の解決はこのテストのスタブでは施設名で行う — 解決の経路は違っても渡る配列は同じ `query.facility_ids`）
*/
describe("GET /clean-logs — 連続日数の入力も施設で絞る（指示書BB 表10 N5）", () => {
/** 連続日数用の予定のクエリ（`precheck` を読む select 付き） */
function consecutiveTimetableCalls() {
return calls.cleanTimetable.filter((c) => {
const select = c.select as Record<string, unknown> | undefined;
return select !== undefined && select.precheck === true && select.facility_id === true;
});
}
it("★施設名で施設1・2に絞る → 連続日数の入力の `where` に `facility_id: { in: [1n, 2n] }`。値は絞る前と同じ★", async () => {
const before = await get("");
const expected = new Map(before.items.map((i) => [i.id, [i.consecutive_problem_days, i.escalation_level]]));
calls.cleanTimetable = [];
const scoped = await get(`?facility_name=${encodeURIComponent("ドソキホーテ")}`);
const consecutive = consecutiveTimetableCalls();
expect(consecutive).toHaveLength(1);
expect((consecutive[0].where as Record<string, unknown>).facility_id).toEqual({ in: [BigInt(1), BigInt(2)] });
expect(scoped.items.length).toBeGreaterThan(0);
for (const item of scoped.items) {
expect([item.consecutive_problem_days, item.escalation_level]).toEqual(expected.get(item.id));
}
expect(scoped.items.find((i) => i.id === 103)?.consecutive_problem_days).toBe(3);
});
it("施設で絞らない → 連続日数の入力にも `facility_id` の条件を付けない", async () => {
await get("");
const consecutive = consecutiveTimetableCalls();
expect(consecutive).toHaveLength(1);
expect(consecutive[0].where).not.toHaveProperty("facility_id");
});
});
/**
* ★予定外タスクの行（指示書BG §1・§2-1 / 表U1）★ — `clean_task_reports` のうち `clean_timetable_id` が 0 か NULL の行。
*
* | # | 行 | 期待 |
* |---|---|---|
* | U1-1 | 予定外・`started_at` 9/10 21:30・完了率 95.9 | 1行。`unscheduled` true・`id` null・`row_key` "rp-…"・`departed` true・◎・事前チェック null |
* | U1-2 | 予定外・`clean_area` 0 | 完了率 0・× ・出発 true（未実施ではない） |
* | U1-3 | `clean_timetable_id` = 0 と NULL | どちらも予定外として同じ扱い |
* | U1-4 | 予定外・`task_area` 0 | 完了率 0 |
* | U1-5 | 予定外・削除済みの施設（清掃エリア） | 出さない・数えない |
* | U1-6 | 予定のある行 | 今と同じ（`unscheduled` false・`row_key` "tt-<id>"） |
*
* ★日付は表の「10-28 21:00」の代わりに、このファイルの合成データ（9/10）に合わせた★（扱いは同じ）
*/
describe("予定外タスクの行（指示書BG 表U1）", () => {
/** 予定外の清掃結果1行（壁時計値。完了率は `clean_area ÷ task_area × 100`） */
function unscheduledReport(
reportId: string,
facilityId: number,
facilityName: string,
startedJstIso: string,
cleanArea: number,
taskArea: number,
timetableId: bigint | null = null,
status = 4
): StubReport {
const startedAt = dbWallClock(startedJstIso);
return {
report_id: reportId,
facility_id: BigInt(facilityId),
section_id: BigInt(facilityId * 10),
clean_timetable_id: timetableId,
clean_ratio: 0,
status,
started_at: startedAt,
ended_at: new Date(startedAt.getTime() + 60 * 60_000),
clean_area: cleanArea,
task_area: taskArea,
facility: { facility_name: facilityName, deleted_at: null },
section: {
deleted_at: null,
robots: [{ serial_number: `8111R56280600${facilityId}`, device: { maker_id: 1, model_name: "CC1" } }],
},
};
}
const RP1 = "9200000000000000001";
const RP2 = "9200000000000000002";
it("U1-1: 予定外の1行 — unscheduled true・id null・row_key rp-…・出発 true・◎・事前チェック null・scheduled_at は started_at", async () => {
data.reports.push(unscheduledReport(RP1, 3, FACILITY_3, "2026-09-10T21:30:00+09:00", 959, 1000));
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
const item = body.items.find((i) => i.unscheduled);
expect(item).toMatchObject({
id: null,
row_key: `rp-${RP1}`,
report_id: RP1,
unscheduled: true,
facility_id: 3,
facility_name: FACILITY_3,
model_name: "PUDU CC1",
serial_number: "8111R562806003",
scheduled_at: "2026-09-10T21:30:00+09:00",
status_1h: null,
status_1h_minutes: null,
status_30m: null,
status_30m_minutes: null,
departed: true,
task_status: 4,
result_pending: false,
completion_rate: 95.9,
grade: "◎",
});
// ★予定のある行と一緒に `scheduled_at` の新しい順で並び、`meta.total` にも数える★（9/10 の予定3行 ＋ 予定外1行）
expect(body.items[0].row_key).toBe(`rp-${RP1}`);
expect(body.meta.total).toBe(4);
});
it("U1-2: 予定外・clean_area 0 → 完了率 0・×・出発 true（未実施ではない）", async () => {
data.reports.push(unscheduledReport(RP1, 3, FACILITY_3, "2026-09-10T21:30:00+09:00", 0, 800, null, 6));
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
const item = body.items.find((i) => i.unscheduled);
expect(item).toMatchObject({ completion_rate: 0, grade: "×", departed: true, task_status: 6, result_pending: false });
});
it("U1-3: clean_timetable_id が 0 と NULL のどちらも予定外。0 でも NULL でもないレポートは予定外の行にしない", async () => {
data.reports.push(
unscheduledReport(RP1, 3, FACILITY_3, "2026-09-10T21:30:00+09:00", 500, 1000, null),
unscheduledReport(RP2, 3, FACILITY_3, "2026-09-10T22:30:00+09:00", 500, 1000, BigInt(0)),
// ★予定の id を持つ（予定の表に行が無い）レポート★ — 予定外の行にしない
unscheduledReport("9200000000000000003", 3, FACILITY_3, "2026-09-10T23:00:00+09:00", 500, 1000, BigInt(999))
);
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
const unscheduled = body.items.filter((i) => i.unscheduled);
expect(unscheduled.map((i) => i.row_key)).toEqual([`rp-${RP2}`, `rp-${RP1}`]);
expect(unscheduled.map((i) => [i.completion_rate, i.grade, i.departed])).toEqual([
[50, "△", true],
[50, "△", true],
]);
});
it("U1-4: 予定外・task_area 0 → 完了率 0（`runCompletionRate()` と同じ）", async () => {
data.reports.push(unscheduledReport(RP1, 3, FACILITY_3, "2026-09-10T21:30:00+09:00", 300, 0));
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
expect(body.items.find((i) => i.unscheduled)).toMatchObject({ completion_rate: 0, grade: "×", departed: true });
});
it("U1-5: 削除済みの施設・清掃エリアの予定外は出さない・数えない", async () => {
const deletedFacility = unscheduledReport(RP1, 3, FACILITY_3, "2026-09-10T21:30:00+09:00", 959, 1000);
deletedFacility.facility = { facility_name: FACILITY_3, deleted_at: dbWallClock("2026-09-01T00:00:00+09:00") };
const deletedSection = unscheduledReport(RP2, 3, FACILITY_3, "2026-09-10T22:30:00+09:00", 959, 1000);
deletedSection.section = {
robots: deletedSection.section?.robots ?? [],
deleted_at: dbWallClock("2026-09-01T00:00:00+09:00"),
};
data.reports.push(deletedFacility, deletedSection);
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
expect(body.items.some((i) => i.unscheduled)).toBe(false);
expect(body.meta.total).toBe(3);
// ★SQL の `where` にも可視性の条件が載っている★
const call = calls.cleanTaskReport.find((c) => "include" in c) as { where: Record<string, unknown> };
expect(call.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
});
it("U1-6: 予定のある行は今と同じ（unscheduled false・row_key tt-<id>・report_id null）", async () => {
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
const item = body.items.find((i) => i.id === 103);
expect(item).toMatchObject({ unscheduled: false, row_key: "tt-103", report_id: null });
expect(body.items.every((i) => !i.unscheduled)).toBe(true);
});
it("期間は started_at（JST の日付）で絞る・施設の絞り込みも効く", async () => {
data.reports.push(
unscheduledReport(RP1, 3, FACILITY_3, "2026-09-09T21:30:00+09:00", 959, 1000),
unscheduledReport(RP2, 1, FACILITY_1, "2026-09-10T21:30:00+09:00", 959, 1000)
);
const day10 = await get("?date_from=2026-09-10&date_to=2026-09-10");
expect(day10.items.filter((i) => i.unscheduled).map((i) => i.row_key)).toEqual([`rp-${RP2}`]);
const facility3 = await get(`?facility_name=${encodeURIComponent(FACILITY_3)}`);
expect(facility3.items.filter((i) => i.unscheduled).map((i) => i.row_key)).toEqual([`rp-${RP1}`]);
});
it("予定外の行の連続日数・L1〜L3 は、施設のその日の値（同じ施設・同じ日の予定のある行と同じ）", async () => {
// 施設1 の 9/10 は 9/8・9/9・9/10 の × で3日連続（L3）。同じ日の予定外 ◎ も同じ値になる
data.reports.push(unscheduledReport(RP1, 1, FACILITY_1, "2026-09-10T21:30:00+09:00", 959, 1000));
const body = await get("?date_from=2026-09-10&date_to=2026-09-10");
const item = body.items.find((i) => i.unscheduled);
expect(item).toMatchObject({ grade: "◎", consecutive_problem_days: 3, escalation_level: "L3" });
});
it("result=problem の絞り込みも予定のある行と同じ（判定で絞る）", async () => {
data.reports.push(
unscheduledReport(RP1, 3, FACILITY_3, "2026-09-10T21:30:00+09:00", 959, 1000),
unscheduledReport(RP2, 3, FACILITY_3, "2026-09-10T22:30:00+09:00", 0, 1000)
);
const problem = await get("?date_from=2026-09-10&date_to=2026-09-10&result=problem");
expect(problem.items.filter((i) => i.unscheduled).map((i) => i.row_key)).toEqual([`rp-${RP2}`]);
});
it("単一ID（`/clean-logs/{id}/*`）の取得では予定外の行を読まない", async () => {
data.reports.push(unscheduledReport(RP1, 1, FACILITY_1, "2026-09-10T21:30:00+09:00", 959, 1000));
const rows = await db.cleanLogs({ id: 103, date_from: null, date_to: null, facility_ids: null });
expect(rows.map((r) => r.row_key)).toEqual(["tt-103"]);
expect(calls.cleanTaskReport.filter((c) => "include" in c)).toEqual([]);
});
});
