import { afterEach, describe, expect, it } from "vitest";
import {
CLEAN_TIMETABLE_PRECHECK,
CONSECUTIVE_DAYS_DISPLAY,
CONSECUTIVE_LOOKBACK,
RESULT_WAIT_MINUTES,
} from "@/lib/config";
import {
completionRateFromReport,
computeConsecutiveProblemDays,
consecutiveProblemDaysByFacilityDate,
facilityDateKey,
foldProblemDaysByDate,
isFutureSchedule,
latestReportByTimetableId,
type ConsecutiveInput,
} from "@/lib/db/clean-log-mapping";
import {
consecutiveInputsFromRows,
consecutiveLookbackCalendarDays,
consecutiveLookbackFrom,
loadConsecutiveInputs,
CONSECUTIVE_RANGE_UNBOUNDED,
type ConsecutiveDbRange,
type ConsecutiveSourcePrisma,
type ConsecutiveTaskReportRow,
type ConsecutiveTimetableRow,
type ConsecutiveUnscheduledReportRow,
type ConsecutiveUnscheduledReportWhere,
} from "@/lib/db/consecutive-source";
import {
consecutiveProblemDaysAtPeriodEnd,
continuousProblemsInPeriod,
} from "@/lib/db/report-mapping";
import { buildRescueRequired } from "@/lib/db/rescue-mapping";
import { judgeEscalationLevel } from "@/lib/judge";
import { FACILITY_SECTION_VISIBLE_WHERE } from "@/lib/db/visibility";
import { capConsecutiveDays } from "@/lib/format/consecutive-days";
import { runCompletionRate } from "@/lib/judge";
import { fromDbJst } from "@/lib/format/date";
import { periodRange } from "@/lib/format/period";
import {
__setDisplayLimitStoreForTesting,
type DisplayLimitOverrides,
} from "@/lib/settings/display-limits";
/**
* 指示書AC 段階1 の期待値表（6行）。
*
* ★★段階1 は「挙動を1ミリも変えないリファクタ」なので、固定するのは
* 「値が**変わらない**こと」です★★。
*
* | # | 入力 | 期待 |
* |---|---|---|
* | 1 | ローカルDB 全件 | `loadConsecutiveInputs()` の件数 ＝ 段階0 の `cleanLogs()` の件数（538） |
* | 2 | ローカルDB 全件 | `computeConsecutiveProblemDays()` の Map が段階0 のスナップショットと完全一致 |
* | 3 | ローカルDB 全件 | `facilityPerformance()` の `consecutive_problem_days` が段階0 と一致 |
* | 4 | ローカルDB 全件 | `continuousProblems()` の全行が段階0 と一致 |
* | 5 | 合成データ | 同一施設・2台・Aの翌日にBが問題 → ★2日連続★（D-109 A案） |
* | 6 | 合成データ | 清掃予定のない日を挟んでも連続が途切れない（D-026） |
*
* ★★#1〜#4 の期待値は、段階0（refactor 前の HEAD）で ★ローカルDB `dwatch_local` から実測した
* スナップショット★ をそのままこのファイルに書き写したものです★★
* （2026-09-13 実測。`clean_timetables` 1,044行 / 本清掃 538行 / 施設12件）。
* ★★テストからDBに接続しないこと★★（`lib/db/` のテストはDB非依存が原則）なので、
* ★施設9（★2台の清掃エリアを持ち、実測の最大連続6日を含む施設★）の実測62行を
* `LOCAL_DB_FACILITY_9` に固定し、その行から作ったスタブを通して同じ値が出ることを確認する★。
* ★全538行ぶんの一致は、同じスクリプトで段階0 と段階1 の全メソッドの戻り値を
* 突き合わせて確認済み（11メソッドすべて完全一致）★。
*/
/**
* ★★指示書AQ（参照元を `clean_task_reports` に差し替える）の期待値表（10行）★★
*
* ★実装の前にこの表を確定させたもの★（`CLAUDE.md` §0-2 / §6-2）。
* ★★`clean_timetable_id` が NULL の行と `ended_at` が NULL の行を必ず含めること★★
* （指示書AQ 罠1 / 罠3。★どちらも例外もテスト失敗も出ずに壊れる形★）。
*
* | # | 入力 | 期待 |
* |----|---|---|
* | Q1 | 本清掃1行 + レポート1行（面積 50/100） | `completion_rate = 50`（★`runCompletionRate()`。D-155★） |
* | Q2 | 本清掃1行 + ★対応レポートなし★ | `completion_rate = null`（★未実施★。§1-1） |
* | Q3 | レポートの `clean_timetable_id` が ★NULL★ | ★`IN` に一致せず返らない → その清掃は「未実施」★（罠1） |
* | Q4 | レポート3行・`ended_at` すべてあり | ★`ended_at` が最新★の1件 |
* | Q5 | レポート2行・片方の `ended_at` が ★NULL★ | ★NULL 側は `started_at` を順序キーにする★（§1-4） |
* | Q6 | レポート2行・★両方 `ended_at` が NULL★ | ★`started_at` が新しいほう★ |
* | Q7 | レポート2行・順序キーが同着 | ★入力順の先頭★（`clean_status_histories` 時代と同じ規則） |
* | Q8 | 面積 0/100 のレポートあり | ★`0`★（★`null` にしない★。「0%で実施」と「未実施」は別物） |
* | Q9 | 面積 900/1000 のレポート / 0/0 のレポート / レポートなし | ★面積は生値 / なしは `0`★。完了率は 90 / ★0（`task_area = 0`。P-5=B。旧: null）★ / null、★`departed` は true / true / false★（D-155 / D-156 / D-158） |
* | Q10| `select` の列 | 6列（`clean_timetable_id` / `clean_ratio` / `started_at` / `ended_at` / `clean_area` / `task_area`）。★`clean_error` は無い★ |
*
* ★★Q1〜Q10 の期待値は実測ではありません★★（`CLAUDE.md` §6-6）— ★仕様（指示書AQ §1-1〜§1-4）
* から起こした合成データ★です。★本番DBの `clean_task_reports` は0行★で、
* ★ユーザー提供CSV 189行が唯一の実データ★（指示書AQ 決定4の根拠表）。
*/
// ---------------------------------------------------------------- ヘルパー
/**
* `clean_timetables.start_at` は ★日本時間の壁時計値★ が入った DATETIME（D-115 / 指示書Y）。
* ISO文字列（+09:00）から、DBに入っているのと同じ「壁時計値としての Date」を作る。
* ★`fromDbJst()` を通すと元の ISO に戻る★のが正しい状態。
*/
function dbWallClock(jstIso: string): Date {
return new Date(jstIso.replace("+09:00", "Z"));
}
/**
* @param endJstIso ★予定の終了★（結果待ちの判定用。D-173）。★省略時は開始の1時間後★
*/
function timetable(
id: number,
facilityId: number,
jstIso: string,
precheck: number = CLEAN_TIMETABLE_PRECHECK.main,
endJstIso?: string
): ConsecutiveTimetableRow {
const startAt = dbWallClock(jstIso);
return {
id: BigInt(id),
facility_id: BigInt(facilityId),
start_at: startAt,
end_at: endJstIso === undefined ? new Date(startAt.getTime() + 3_600_000) : dbWallClock(endJstIso),
precheck,
};
}
/**
* `clean_task_reports` の1行を作る（指示書AQ 決定2）。
*
* ★★「未実施」をこの関数では作れない★★（指示書AQ §1-1）— 未実施は
* ★★レポートの行そのものが無いこと★★で表すので、★行を作らない★のが正しい。
* ★`clean_ratio = 0` を未実施の代わりに使わないこと★（「0%で実施した」と別物。
* 指示書U 落とし穴1）。
*
* ★面積の既定は `cleanRatio / 100`★（D-155）— 完了率は面積から `runCompletionRate()` で決まるので、
* `task_area = 100` に対して `clean_area = cleanRatio` とし、`clean_ratio` 列にも同じ値を入れる
* （★列は完了率に使っていない。指示書AS D6★）。★旧: 面積の既定は 0 だった★（指示書AI 段階2）。
* ★R-3 は面積で重み付けしない★（1回ごとの完了率の単純平均＝`meanCleanRatio()`。
* 指示書AQ 決定4 / §5-5）。R-3 の期待値表は `lib/judge/__tests__/rescue.test.ts` が持つ。
*
* @param timetableId ★`null` を渡すと `clean_timetable_id` が NULL の行になる★（罠1 の検証用）
* @param endedAtJstIso ★`null` を渡すと `ended_at` が NULL の行になる★（罠3 / §1-4 の検証用）
*/
function taskReport(
timetableId: number | null,
cleanRatio: number,
endedAtJstIso: string | null = "2026-09-13T05:00:00+09:00",
cleanArea = cleanRatio,
taskArea = 100,
// ★順序キーのフォールバック★（`ended_at` が NULL のとき使われる。指示書AQ §1-4）
startedAtJstIso = "2026-09-13T04:00:00+09:00"
): ConsecutiveTaskReportRow {
return {
clean_timetable_id: timetableId === null ? null : BigInt(timetableId),
clean_ratio: cleanRatio,
started_at: dbWallClock(startedAtJstIso),
ended_at: endedAtJstIso === null ? null : dbWallClock(endedAtJstIso),
clean_area: cleanArea,
task_area: taskArea,
};
}
/**
* `findMany()` に渡された引数を控えるスタブ（★DBに接続しない★）。
*
* ★★`where.start_at` と `where.clean_timetable_id` は**DBと同じように絞る**★★ —
* 段階6（遡り範囲を有界にする）の検証は「★どの行が返らなくなったか★」を見る必要があるため。
*
* ★★ただし `where.precheck` はあえて**無視する**★★ —
* `precheck` の絞り込みは SQL にも降ろしてあるが、★規則の正は
* `consecutiveInputsFromRows()` のメモリ側 filter★（指示書AC C-5）。
* スタブが SQL 側で落としてしまうと、★純粋関数側の filter を消しても
* テストが緑のまま★になる。
*/
function stubPrisma(
timetables: readonly ConsecutiveTimetableRow[],
reports: readonly ConsecutiveTaskReportRow[],
// ★`clean_timetable_histories` の行（指示書AU 段階3b。既定は空）★
historyTimetables: readonly ConsecutiveTimetableRow[] = [],
// ★予定外タスクの行（指示書BG §2-3。3本目のクエリ。既定は空）★
unscheduledReports: readonly ConsecutiveUnscheduledReportRow[] = []
): { prisma: ConsecutiveSourcePrisma; calls: Record<string, unknown[]> } {
const calls: Record<string, unknown[]> = {
cleanTimetable: [],
cleanTimetableHistory: [],
cleanTaskReport: [],
// ★予定外タスクの3本目は別の箱に控える★（2本目の引数を見ている既存のテストを変えないため）
cleanTaskReportUnscheduled: [],
};
/**
* 予定の表の `findMany`（本表・履歴で共通）。★`where.id.in`（影チェック。`lib/db/timetable-source.ts`）だけは
* 再現する★ — 再現しないと、影チェックが本表の全行を返して「本表に同じ id がある」と誤認する。
*/
const timetableFindMany =
(rows: readonly ConsecutiveTimetableRow[], bucket: "cleanTimetable" | "cleanTimetableHistory") =>
async (args: Parameters<ConsecutiveSourcePrisma["cleanTimetable"]["findMany"]>[0]) => {
const idIn = (args.where as { id?: { in: bigint[] } } | undefined)?.id?.in;
// ★影チェックは記録しない★（`calls.cleanTimetable` の引数を見ている既存のテストを変えないため）
if (idIn) return rows.filter((row) => idIn.some((id) => id === row.id));
calls[bucket].push(args);
const range = args.where?.start_at;
return rows.filter((row) => {
if (range?.gte && row.start_at < range.gte) return false;
if (range?.lt && row.start_at >= range.lt) return false;
return true;
});
};
const prisma: ConsecutiveSourcePrisma = {
cleanTimetable: { findMany: timetableFindMany(timetables, "cleanTimetable") },
cleanTimetableHistory: { findMany: timetableFindMany(historyTimetables, "cleanTimetableHistory") },
cleanTaskReport: {
// ★2つの形を `where.clean_timetable_id.in` の有無で見分ける★（予定の id で引く2本目／予定外タスクの3本目）。
// ★交差型の `findMany` は2つの形のどちらにも代入できる必要がある★ので、和の引数で受けて型を合わせる
findMany: (async (
args:
| { where: { clean_timetable_id: { in: bigint[] } } }
| { where: ConsecutiveUnscheduledReportWhere }
) => {
if ("clean_timetable_id" in args.where) {
calls.cleanTaskReport.push(args);
const ids = new Set(args.where.clean_timetable_id.in.map((id) => id.toString()));
return reports.filter((row) => {
// ★★SQL と同じ挙動にする — NULL は `IN` に一致しない★★（指示書AQ 罠1）。
// ★ここを `?? ""` 等で誤魔化すと、罠1（NULL 行が「未実施」に化ける）を
// テストで再現できなくなります★
if (row.clean_timetable_id === null) return false;
return ids.has(row.clean_timetable_id.toString());
});
}
calls.cleanTaskReportUnscheduled.push(args);
const where = args.where;
// ★SQL と同じ意味で当てる★: `OR`（NULL か 0）・`started_at` の範囲・施設の `IN`
return unscheduledReports.filter((row) => {
const isUnscheduled = where.OR.some((cond) =>
cond.clean_timetable_id === null
? row.clean_timetable_id === null
: row.clean_timetable_id !== null && row.clean_timetable_id === cond.clean_timetable_id
);
if (!isUnscheduled) return false;
if (where.started_at?.gte && row.started_at < where.started_at.gte) return false;
if (where.started_at?.lt && row.started_at >= where.started_at.lt) return false;
if (where.facility_id && !where.facility_id.in.some((id) => id === row.facility_id)) return false;
return true;
});
}) as unknown as ConsecutiveSourcePrisma["cleanTaskReport"]["findMany"],
},
};
return { prisma, calls };
}
/**
* ★予定外タスクの `clean_task_reports` の1行★（指示書BG §2-3）。
* @param timetableId ★0 か `null`★（どちらも予定外。表U1 U1-3）
*/
function unscheduledReport(
facilityId: number,
startedAtJstIso: string,
cleanArea: number,
taskArea = 100,
timetableId: 0 | null = null
): ConsecutiveUnscheduledReportRow {
return {
facility_id: BigInt(facilityId),
clean_timetable_id: timetableId === null ? null : BigInt(timetableId),
clean_ratio: 0,
started_at: dbWallClock(startedAtJstIso),
ended_at: dbWallClock(startedAtJstIso),
clean_area: cleanArea,
task_area: taskArea,
};
}
/**
* 「システム管理画面で保存された表示上限」を差し替える（★実ファイルを触らない★）。
*
* ★段階6 の期待値表 #5 / #6（上限を大きく／小さくしたらクエリの遡り範囲も追随する）の
* 検証に使う★。★`undefined` を渡すと「未編集」＝ `lib/config/` の既定値に倒れる★。
*/
function useSavedConsecutiveDaysMax(value: number | undefined): void {
const overrides: DisplayLimitOverrides =
value === undefined ? {} : { consecutive_days_max: value };
__setDisplayLimitStoreForTesting(
{
async read() {
return { ...overrides };
},
async write() {
/* 段階6 は読むだけ。保存はしない */
},
},
"(test)"
);
}
afterEach(() => {
// ★差し替えを必ず戻す★ — 残すと他のテストが実ファイルではなくこのスタブを読む
__setDisplayLimitStoreForTesting(null);
});
/**
* ★本体（`consecutiveInputsFromRows()`）とは独立に書いた素朴な実装★。
* ★これと本体の結果が完全一致することを合格条件にする★（本体のヘルパーを1つも使わない）。
*
* ★★指示書AQ の切替でこの関数も書き直した★★ — 以前は
* `completionRateFromHistory()` / `latestHistoryByTimetableId()` を呼んでいたが、
* ★`clean_error` が `clean_task_reports` に無い★ため成立しない（指示書AQ §1-1）。
* ★規則をベタ書きにして「本体と同じ関数を呼ぶから一致する」トートロジーを避ける★。
*/
function legacyConsecutiveInputs(
timetables: readonly ConsecutiveTimetableRow[],
reports: readonly ConsecutiveTaskReportRow[],
now: Date
): ConsecutiveInput[] {
const mainRows = timetables.filter(
(row) => row.precheck === CLEAN_TIMETABLE_PRECHECK.main
);
// ★順序キー: `ended_at` があればそれ、無ければ `started_at`★（指示書AQ §1-4）。
// ★同着は入力順の先頭★（`<` 比較なので後続で上書きされない）
const reportByTimetableId = new Map<string, ConsecutiveTaskReportRow>();
for (const report of reports) {
if (report.clean_timetable_id === null) continue; // ★NULL はキーにできない★（罠1）
const key = report.clean_timetable_id.toString();
const current = reportByTimetableId.get(key);
const orderAt = report.ended_at ?? report.started_at;
if (!current || (current.ended_at ?? current.started_at) < orderAt) {
reportByTimetableId.set(key, report);
}
}
return mainRows
.filter((row) => !isFutureSchedule(fromDbJst(row.start_at), now))
// ★結果待ち（レポートなし かつ 予定の終了＋待ち時間より前）は外す★（表2 C10。D-173）。
// ★本体の `isResultPending()` を呼ばずにベタ書きする★（トートロジーを避ける。上の docstring）
.filter(
(row) =>
reportByTimetableId.has(row.id.toString()) ||
now.getTime() >= fromDbJst(row.end_at).getTime() + RESULT_WAIT_MINUTES * 60_000
)
.map((row) => {
const r = reportByTimetableId.get(row.id.toString());
return {
id: Number(row.id),
unscheduled: false,
facility_id: Number(row.facility_id),
scheduled_at: new Date(
fromDbJst(row.start_at).getTime()
).toISOString(), // ★後段で jstIsoFromDb と突き合わせるため、ここでは比較対象から外す★
// ★未実施 ＝ レポートの行が無い★（指示書AQ §1-1）。★`clean_error` は見ない★
// ★1回ごとの完了率は `runCompletionRate()` を呼ぶ★（指示書AU 段階2-4。テストの中に規則を写さない —
// 規則は `lib/judge/__tests__/run-completion-rate.test.ts` の表1 で固定している）
completion_rate: r === undefined ? null : runCompletionRate(r),
departed: r !== undefined,
// ★レポートが無い行は 0★（指示書AI 段階2。本体側と同じ規則をここにも写す）
clean_area: r?.clean_area ?? 0,
task_area: r?.task_area ?? 0,
};
});
}
// ---------------------------------------------------------------- 段階0 の実測スナップショット
/**
* ★段階0（refactor 前）にローカルDB `dwatch_local` から実測した施設9の全62行★。
* `[清掃ログid, scheduled_at, completion_rate, ★段階0 の consecutive_problem_days★]`
*
* ★施設9 を選んだ理由★: ★清掃エリアが2つ（1日に2行）ある★ので同一日OR畳み込み（D-109 A案）が
* 効いており、かつ ★実測の最大連続日数6日★ を含むため。
* ★この表の値を書き換えないこと★ — 書き換えたら「挙動が変わっていない」ことの証拠が消える。
*/
const LOCAL_DB_FACILITY_9: readonly [number, string, number | null, number][] = [
[1008, "2026-09-13T02:30:00+09:00", 9.9, 6],
[1017, "2026-09-08T02:30:00+09:00", 22, 1],
[1018, "2026-09-09T02:30:00+09:00", 18, 2],
[1019, "2026-09-10T02:30:00+09:00", 25, 3],
[1020, "2026-09-11T02:30:00+09:00", 15, 4],
[1021, "2026-09-12T02:30:00+09:00", 12, 5],
[1038, "2026-09-07T02:30:00+09:00", 75.9, 0],
[1048, "2026-09-06T02:30:00+09:00", 96.9, 1],
[1058, "2026-09-05T02:30:00+09:00", 93.8, 0],
[1068, "2026-09-04T02:30:00+09:00", 94.6, 1],
[1078, "2026-09-03T02:30:00+09:00", 94.6, 0],
[1088, "2026-09-02T02:30:00+09:00", 98.1, 1],
[1098, "2026-09-01T02:30:00+09:00", 94.5, 0],
[1108, "2026-08-31T02:30:00+09:00", 98.5, 2],
[1118, "2026-08-30T02:30:00+09:00", 8.5, 1],
[1128, "2026-08-29T02:30:00+09:00", 95.9, 0],
[1138, "2026-08-28T02:30:00+09:00", 97.7, 1],
[1148, "2026-08-27T02:30:00+09:00", 98.2, 0],
[1158, "2026-08-26T02:30:00+09:00", null, 3],
[1168, "2026-08-25T02:30:00+09:00", 9.1, 2],
[1178, "2026-08-24T02:30:00+09:00", 99.4, 1],
[1188, "2026-08-23T02:30:00+09:00", 96.6, 0],
[1198, "2026-08-22T02:30:00+09:00", 76.4, 2],
[1208, "2026-08-21T02:30:00+09:00", 76.2, 1],
[1218, "2026-08-20T02:30:00+09:00", 93.7, 0],
[1228, "2026-08-19T02:30:00+09:00", 98.1, 1],
[1238, "2026-08-18T02:30:00+09:00", 95.1, 0],
[1248, "2026-08-17T02:30:00+09:00", 99.1, 1],
[1258, "2026-08-16T02:30:00+09:00", 96.2, 0],
[1268, "2026-08-15T02:30:00+09:00", 94.7, 1],
[1278, "2026-08-14T02:30:00+09:00", 94.7, 0],
[3008, "2026-08-14T01:20:00+09:00", 73.6, 0],
[3017, "2026-08-15T01:20:00+09:00", 5.6, 1],
[3026, "2026-08-16T01:20:00+09:00", 98.5, 0],
[3035, "2026-08-17T01:20:00+09:00", 30.6, 1],
[3044, "2026-08-18T01:20:00+09:00", 85.1, 0],
[3053, "2026-08-19T01:20:00+09:00", 8.3, 1],
[3062, "2026-08-20T01:20:00+09:00", 92.8, 0],
[3071, "2026-08-21T01:20:00+09:00", 53.8, 1],
[3080, "2026-08-22T01:20:00+09:00", null, 2],
[3089, "2026-08-23T01:20:00+09:00", 79.2, 0],
[3098, "2026-08-24T01:20:00+09:00", 4.4, 1],
[3107, "2026-08-25T01:20:00+09:00", 98.1, 2],
[3116, "2026-08-26T01:20:00+09:00", 36.6, 3],
[3125, "2026-08-27T01:20:00+09:00", 87.4, 0],
[3134, "2026-08-28T01:20:00+09:00", 0.9, 1],
[3143, "2026-08-29T01:20:00+09:00", 95.9, 0],
[3152, "2026-08-30T01:20:00+09:00", 57.9, 1],
[3161, "2026-08-31T01:20:00+09:00", null, 2],
[3170, "2026-09-01T01:20:00+09:00", 71.2, 0],
[3179, "2026-09-02T01:20:00+09:00", 1, 1],
[3188, "2026-09-03T01:20:00+09:00", 99.4, 0],
[3197, "2026-09-04T01:20:00+09:00", 50.3, 1],
[3206, "2026-09-05T01:20:00+09:00", 76.1, 0],
[3215, "2026-09-06T01:20:00+09:00", 2.8, 1],
[3224, "2026-09-07T01:20:00+09:00", 93.7, 0],
[3233, "2026-09-08T01:20:00+09:00", 60.3, 1],
[3242, "2026-09-09T01:20:00+09:00", null, 2],
[3251, "2026-09-10T01:20:00+09:00", 88.6, 3],
[3260, "2026-09-11T01:20:00+09:00", 6.2, 4],
[3269, "2026-09-12T01:20:00+09:00", 94.7, 5],
[3278, "2026-09-13T01:20:00+09:00", 38.4, 6],
];
/** 段階0 実測: `db.cleanLogs()` の全件数（＝ `loadConsecutiveInputs()` が返すべき件数） */
const LOCAL_DB_TOTAL_MAIN_ROWS = 538;
const FACILITY_9_NAME = "メガバリューマート三ツ橋中央ショッピングセンター店";
/** ★段階0 実測★: `facilityPerformance()` の施設9の `consecutive_problem_days` */
const LOCAL_DB_FACILITY_PERFORMANCE_9: readonly {
period: "weekly" | "monthly";
year: number;
month: number;
week: number;
consecutive_problem_days: number;
}[] = [
{ period: "monthly", year: 2026, month: 8, week: 0, consecutive_problem_days: 2 },
{ period: "monthly", year: 2026, month: 9, week: 0, consecutive_problem_days: 6 },
{ period: "weekly", year: 2026, month: 9, week: 2, consecutive_problem_days: 5 },
{ period: "weekly", year: 2026, month: 9, week: 3, consecutive_problem_days: 6 },
];
/** ★段階0 実測★: `continuousProblems()` の施設9の全行（★`week: 5` は行が出ない★） */
const LOCAL_DB_CONTINUOUS_PROBLEMS_9: readonly {
period: "weekly" | "monthly";
year: number;
month: number;
week: number;
item: Record<string, unknown> | null;
}[] = [
{
period: "weekly",
year: 2026,
month: 8,
week: 3,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 1,
escalation_level: "L1",
last_problem_on: "2026-08-15",
summary: "{n}日連続で完了率が△以下",
launch_failed_days: 0,
},
},
{
period: "weekly",
year: 2026,
month: 8,
week: 4,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 2,
escalation_level: "L2",
last_problem_on: "2026-08-22",
summary: "{n}日連続で△以下（うち{m}日は出発失敗）",
launch_failed_days: 1,
},
},
// ★この週だけ行が出ない（連続0日）★ — 「全期間を読んでいれば必ず行が出る」ではないことの固定
{ period: "weekly", year: 2026, month: 8, week: 5, item: null },
{
period: "weekly",
year: 2026,
month: 8,
week: 6,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 2,
escalation_level: "L2",
last_problem_on: "2026-08-31",
summary: "{n}日連続で△以下（うち{m}日は出発失敗）",
launch_failed_days: 1,
},
},
{
period: "monthly",
year: 2026,
month: 8,
week: 0,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 2,
escalation_level: "L2",
last_problem_on: "2026-08-31",
summary: "{n}日連続で△以下（うち{m}日は出発失敗）",
launch_failed_days: 1,
},
},
{
period: "weekly",
year: 2026,
month: 9,
week: 2,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 5,
escalation_level: "L3",
last_problem_on: "2026-09-12",
summary: "{n}日連続で△以下（うち{m}日は出発失敗）",
launch_failed_days: 1,
},
},
{
period: "weekly",
year: 2026,
month: 9,
week: 3,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 6,
escalation_level: "L3",
last_problem_on: "2026-09-13",
summary: "{n}日連続で△以下（うち{m}日は出発失敗）",
launch_failed_days: 1,
},
},
{
period: "monthly",
year: 2026,
month: 9,
week: 0,
item: {
facility_id: 9,
facility_name: FACILITY_9_NAME,
consecutive_problem_days: 6,
escalation_level: "L3",
last_problem_on: "2026-09-13",
summary: "{n}日連続で△以下（うち{m}日は出発失敗）",
launch_failed_days: 1,
},
},
];
/**
* 施設9 の実測行から、DB に入っているのと同じ形の行を組み立てる。
*
* ★★完了率が `null`（未実施）の行はレポートを作らない★★（指示書AQ §1-1）—
* ★旧実装では `clean_error = 1` の履歴行を作っていた★が、`clean_task_reports` には
* その列が無く、★未実施は「行が無いこと」でしか表せない★。
* ★★段階0 の実測スナップショット（連続日数）は1つも変わらないこと★★が合格条件。
*/
function facility9Rows(): {
timetables: ConsecutiveTimetableRow[];
reports: ConsecutiveTaskReportRow[];
} {
const timetables: ConsecutiveTimetableRow[] = [];
const reports: ConsecutiveTaskReportRow[] = [];
for (const [id, jstIso, rate] of LOCAL_DB_FACILITY_9) {
timetables.push(timetable(id, 9, jstIso));
if (rate === null) continue; // ★未実施 ＝ レポートの行が無い★
reports.push(taskReport(id, rate, jstIso));
}
return { timetables, reports };
}
/** ★段階0 の実測より後の時刻★（未来除外が効かない基準時刻。実測時と同じ状態を再現する） */
const NOW_AFTER_LOCAL_DB = new Date("2026-09-30T00:00:00+09:00");
// ---------------------------------------------------------------- テスト
describe("loadConsecutiveInputs（指示書AC 段階1 — 連続日数の入力を1本に切り出す）", () => {
it("読む列を `select` で絞り、`include` を一切しない（★この2本だけが広い範囲を読むため★）", async () => {
const { prisma, calls } = stubPrisma(
[timetable(1, 1, "2026-09-01T02:00:00+09:00")],
[taskReport(1, 50)]
);
await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(calls.cleanTimetable).toEqual([
{
// ★範囲なしのときは `start_at` のキーごと付けない★。
// ★削除済みの施設・清掃エリアの行は入力に入れない（指示書BB U1・表1 V15）。`select` は変えない（5-12）★
where: { precheck: CLEAN_TIMETABLE_PRECHECK.main, ...FACILITY_SECTION_VISIBLE_WHERE },
// ★`end_at` は結果待ちの判定用（D-173）★
select: { id: true, facility_id: true, start_at: true, end_at: true, precheck: true },
},
]);
// ★★履歴にも同じ引数が渡る★★（指示書AU 段階3b。`where` を2回書かない）
expect(calls.cleanTimetableHistory).toEqual(calls.cleanTimetable);
expect(calls.cleanTaskReport).toEqual([
{
// ★レポートは「引いた本清掃の id」で引き直す（全件読みに戻さない）★
where: { clean_timetable_id: { in: [BigInt(1)] } },
select: {
clean_timetable_id: true,
clean_ratio: true,
// ★★`clean_error` は `clean_task_reports` に無い★★（指示書AQ §1-1）。
// ★この行が復活したら未実施の判定規則が戻っている★
// ★順序キーのフォールバック★（`ended_at` が nullable。指示書AQ §1-4）
started_at: true,
ended_at: true,
// ★旧: 要レスキューの急落判定（R-3）の面積の重み付けに読んでいた2列（指示書AI 段階2）★。
// ★2026-09-30 から R-3 は1回ごとの完了率の単純平均で、この2列は完了率の平均には使わない★（指示書AQ 決定4。D-155 以降の1回ごとの完了率は面積から `runCompletionRate()` が作るので、この2列はそのために読んでいる）。
// ★これ以上増やすときの条件は `loadConsecutiveInputs()` の docstring★
clean_area: true,
task_area: true,
},
},
]);
// ★`include` を足していないこと（キーが `where` と `select` だけ）★
for (const args of [...calls.cleanTimetable, ...calls.cleanTimetableHistory, ...calls.cleanTaskReport]) {
expect(Object.keys(args as object).sort()).toEqual(["select", "where"]);
}
});
it("★履歴（`clean_timetable_histories`）だけにある予定も読み、レポートを引き直す★（指示書AU 段階3b）", async () => {
const { prisma, calls } = stubPrisma(
[timetable(1, 1, "2026-09-01T02:00:00+09:00")],
[taskReport(1, 50), taskReport(2, 80)],
[timetable(2, 1, "2026-09-02T02:00:00+09:00")]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows.map((r) => r.id).sort()).toEqual([1, 2]);
// ★レポートは合わせた後の id で引く（履歴の予定に紐づく行も取れる）★
const reportIds = (calls.cleanTaskReport as { where: { clean_timetable_id: { in: bigint[] } } }[])
.flatMap((c) => c.where.clean_timetable_id.in)
.map(String)
.sort();
expect(reportIds).toEqual(["1", "2"]);
});
it("本清掃が0件なら履歴のクエリを1本も撃たない（`in: []` の空撃ちをしない）", async () => {
const { prisma, calls } = stubPrisma([], []);
const rows = await loadConsecutiveInputs(
prisma,
NOW_AFTER_LOCAL_DB,
CONSECUTIVE_RANGE_UNBOUNDED
);
expect(rows).toEqual([]);
expect(calls.cleanTaskReport).toEqual([]);
});
it("本清掃だけに絞る（事前チェック行は入れない）", async () => {
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-01T02:00:00+09:00"),
timetable(2, 1, "2026-09-01T01:00:00+09:00", 60),
timetable(3, 1, "2026-09-01T01:30:00+09:00", 30),
],
[taskReport(1, 50), taskReport(2, 0), taskReport(3, 0)]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows.map((r) => r.id)).toEqual([1]);
});
it("★`isFutureSchedule()` を外さない★ — 予定時刻がまだ来ていない本清掃を除外する（D-106 / D-107 / D-110）", async () => {
const now = new Date("2026-09-10T03:00:00+09:00");
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-10T02:00:00+09:00"),
timetable(2, 1, "2026-09-10T03:00:00+09:00"), // ★同時刻は「来ていない」に入れない★
timetable(3, 1, "2026-09-11T02:00:00+09:00"), // 未来 → 除外
],
// ★id 2 にもレポートを付ける★ — 無いと結果待ち（D-173）で外れ、`isFutureSchedule()` の境界を確かめられない
[taskReport(1, 50), taskReport(2, 50)]
);
const rows = await loadConsecutiveInputs(prisma, now, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows.map((r) => r.id)).toEqual([1, 2]);
// ★未来を外さないと履歴の無い行が「未実施（出発失敗）」として連続日数に混ざる★
expect(rows.find((r) => r.id === 3)).toBeUndefined();
});
it("★結果待ち（D-173。表2 C10）は未来の予定と同じく入力から外す★ — 確定した出発失敗は残す", async () => {
// 予定 02:00〜03:00、W=120（表1 と同じ時刻）。now=04:59 は結果待ち、レポートありは残る
const day = "2026-09-10";
const { prisma } = stubPrisma(
[
timetable(1, 1, `${day}T02:00:00+09:00`, CLEAN_TIMETABLE_PRECHECK.main, `${day}T03:00:00+09:00`), // レポートなし → 結果待ち
timetable(2, 1, `${day}T02:00:00+09:00`, CLEAN_TIMETABLE_PRECHECK.main, `${day}T03:00:00+09:00`), // レポートあり
timetable(3, 1, `${day}T00:00:00+09:00`, CLEAN_TIMETABLE_PRECHECK.main, `${day}T02:59:00+09:00`), // レポートなし・04:59 で確定
],
[taskReport(2, 50)]
);
const pending = await loadConsecutiveInputs(
prisma,
new Date(`${day}T04:59:00+09:00`),
CONSECUTIVE_RANGE_UNBOUNDED
);
expect(pending.map((r) => r.id).sort()).toEqual([2, 3]);
expect(pending.find((r) => r.id === 3)?.departed).toBe(false);
// ★終了＋120分ちょうど（05:00）で確定 → 出発失敗として入力に戻る（表1 P6）★
const settled = await loadConsecutiveInputs(
prisma,
new Date(`${day}T05:00:00+09:00`),
CONSECUTIVE_RANGE_UNBOUNDED
);
expect(settled.map((r) => r.id).sort()).toEqual([1, 2, 3]);
expect(settled.find((r) => r.id === 1)?.departed).toBe(false);
});
it("`start_at` を壁時計値として読む（`fromDbJst()` / `jstIsoFromDb()` を通す。D-115）", async () => {
const { prisma } = stubPrisma(
[timetable(1, 7, "2026-09-10T20:00:00+09:00")],
[taskReport(1, 88.6)]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows).toEqual([
{
id: 1,
unscheduled: false,
facility_id: 7,
scheduled_at: "2026-09-10T20:00:00+09:00",
completion_rate: 88.6,
departed: true,
// ★`taskReport()` の既定（面積 88.6/100）。この検証の対象は日時の読み方であって面積ではない★
clean_area: 88.6,
task_area: 100,
},
]);
});
it("★未実施＝レポートの行が無いこと★。完了率 0（面積 0/100）は 0 のまま（0%実施に化けさせない）", async () => {
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-01T02:00:00+09:00"), // ★レポートなし → 未実施★
timetable(2, 1, "2026-09-02T02:00:00+09:00"), // ★0% で実施★
timetable(3, 1, "2026-09-03T02:00:00+09:00"), // ★レポートなし → 未実施★
],
[taskReport(2, 0)]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
// ★「0%で実施した」と「未実施」は別物★（指示書U 落とし穴1。判定はどちらも × なので
// ★画面もテストも赤くならないまま壊れる★ところ）
expect(rows.map((r) => r.completion_rate)).toEqual([null, 0, null]);
});
it("レポートが複数あるときは順序キーが最新の1件を採る（指示書AQ §1-4）", async () => {
const { prisma } = stubPrisma(
[timetable(1, 1, "2026-09-01T02:00:00+09:00")],
[
taskReport(1, 10, "2026-09-01T03:00:00+09:00"),
taskReport(1, 90, "2026-09-01T05:00:00+09:00"),
taskReport(1, 40, "2026-09-01T04:00:00+09:00"),
]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows[0].completion_rate).toBe(90);
});
it("★面積の生値をそのまま持ち帰る（レポートなしは 0）★（指示書AI 段階2。★R-3 は面積で重み付けしない★ — 指示書AQ 決定4）", async () => {
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-01T02:00:00+09:00"),
timetable(2, 1, "2026-09-02T02:00:00+09:00"),
timetable(3, 1, "2026-09-03T02:00:00+09:00"),
],
[
taskReport(1, 90, "2026-09-01T05:00:00+09:00", 900, 1000),
// ★面積0（`task_area = 0`）で実施したレポート★（★未実施ではない★。表5 U2）
taskReport(2, 0, "2026-09-02T05:00:00+09:00", 0, 0),
// id=3 はレポートなし ＝ ★未実施★
]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows.map((r) => [r.clean_area, r.task_area])).toEqual([
[900, 1000],
[0, 0],
// ★★レポートが無い行は `undefined` ではなく 0★★（Prisma 版と fixtures 版の形を揃えるため。
// 旧: optional にすると R-3 の面積加重が静かに壊れる、という理由だった）
[0, 0],
]);
// ★★完了率は1回ごとの面積比（`runCompletionRate()`。D-155）★★ —
// id=1 は 900/1000 = 90、★id=2 は `task_area = 0` なので 0（P-5=B）★、id=3 はレポートなしで null
expect(rows.map((r) => r.completion_rate)).toEqual([90, 0, null]);
// ★★未実施は `departed` で見る★★（【未決1】案A。D-156）— ★id=2 は出発している★
expect(rows.map((r) => r.departed)).toEqual([true, true, false]);
});
it("★独立に書いた素朴な実装と完全一致する★（本体のヘルパーを1つも使わない突き合わせ）", () => {
const now = new Date("2026-09-10T03:00:00+09:00");
const timetables = [
timetable(1, 1, "2026-09-08T02:00:00+09:00"),
timetable(2, 1, "2026-09-09T02:00:00+09:00"), // ★レポートなし ＝ 未実施★
timetable(3, 1, "2026-09-10T02:00:00+09:00"),
timetable(4, 1, "2026-09-11T02:00:00+09:00"), // 未来
timetable(5, 2, "2026-09-08T01:00:00+09:00", 60), // 事前チェック
timetable(6, 2, "2026-09-08T02:00:00+09:00"),
timetable(7, 2, "2026-09-09T02:00:00+09:00"), // ★`ended_at` が NULL のレポート★
];
const reports = [
taskReport(1, 95),
// ★id=2 のレポートは作らない（未実施）★
taskReport(3, 0),
taskReport(4, 10),
taskReport(5, 0),
taskReport(6, 70),
// ★`clean_timetable_id` が NULL の行を混ぜる（罠1）★ — どの清掃にも結びつかない
taskReport(null, 100),
// ★`ended_at` が NULL の行を混ぜる（罠3 / §1-4）★
taskReport(7, 55, null, 55, 100, "2026-09-09T03:00:00+09:00"),
// ★`task_area = 0` の行（完了率 0。P-5=B・出発はしている。表5 U2）★
taskReport(6, 80, "2026-09-14T05:00:00+09:00", 10, 0),
];
const actual = consecutiveInputsFromRows(timetables, reports, now, []);
const legacy = legacyConsecutiveInputs(timetables, reports, now);
// ★`scheduled_at` の作り方だけは legacy 側の写しで表現できないので、id と値で突き合わせる★
expect(actual.map((r) => [r.id, r.facility_id, r.completion_rate])).toEqual(
legacy.map((r) => [r.id, r.facility_id, r.completion_rate])
);
expect(actual.map((r) => r.scheduled_at)).toEqual([
"2026-09-08T02:00:00+09:00",
"2026-09-09T02:00:00+09:00",
"2026-09-10T02:00:00+09:00",
"2026-09-08T02:00:00+09:00",
"2026-09-09T02:00:00+09:00",
]);
});
});
describe("指示書AQ — 参照元を `clean_task_reports` に差し替える（期待値表 Q1〜Q10）", () => {
it("Q3 ★`clean_timetable_id` が NULL のレポートは `IN` に一致せず、その清掃は「未実施」になる★（罠1）", async () => {
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-01T02:00:00+09:00"),
timetable(2, 1, "2026-09-02T02:00:00+09:00"),
],
[
taskReport(1, 95),
// ★本来は id=2 の結果だが `clean_timetable_id` が埋まっていない行★
// （指示書AQ 決定5 — TeamWorks が今後埋める前提）
taskReport(null, 95),
]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
// ★★行が消えるのではなく「未実施」に化けるのが危険なところ★★（fail-silent）。
// ★95% で実施されていても画面には未実施として出る★
expect(rows.map((r) => [r.id, r.completion_rate])).toEqual([
[1, 95],
[2, null],
]);
});
it("Q3c ★`clean_timetable_id` が 0（予定外。TeamWorks 回答 2026-10-27）のレポートも引き当たらない・0 を `IN` に入れない★", async () => {
const { prisma, calls } = stubPrisma(
[
// ★予定の id は自動採番で 0 にならないが、仮に 0 の予定があっても予定外のレポートを引き当てないこと★
timetable(0, 1, "2026-09-01T02:00:00+09:00"),
timetable(2, 1, "2026-09-02T02:00:00+09:00"),
],
[taskReport(0, 95), taskReport(2, 80)]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
const inIds = calls.cleanTaskReport.flatMap(
(call) => (call as { where: { clean_timetable_id: { in: bigint[] } } }).where.clean_timetable_id.in
);
expect(inIds).toEqual([BigInt(2)]);
// ★予定外（0）のレポートの 95% は、どの予定の完了率にもならない★
expect(rows.map((r) => [r.id, r.completion_rate])).toEqual([
[0, null],
[2, 80],
]);
});
it("Q3b ★NULL のレポートは `latestReportByTimetableId()`（担当C）でも落ちる★（Map のキーにできない）", () => {
const map = latestReportByTimetableId([
taskReport(null, 10),
taskReport(null, 20),
taskReport(1, 30),
]);
// ★★NULL 同士を1つのグループにまとめないこと★★（まとめると `null` キーで引けてしまう）
expect(map.size).toBe(1);
expect(map.get("1")?.clean_ratio).toBe(30);
});
it("Q5 ★`ended_at` が NULL の行は `started_at` を順序キーにする★（指示書AQ §1-4）", async () => {
const { prisma } = stubPrisma(
[timetable(1, 1, "2026-09-01T02:00:00+09:00")],
[
// ★`ended_at` あり（03:00）★
taskReport(1, 10, "2026-09-01T03:00:00+09:00", 10, 100, "2026-09-01T02:30:00+09:00"),
// ★`ended_at` なし → `started_at`（05:00）が順序キー★ → こちらが最新
taskReport(1, 90, null, 90, 100, "2026-09-01T05:00:00+09:00"),
]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
// ★`ended_at` だけを見て NULL 行を落とすと 10 になる★
expect(rows[0].completion_rate).toBe(90);
});
it("Q6 ★両方の `ended_at` が NULL なら `started_at` が新しいほう★", async () => {
const { prisma } = stubPrisma(
[timetable(1, 1, "2026-09-01T02:00:00+09:00")],
[
taskReport(1, 10, null, 10, 100, "2026-09-01T03:00:00+09:00"),
taskReport(1, 90, null, 90, 100, "2026-09-01T05:00:00+09:00"),
taskReport(1, 40, null, 40, 100, "2026-09-01T04:00:00+09:00"),
]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows[0].completion_rate).toBe(90);
});
it("Q7 ★順序キーが同着なら入力順の先頭★（`clean_status_histories` 時代と同じ規則）", () => {
const map = latestReportByTimetableId([
taskReport(1, 11, "2026-09-01T03:00:00+09:00"),
taskReport(1, 22, "2026-09-01T03:00:00+09:00"),
]);
expect(map.get("1")?.clean_ratio).toBe(11);
});
// ★★順序キーそのものの単体テストはここに書かない★★ — 担当C が
// `reportOrderKey()` を ★意図的に export していない★（規則を1箇所に閉じるため。
// `lib/db/clean-log-mapping.ts`）。★このファイルは Q5 / Q6 で**挙動として**固定する★。
it("Q1 / Q2 / Q8 ★未実施はレポートの行が無いことだけで決まる★（`completionRateFromReport()`）", () => {
// ★★`status`（3/4/5/6）で分岐しないこと★★ — 判定には使わない（D-155 項2 / 指示書AS D12）
expect(completionRateFromReport(undefined)).toBeNull();
// ★完了率は面積から（表1。`clean_ratio` 列は読まない）★
expect(completionRateFromReport({ clean_area: 50, task_area: 100, clean_ratio: 50 })).toBe(50);
// ★「0%で実施した」を `null` に化けさせない★
expect(completionRateFromReport({ clean_area: 0, task_area: 100, clean_ratio: 0 })).toBe(0);
// ★平均側では丸めない★（`CLAUDE.md` §4.3。89.5 は ○ のまま）
expect(completionRateFromReport({ clean_area: 89.5, task_area: 100, clean_ratio: 89.5 })).toBe(
89.5
);
});
// ★★表5（指示書AS §4。【未決1】案A。D-156）— `departed` の詰め方★★
// | # | 清掃 | departed | completion_rate |
// | U1 | レポートの行が無い | false | null |
// | U2 | ★行がある・task_area = 0★ | ★true★ | ★0.0★（P-5=B） |
// | U3 | 行がある・50/100 | true | 50.0 |
// | U4 | 行がある・100/100 | true | 100.0 |
it("表5 U1〜U4: `departed` はレポートの行の有無で詰める（完了率 null とは別）", () => {
const now = new Date("2026-09-10T03:00:00+09:00");
const rows = consecutiveInputsFromRows(
[
timetable(1, 1, "2026-09-01T02:00:00+09:00"), // U1
timetable(2, 1, "2026-09-02T02:00:00+09:00"), // U2
timetable(3, 1, "2026-09-03T02:00:00+09:00"), // U3
timetable(4, 1, "2026-09-04T02:00:00+09:00"), // U4
],
[taskReport(2, 0, undefined, 10, 0), taskReport(3, 50), taskReport(4, 100)],
now,
[]
);
expect(rows.map((r) => [r.id, r.departed, r.completion_rate])).toEqual([
[1, false, null],
[2, true, 0],
[3, true, 50],
[4, true, 100],
]);
});
});
describe("段階0（refactor 前）のローカルDB実測値と一致すること", () => {
it("#1 本清掃の行だけを全件返す（施設9 の実測62行。全体は 538 件）", async () => {
const { timetables, reports } = facility9Rows();
// ★事前チェック行と未来の行を混ぜても件数が変わらないこと★
const withNoise = [
...timetables,
timetable(90001, 9, "2026-09-13T01:30:00+09:00", 60),
timetable(90002, 9, "2026-10-01T02:30:00+09:00"),
];
const { prisma } = stubPrisma(withNoise, reports);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
expect(rows).toHaveLength(LOCAL_DB_FACILITY_9.length);
expect(rows).toHaveLength(62);
// ★段階0 実測の全件数（`db.cleanLogs()` = 538件）はこの施設9の62件を含む★
expect(LOCAL_DB_TOTAL_MAIN_ROWS).toBeGreaterThan(rows.length);
});
it("#2 `computeConsecutiveProblemDays()` の結果が段階0 のスナップショットと完全一致する", async () => {
const { timetables, reports } = facility9Rows();
const { prisma } = stubPrisma(timetables, reports);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
const consecutiveById = computeConsecutiveProblemDays(rows);
const actual = [...consecutiveById.entries()].sort((a, b) => a[0] - b[0]);
const expected = LOCAL_DB_FACILITY_9.map(
([id, , , days]): [number, number] => [id, days]
).sort((a, b) => a[0] - b[0]);
expect(actual).toEqual(expected);
});
it("#3 `facilityPerformance()` の `consecutive_problem_days` が段階0 と一致する", async () => {
const { timetables, reports } = facility9Rows();
const { prisma } = stubPrisma(timetables, reports);
const entries = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
const consecutiveByFacilityDate = consecutiveProblemDaysByFacilityDate(entries);
for (const expected of LOCAL_DB_FACILITY_PERFORMANCE_9) {
const range = periodRange(
expected.period,
expected.year,
expected.month,
expected.week
);
expect(range).not.toBeNull();
const days = consecutiveProblemDaysAtPeriodEnd(
entries,
consecutiveByFacilityDate,
9,
range as { from: string; to: string }
);
expect({ ...expected, consecutive_problem_days: days }).toEqual(expected);
}
});
it("#4 `continuousProblems()` の行が段階0 と一致する（行が出ない期間も含む）", async () => {
const { timetables, reports } = facility9Rows();
const { prisma } = stubPrisma(timetables, reports);
const entries = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
const consecutiveByFacilityDate = consecutiveProblemDaysByFacilityDate(entries);
const facilityNameById = new Map<number, string>([[9, FACILITY_9_NAME]]);
for (const expected of LOCAL_DB_CONTINUOUS_PROBLEMS_9) {
const range = periodRange(
expected.period,
expected.year,
expected.month,
expected.week
);
expect(range).not.toBeNull();
const items = continuousProblemsInPeriod(
entries,
consecutiveByFacilityDate,
facilityNameById,
range as { from: string; to: string }
);
expect(items).toEqual(expected.item === null ? [] : [expected.item]);
}
});
});
describe("合成データ（段階1 期待値表 #5 / #6）", () => {
it("#5 同一施設・2台 — 1日目にA、2日目にBが問題なら★2日連続★（D-109 A案）", async () => {
// 施設1 に清掃エリアが2つ（ロボットA: id 1,2 / ロボットB: id 11,12）
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-01T01:00:00+09:00"), // A: 問題あり
timetable(11, 1, "2026-09-01T02:00:00+09:00"), // B: 正常
timetable(2, 1, "2026-09-02T01:00:00+09:00"), // A: 正常
timetable(12, 1, "2026-09-02T02:00:00+09:00"), // B: 問題あり
],
[taskReport(1, 30), taskReport(11, 95), taskReport(2, 95), taskReport(12, 30)]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
const map = computeConsecutiveProblemDays(rows);
expect(map.get(1)).toBe(1);
expect(map.get(11)).toBe(1); // ★同じ日の全行が同じ値になる★
expect(map.get(2)).toBe(2);
expect(map.get(12)).toBe(2);
});
it("#6 清掃予定のない日を挟んでも連続が途切れない（D-026。「連続」はスケジュール存在日の連続）", async () => {
const { prisma } = stubPrisma(
[
timetable(1, 1, "2026-09-01T02:00:00+09:00"),
// 9/2・9/3 は清掃予定なし（行そのものが無い）
timetable(2, 1, "2026-09-04T02:00:00+09:00"),
timetable(3, 1, "2026-09-05T02:00:00+09:00"),
],
[taskReport(1, 30), taskReport(2, 30), taskReport(3, 30)]
);
const rows = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, CONSECUTIVE_RANGE_UNBOUNDED);
const map = computeConsecutiveProblemDays(rows);
expect(map.get(1)).toBe(1);
expect(map.get(2)).toBe(2);
expect(map.get(3)).toBe(3);
});
});
// ---------------------------------------------------------------- 段階6（遡り範囲を有界にする）
/**
* 指示書AC ★段階6★ の期待値表（7行）。
*
* | # | 入力 | 期待 |
* |---|---|---|
* | 1 | 連続が上限未満 | 段階5（全期間読み）と同じ数字 |
* | 2 | 連続が上限を超える | 上限で頭打ち。かつ「以上」と分かる表示（`capped: true`） |
* | 3 | 清掃予定のない日を挟む | 連続が途切れない（D-026。★カレンダー日で遡ると壊れるところ★） |
* | 4 | `/detail-log` と `/reports` | 同じ施設・同じ日で同じ数字（D-109 の再発防止） |
* | 5 | 管理画面で上限を大きくした | クエリの遡り範囲も追随して広がる |
* | 6 | 管理画面で上限を小さくした | 表示も遡り範囲も小さいほうに追随する |
* | 7 | 上限を超える連続日数のデータ | `capped=true` が実際に出る（＝「上限 +1日ぶん」読めていることの検出） |
*
* ★★#7 が無いと、`+1` を忘れても #1〜#6 は全部緑のままです★★
* （`rawDays` が上限を超えられなくなるだけで、他の行はどれも落ちない）。
*/
/** `YYYY-MM-DD` に日数を足す（★実行環境のタイムゾーンに依存しない UTC 演算★） */
function jstDatePlus(date: string, days: number): string {
return new Date(new Date(`${date}T00:00:00Z`).getTime() + days * 86_400_000)
.toISOString()
.slice(0, 10);
}
/**
* 「問題あり（完了率 5% ＝ ×）」の清掃を `days` 日ぶん作る。
* @param stepDays 清掃予定日の間隔（★1 なら毎日、3 なら2日おきに予定が無い★。D-026 の検証用）
*/
function problemRun(
facilityId: number,
lastDate: string,
days: number,
startId: number,
stepDays = 1
): {
timetables: ConsecutiveTimetableRow[];
reports: ConsecutiveTaskReportRow[];
lastId: number;
} {
const timetables: ConsecutiveTimetableRow[] = [];
const reports: ConsecutiveTaskReportRow[] = [];
for (let i = 0; i < days; i++) {
const date = jstDatePlus(lastDate, -(days - 1 - i) * stepDays);
const id = startId + i;
timetables.push(timetable(id, facilityId, `${date}T02:00:00+09:00`));
reports.push(taskReport(id, 5, `${date}T03:00:00+09:00`));
}
return { timetables, reports, lastId: startId + days - 1 };
}
/** その範囲で読んだときの、指定ログの ★丸める前の★ 連続日数と、実際の遡り下限 */
async function rawConsecutiveDays(
rows: { timetables: ConsecutiveTimetableRow[]; reports: ConsecutiveTaskReportRow[] },
range: ConsecutiveDbRange,
logId: number
): Promise<{ days: number; gte: Date | undefined }> {
const { prisma, calls } = stubPrisma(rows.timetables, rows.reports);
const entries = await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, range);
const map = computeConsecutiveProblemDays(entries);
const args = calls.cleanTimetable[0] as { where?: { start_at?: { gte?: Date } } };
return { days: map.get(logId) ?? 0, gte: args.where?.start_at?.gte };
}
/** 遡り下限（`gte`）として期待される「DBの壁時計値」 */
function expectedGte(dateFrom: string, maxDays: number): Date {
const from = consecutiveLookbackFrom(dateFrom, maxDays);
expect(from).not.toBeNull();
return dbWallClock(`${from as string}T00:00:00+09:00`);
}
describe("consecutiveLookbackFrom / consecutiveLookbackCalendarDays（純粋関数）", () => {
it("★下限なし（`null`）はそのまま `null`★ — 全期間を読む（単一ID取得の経路）", () => {
expect(consecutiveLookbackFrom(null, CONSECUTIVE_DAYS_DISPLAY.defaultMax)).toBeNull();
// 形式が不正な文字列も「指定なし」（検証は `parseCleanLogQuery()` の仕事）
expect(consecutiveLookbackFrom("2026/09/13", 30)).toBeNull();
});
it("★★遡り幅は必ず「上限 +1日ぶん」以上★★（#7 の検出条件。★ここを割ると `capped` が永久に false★）", () => {
for (const maxDays of [
CONSECUTIVE_DAYS_DISPLAY.minMax,
CONSECUTIVE_DAYS_DISPLAY.defaultMax,
CONSECUTIVE_DAYS_DISPLAY.maxMax,
]) {
expect(consecutiveLookbackCalendarDays(maxDays)).toBeGreaterThanOrEqual(maxDays + 1);
}
// ★`plusDays` を 0 にしないこと★（設定値そのものを固定しておく）
expect(CONSECUTIVE_LOOKBACK.plusDays).toBeGreaterThanOrEqual(1);
expect(CONSECUTIVE_LOOKBACK.calendarDaysPerScheduleDay).toBeGreaterThanOrEqual(1);
});
it("★カレンダー日で数え、スケジュール存在日より**広く**取る★（D-026 の安全側）", () => {
// 上限30日 → (30 + 1) × 7 ＝ 217 カレンダー日ぶん遡る
expect(consecutiveLookbackCalendarDays(30)).toBe(217);
expect(consecutiveLookbackFrom("2026-09-13", 30)).toBe(jstDatePlus("2026-09-13", -217));
});
});
describe("段階6 — 連続日数のクエリを有界にする", () => {
it("#1 連続が上限未満なら、段階5（全期間読み）と同じ数字になる", async () => {
useSavedConsecutiveDaysMax(undefined); // 既定値 30
const rows = problemRun(1, "2026-09-13", 5, 10_000);
const bounded = await rawConsecutiveDays(
rows,
{ date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null },
rows.lastId
);
const unbounded = await rawConsecutiveDays(
rows,
CONSECUTIVE_RANGE_UNBOUNDED,
rows.lastId
);
expect(bounded.days).toBe(5);
expect(bounded.days).toBe(unbounded.days);
expect(
capConsecutiveDays(bounded.days, CONSECUTIVE_DAYS_DISPLAY.defaultMax).capped
).toBe(false);
});
it("#2 連続が上限を超えたら上限で頭打ちになり、「以上」と分かる表示になる", async () => {
const maxDays = 3;
useSavedConsecutiveDaysMax(maxDays);
const rows = problemRun(1, "2026-09-13", 10, 20_000);
const { days } = await rawConsecutiveDays(
rows,
{ date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null },
rows.lastId
);
expect(days).toBe(10); // ★判定に使う生値は頭打ちにしない（CLAUDE.md §4.3）★
expect(capConsecutiveDays(days, maxDays)).toEqual({ days: 3, capped: true });
});
it("#3 ★清掃予定のない日を挟んでも連続が途切れない★（D-026。カレンダー日で遡ると壊れるところ）", async () => {
const maxDays = 3;
useSavedConsecutiveDaysMax(maxDays);
// 3日おきの清掃予定を4回 → 9/04・9/07・9/10・9/13（★スケジュール存在日では4日連続★）
const rows = problemRun(1, "2026-09-13", 4, 30_000, 3);
const { days, gte } = await rawConsecutiveDays(
rows,
{ date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null },
rows.lastId
);
// ★★「上限＋1」をカレンダー日として遡る実装（9/09 まで）だと 2 になる★★
expect(days).toBe(4);
// 実際の遡り下限は (3+1)×7 ＝ 28 カレンダー日前（＝ 8/16）
expect(gte).toEqual(expectedGte("2026-09-13", maxDays));
});
it("#4 `/detail-log`（1日）と `/reports`（週・月）で同じ施設・同じ日の数字が一致する", async () => {
useSavedConsecutiveDaysMax(undefined);
const rows = problemRun(1, "2026-09-13", 8, 40_000);
// `/detail-log` … `cleanLogs()` は画面の日付範囲をそのまま渡す
const detailLog = await rawConsecutiveDays(
rows,
{ date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null },
rows.lastId
);
// `/reports` … `continuousProblems()` / `facilityPerformance()` は `periodRange()` の範囲
const weekly = periodRange("weekly", 2026, 9, 3) as { from: string; to: string };
const monthly = periodRange("monthly", 2026, 9, 0) as { from: string; to: string };
const reportsWeekly = await rawConsecutiveDays(
rows,
{ date_from: weekly.from, date_to: weekly.to, facility_ids: null },
rows.lastId
);
const reportsMonthly = await rawConsecutiveDays(
rows,
{ date_from: monthly.from, date_to: monthly.to, facility_ids: null },
rows.lastId
);
expect(detailLog.days).toBe(8);
expect(reportsWeekly.days).toBe(8);
expect(reportsMonthly.days).toBe(8);
});
it("#4b 上限を超える連続でも、3経路とも同じ「{上限}日以上」になる（D-109 の再発防止）", async () => {
const maxDays = 3;
useSavedConsecutiveDaysMax(maxDays);
const rows = problemRun(1, "2026-09-13", 60, 45_000);
const weekly = periodRange("weekly", 2026, 9, 3) as { from: string; to: string };
const shown = [];
for (const range of [
{ date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null },
{ date_from: weekly.from, date_to: weekly.to, facility_ids: null },
CONSECUTIVE_RANGE_UNBOUNDED,
]) {
const { days } = await rawConsecutiveDays(rows, range, rows.lastId);
shown.push(capConsecutiveDays(days, maxDays));
}
// ★生値は経路ごとに違いうる（読める範囲が違う）が、★★画面に出る値は一致する★★
expect(shown).toEqual([
{ days: 3, capped: true },
{ days: 3, capped: true },
{ days: 3, capped: true },
]);
});
it("#5 ★管理画面で上限を大きくすると、クエリの遡り範囲も追随して広がる★", async () => {
const rows = problemRun(1, "2026-09-13", 100, 50_000);
const range: ConsecutiveDbRange = { date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null };
useSavedConsecutiveDaysMax(3);
const small = await rawConsecutiveDays(rows, range, rows.lastId);
useSavedConsecutiveDaysMax(90);
const large = await rawConsecutiveDays(rows, range, rows.lastId);
// ★遡り下限が実際に古くなっていること★
expect(small.gte).toEqual(expectedGte("2026-09-13", 3));
expect(large.gte).toEqual(expectedGte("2026-09-13", 90));
expect(large.gte?.getTime()).toBeLessThan(small.gte?.getTime() ?? 0);
// ★★上限を上げたぶん、実際に読めた行数（＝生値）も増えること★★ —
// ★設定だけ大きくしてクエリが古い範囲のままだと、ここが変わらない（静かな不整合。申し送り⑪）★
expect(small.days).toBe(consecutiveLookbackCalendarDays(3) + 1); // 28日前〜当日 ＝ 29日
expect(large.days).toBe(100); // 637日ぶん読めるので全部入る
expect(capConsecutiveDays(large.days, 90)).toEqual({ days: 90, capped: true });
});
it("#6 ★管理画面で上限を小さくすると、表示も遡り範囲も小さいほうに追随する★", async () => {
const rows = problemRun(1, "2026-09-13", 100, 60_000);
const range: ConsecutiveDbRange = { date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null };
useSavedConsecutiveDaysMax(CONSECUTIVE_DAYS_DISPLAY.defaultMax);
const before = await rawConsecutiveDays(rows, range, rows.lastId);
useSavedConsecutiveDaysMax(CONSECUTIVE_DAYS_DISPLAY.minMax);
const after = await rawConsecutiveDays(rows, range, rows.lastId);
expect(after.gte?.getTime()).toBeGreaterThan(before.gte?.getTime() ?? 0);
expect(after.days).toBeLessThan(before.days);
expect(capConsecutiveDays(after.days, CONSECUTIVE_DAYS_DISPLAY.minMax)).toEqual({
days: CONSECUTIVE_DAYS_DISPLAY.minMax,
capped: true,
});
});
it("#7 ★★上限をちょうど1日超える連続で `capped: true` が出る★★（＝「上限 +1日ぶん」読めている証拠）", async () => {
const maxDays = CONSECUTIVE_DAYS_DISPLAY.minMax; // 3
useSavedConsecutiveDaysMax(maxDays);
// ★ちょうど「上限 +1日」ぶんだけ問題が続く★
const rows = problemRun(1, "2026-09-13", maxDays + 1, 70_000);
const { days } = await rawConsecutiveDays(
rows,
{ date_from: "2026-09-13", date_to: "2026-09-13", facility_ids: null },
rows.lastId
);
// ★★上限ぴったりまでしか読まない実装だと `days === maxDays` になり、下の `capped` が false に★★
expect(days).toBe(maxDays + 1);
expect(capConsecutiveDays(days, maxDays).capped).toBe(true);
});
});
// ★表10 N1〜N3（指示書BB A6・D16・D-182）★ — `facility_ids` の `null`（絞らない）と `[]`（0行）を取り違えない（罠1）
describe("loadConsecutiveInputs — 施設で絞る（指示書BB 表10 N1〜N3）", () => {
function timetableWheres(calls: Record<string, unknown[]>) {
return [...calls.cleanTimetable, ...calls.cleanTimetableHistory].map(
(c) => (c as { where: Record<string, unknown> }).where
);
}
it("N1: `facility_ids: null` → 予定の `where` に `facility_id` の条件が無い（今と同じ SQL）", async () => {
const { prisma, calls } = stubPrisma([timetable(1, 1, "2026-09-01T02:00:00+09:00")], []);
await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, { date_from: null, date_to: null, facility_ids: null });
const wheres = timetableWheres(calls);
expect(wheres).toHaveLength(2);
for (const where of wheres) expect(where).not.toHaveProperty("facility_id");
});
it("N2: `facility_ids: [1, 3]` → 2表とも `facility_id: { in: [1n, 3n] }`", async () => {
const { prisma, calls } = stubPrisma([timetable(1, 1, "2026-09-01T02:00:00+09:00")], []);
await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, { date_from: null, date_to: null, facility_ids: [1, 3] });
const wheres = timetableWheres(calls);
expect(wheres).toHaveLength(2);
for (const where of wheres) expect(where.facility_id).toEqual({ in: [BigInt(1), BigInt(3)] });
});
it("★N3: `facility_ids: []` → `facility_id: { in: [] }`（`null` と取り違えない。罠1）★", async () => {
const { prisma, calls } = stubPrisma([timetable(1, 1, "2026-09-01T02:00:00+09:00")], []);
await loadConsecutiveInputs(prisma, NOW_AFTER_LOCAL_DB, { date_from: null, date_to: null, facility_ids: [] });
for (const where of timetableWheres(calls)) expect(where.facility_id).toEqual({ in: [] });
});
});
// ══════════════════════════════════════════════════════════════════════════════
// ★★指示書BG §2-3 — 予定外タスクも連続日数・要レスキュー・連続問題の入力に入れる★★
// ══════════════════════════════════════════════════════════════════════════════
/**
* 前提（指示書BG §3）: 今 = 2026-10-29 10:00 JST、施設 F1（id 1）。
*
* ★表U4（監督が書いた。数字を変えない）★
* | # | 施設 F1 の日ごとの結果 | 期待 |
* |---|---|---|
* | U4-1 | 10-26 予定 ×、10-27 予定外だけ（完了率 50）、10-28 予定 △ | 3日連続 → L3 |
* | U4-2 | 10-27 に予定 ◎ と 予定外 △ | その日は問題日（OR） |
* | U4-3 | 10-27 予定外だけ（完了率 95） | 問題日ではない → 連続が切れる |
*
* ★表U1 のうち連続日数の入力にかかるもの★（U1-2 / U1-3 / U1-4 / U1-5）も下で固める。
*/
describe("指示書BG §2-3 — 予定外タスクを連続日数の入力に入れる", () => {
const NOW = new Date("2026-10-29T10:00:00+09:00");
const F1 = 1;
/** 予定の行とそのレポート（完了率 `rate`。`null` はレポートなし＝未実施） */
function scheduled(id: number, jstIso: string, rate: number | null) {
return {
timetable: timetable(id, F1, jstIso),
reports: rate === null ? [] : [taskReport(id, rate, null, rate, 100, jstIso)],
};
}
function inputs(
runs: { timetable: ConsecutiveTimetableRow; reports: ConsecutiveTaskReportRow[] }[],
unscheduled: ConsecutiveUnscheduledReportRow[]
): ConsecutiveInput[] {
return consecutiveInputsFromRows(
runs.map((r) => r.timetable),
runs.flatMap((r) => r.reports),
NOW,
unscheduled
);
}
/** その施設のその日の連続日数（施設 × 日付で引く。予定外の行も同じ値） */
function daysOn(rows: readonly ConsecutiveInput[], date: string): number | undefined {
return consecutiveProblemDaysByFacilityDate(rows).get(facilityDateKey(F1, date));
}
it("U4-1 10-26 予定 ×、10-27 予定外だけ（50）、10-28 予定 △ → 3日連続 → L3", () => {
const rows = inputs(
[scheduled(1, "2026-10-26T21:00:00+09:00", 5), scheduled(3, "2026-10-28T21:00:00+09:00", 40)],
[unscheduledReport(F1, "2026-10-27T21:00:00+09:00", 50)]
);
expect(daysOn(rows, "2026-10-28")).toBe(3);
expect(judgeEscalationLevel(daysOn(rows, "2026-10-28") ?? 0)).toBe("L3");
// ★予定のある行は id の Map でも同じ値★（`computeConsecutiveProblemDays()`。予定外の行は id が無いので載らない）
const byId = computeConsecutiveProblemDays(rows);
expect(byId.get(3)).toBe(3);
expect([...byId.keys()].sort()).toEqual([1, 3]);
// ★予定外の行の日（10-27）も連続2日目★
expect(daysOn(rows, "2026-10-27")).toBe(2);
});
it("U4-2 10-27 に予定 ◎ と予定外 △ → その日は問題日（OR）", () => {
const rows = inputs(
[scheduled(2, "2026-10-27T21:00:00+09:00", 95)],
[unscheduledReport(F1, "2026-10-27T23:00:00+09:00", 40)]
);
expect(foldProblemDaysByDate(rows)).toEqual([{ date: "2026-10-27", isProblem: true }]);
expect(daysOn(rows, "2026-10-27")).toBe(1);
});
it("U4-3 10-27 予定外だけ（95）→ 問題日ではない → 連続が切れる", () => {
const rows = inputs(
[scheduled(1, "2026-10-26T21:00:00+09:00", 5), scheduled(3, "2026-10-28T21:00:00+09:00", 40)],
[unscheduledReport(F1, "2026-10-27T21:00:00+09:00", 95)]
);
expect(foldProblemDaysByDate(rows).map((d) => [d.date, d.isProblem])).toEqual([
["2026-10-26", true],
["2026-10-27", false],
["2026-10-28", true],
]);
expect(daysOn(rows, "2026-10-28")).toBe(1);
expect(judgeEscalationLevel(1)).toBe("L1");
});
it("U1-2 / U1-4 予定外の `clean_area` 0・`task_area` 0 → 完了率 0・出発済み（未実施ではない）", () => {
const rows = inputs(
[],
[
unscheduledReport(F1, "2026-10-27T21:00:00+09:00", 0, 100),
unscheduledReport(F1, "2026-10-28T21:00:00+09:00", 10, 0),
]
);
expect(rows.map((r) => [r.id, r.unscheduled, r.departed, r.completion_rate])).toEqual([
[null, true, true, 0],
[null, true, true, 0],
]);
});
it("U1-3 `clean_timetable_id` が 0 と NULL → どちらも予定外として同じ扱い", () => {
const zero = inputs([], [unscheduledReport(F1, "2026-10-28T21:00:00+09:00", 50, 100, 0)]);
const nul = inputs([], [unscheduledReport(F1, "2026-10-28T21:00:00+09:00", 50, 100, null)]);
expect(zero).toEqual(nul);
expect(zero[0]).toEqual({
id: null,
unscheduled: true,
facility_id: F1,
// ★日付は `started_at`（実際に始めた時刻）★
scheduled_at: "2026-10-28T21:00:00+09:00",
completion_rate: 50,
departed: true,
clean_area: 50,
task_area: 100,
});
});
it("予定の id を持つ行が予定外として渡されても入れない（SQL の写しが漏れても二重に数えない）", () => {
const leaked: ConsecutiveUnscheduledReportRow = {
...unscheduledReport(F1, "2026-10-28T21:00:00+09:00", 50),
clean_timetable_id: BigInt(7),
};
expect(inputs([], [leaked])).toEqual([]);
});
it("予定外の行は結果待ちにならない（始めたのが今の直前でも入る。予定外は結果が届いている）", () => {
const rows = inputs([], [unscheduledReport(F1, "2026-10-29T09:30:00+09:00", 80)]);
expect(rows).toHaveLength(1);
});
it("U1-5 loadConsecutiveInputs: 3本目で予定外を読む（`OR`（NULL・0）・削除済みの除外・期間は `started_at`・施設の絞り込み）", async () => {
const { prisma, calls } = stubPrisma(
[timetable(1, F1, "2026-10-28T21:00:00+09:00")],
[taskReport(1, 90)],
[],
[
unscheduledReport(F1, "2026-10-28T23:00:00+09:00", 40),
// ★他の施設（絞り込みで外れる）★
unscheduledReport(2, "2026-10-28T23:00:00+09:00", 40),
]
);
const rows = await loadConsecutiveInputs(prisma, NOW, {
date_from: "2026-10-28",
date_to: "2026-10-28",
facility_ids: [F1],
});
expect(calls.cleanTaskReportUnscheduled).toHaveLength(1);
const args = calls.cleanTaskReportUnscheduled[0] as {
where: ConsecutiveUnscheduledReportWhere;
select: Record<string, true>;
};
expect(args.where.OR).toEqual([{ clean_timetable_id: null }, { clean_timetable_id: BigInt(0) }]);
// ★削除済みの施設・清掃エリアは外す（表U1 U1-5）★
expect(args.where).toMatchObject(FACILITY_SECTION_VISIBLE_WHERE);
expect(args.where.facility_id).toEqual({ in: [BigInt(F1)] });
// ★期間は予定の行と同じ遡り範囲（`start_at` と同じ値）を `started_at` に当てる★
const timetableWhere = (calls.cleanTimetable[0] as { where: { start_at: unknown } }).where;
expect(args.where.started_at).toEqual(timetableWhere.start_at);
// ★列は2本目と同じ6列 ＋ `facility_id`★（`include` は付けない）
expect(Object.keys(args).sort()).toEqual(["select", "where"]);
expect(Object.keys(args.select).sort()).toEqual(
["clean_area", "clean_ratio", "clean_timetable_id", "ended_at", "facility_id", "started_at", "task_area"].sort()
);
// ★施設 F1 の予定1件 ＋ 予定外1件★（施設2 の予定外は絞り込みで外れる）
expect(rows.map((r) => [r.id, r.unscheduled, r.facility_id])).toEqual([
[1, false, F1],
[null, true, F1],
]);
});
it("loadConsecutiveInputs: 予定が0件でも予定外は読む（予定外だけの施設も連続日数を持つ）", async () => {
const { prisma, calls } = stubPrisma([], [], [], [unscheduledReport(F1, "2026-10-28T23:00:00+09:00", 40)]);
const rows = await loadConsecutiveInputs(prisma, NOW, CONSECUTIVE_RANGE_UNBOUNDED);
// ★2本目（予定の id で引く）は撃たない★
expect(calls.cleanTaskReport).toEqual([]);
expect(rows.map((r) => [r.id, r.unscheduled])).toEqual([[null, true]]);
});
});
/**
* ★指示書BG §2-3 — 要レスキュー★（`buildRescueRequired()` → `judgeRescue()`。判定は変えない）。
* - R-1（未実施3日連続）: 予定外は未実施にならない
* - R-2（L3）: 予定外だけの日も連続を作る（表U4 U4-1）
* - R-3（急落）: 予定外もその日の完了率の平均に入る
*/
describe("指示書BG §2-3 — 要レスキューに予定外タスクを入れる", () => {
const NOW = new Date("2026-10-29T10:00:00+09:00");
const NAMES = [{ id: 1, facility_name: "F1" }];
function rescue(
timetables: ConsecutiveTimetableRow[],
reports: ConsecutiveTaskReportRow[],
unscheduled: ConsecutiveUnscheduledReportRow[]
) {
return buildRescueRequired(consecutiveInputsFromRows(timetables, reports, NOW, unscheduled), NAMES, "2026-10-29");
}
it("R-1: 未実施の日に予定外が走っても未実施の日のまま（予定外は未実施を打ち消さない）→ 3日連続で要レスキュー", () => {
const items = rescue(
[
timetable(1, 1, "2026-10-26T21:00:00+09:00"),
timetable(2, 1, "2026-10-27T21:00:00+09:00"),
timetable(3, 1, "2026-10-28T21:00:00+09:00"),
],
[],
[unscheduledReport(1, "2026-10-27T23:00:00+09:00", 95)]
);
expect(items).toHaveLength(1);
expect(items[0].reasons).toContain("not_executed_streak");
expect(items[0].not_executed_days).toBe(3);
});
it("R-1: 予定外だけの日は「未実施でない日」として未実施の連続を切る（予定外は未実施にならない）", () => {
const items = rescue(
[timetable(1, 1, "2026-10-26T21:00:00+09:00"), timetable(3, 1, "2026-10-28T21:00:00+09:00")],
[],
[unscheduledReport(1, "2026-10-27T21:00:00+09:00", 95)]
);
// ★10-26 と 10-28 の未実施は問題日だが、10-27（予定外 95）で連続が切れる → L1・未実施1日 → 要レスキューでない★
expect(items).toEqual([]);
});
it("R-2: 表U4 U4-1 の施設は L3 で要レスキュー（予定外だけの日が連続を作る）", () => {
const items = rescue(
[timetable(1, 1, "2026-10-26T21:00:00+09:00"), timetable(3, 1, "2026-10-28T21:00:00+09:00")],
[
taskReport(1, 5, null, 5, 100, "2026-10-26T21:00:00+09:00"),
taskReport(3, 40, null, 40, 100, "2026-10-28T21:00:00+09:00"),
],
[unscheduledReport(1, "2026-10-27T21:00:00+09:00", 50)]
);
expect(items).toHaveLength(1);
expect(items[0].consecutive_problem_days).toBe(3);
expect(items[0].reasons).toContain("escalation_l3");
});
it("R-3: 予定外の完了率もその日の平均に入る（10-27 予定 80 → 10-28 予定 80 ＋ 予定外 20 ＝ 平均 50 → 急落）", () => {
const items = rescue(
[timetable(2, 1, "2026-10-27T21:00:00+09:00"), timetable(3, 1, "2026-10-28T21:00:00+09:00")],
[
taskReport(2, 80, null, 80, 100, "2026-10-27T21:00:00+09:00"),
taskReport(3, 80, null, 80, 100, "2026-10-28T21:00:00+09:00"),
],
[unscheduledReport(1, "2026-10-28T23:00:00+09:00", 20)]
);
expect(items).toHaveLength(1);
expect(items[0].reasons).toEqual(["completion_drop"]);
expect(items[0].previous_completion_rate).toBe(80);
expect(items[0].completion_rate).toBe(50);
expect(items[0].evaluated_on).toBe("2026-10-28");
});
it("評価日の行が予定外だけでも連続日数を引ける（施設 × 日付で引く）", () => {
const items = rescue(
[timetable(1, 1, "2026-10-26T21:00:00+09:00"), timetable(2, 1, "2026-10-27T21:00:00+09:00")],
[
taskReport(1, 5, null, 5, 100, "2026-10-26T21:00:00+09:00"),
taskReport(2, 5, null, 5, 100, "2026-10-27T21:00:00+09:00"),
],
[unscheduledReport(1, "2026-10-28T21:00:00+09:00", 5)]
);
expect(items).toHaveLength(1);
expect(items[0].evaluated_on).toBe("2026-10-28");
expect(items[0].consecutive_problem_days).toBe(3);
});
});
/** ★指示書BG §2-3 — 連続問題施設（レポート）★: 期間内の最終エントリが予定外でも連続日数を引く */
describe("指示書BG §2-3 — 連続問題施設に予定外タスクを入れる", () => {
it("期間 10-28 の最終エントリ（予定外）から3日連続・L3", () => {
const now = new Date("2026-10-29T10:00:00+09:00");
const entries = consecutiveInputsFromRows(
[timetable(1, 1, "2026-10-26T21:00:00+09:00"), timetable(2, 1, "2026-10-27T21:00:00+09:00")],
[taskReport(1, 5, null, 5, 100, "2026-10-26T21:00:00+09:00")],
now,
[
unscheduledReport(1, "2026-10-27T23:00:00+09:00", 50),
unscheduledReport(1, "2026-10-28T21:00:00+09:00", 40),
]
);
const items = continuousProblemsInPeriod(
entries,
consecutiveProblemDaysByFacilityDate(entries),
new Map([[1, "F1"]]),
{ from: "2026-10-28", to: "2026-10-28" }
);
expect(items).toEqual([
expect.objectContaining({
facility_id: 1,
consecutive_problem_days: 3,
escalation_level: "L3",
last_problem_on: "2026-10-28",
// ★10-27 の予定は未実施（予定外は別の1回）→ 出発失敗の日は1日★
launch_failed_days: 1,
}),
]);
});
});
