Jesse_Chen
729 lines
25 KiB
TypeScript
729 lines
25 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { readFileSync } from "node:fs";
|
|
import test from "node:test";
|
|
import {
|
|
PersonalReportJobServiceError,
|
|
createSupabasePersonalReportJobService,
|
|
type PersonalReportJobQueryResult,
|
|
} from "../src/lib/personal-report-job-service-core.ts";
|
|
import type { PersonalReportRecord } from "../src/lib/personal-report-service-core.ts";
|
|
|
|
const USER_A = "11111111-1111-4111-8111-111111111111";
|
|
const USER_B = "22222222-2222-4222-8222-222222222222";
|
|
const REQUEST_A = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa";
|
|
const REQUEST_B = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb";
|
|
const REQUEST_C = "cccccccc-cccc-4ccc-8ccc-cccccccccccc";
|
|
const FINGERPRINT_A = "a".repeat(64);
|
|
const FINGERPRINT_B = "b".repeat(64);
|
|
const WRONG_TOKEN = "ffffffff-ffff-4fff-8fff-ffffffffffff";
|
|
const READY_DOCUMENT = JSON.parse(readFileSync(
|
|
new URL("../../tests/fixtures/personal_report_document.v2.json", import.meta.url),
|
|
"utf8",
|
|
)) as Record<string, unknown>;
|
|
const REPORT_ID = String(READY_DOCUMENT.reportId);
|
|
const PROVENANCE = READY_DOCUMENT.provenance as Record<string, unknown>;
|
|
|
|
type Row = Record<string, unknown>;
|
|
type Filter =
|
|
| Readonly<{ kind: "eq"; column: string; value: unknown }>
|
|
| Readonly<{ kind: "gt"; column: string; value: unknown }>
|
|
| Readonly<{ kind: "in"; column: string; values: readonly unknown[] }>;
|
|
|
|
type Mutation =
|
|
| Readonly<{ kind: "insert"; row: Readonly<Record<string, unknown>> }>
|
|
| Readonly<{ kind: "update"; values: Readonly<Record<string, unknown>> }>
|
|
| Readonly<{ kind: "delete"; exactCount: boolean }>;
|
|
|
|
function uuidFor(value: number): string {
|
|
return `00000000-0000-4000-8000-${String(value).padStart(12, "0")}`;
|
|
}
|
|
|
|
function result(data: unknown, count?: number): PersonalReportJobQueryResult {
|
|
return { data, error: null, ...(count === undefined ? {} : { count }) };
|
|
}
|
|
|
|
class MemoryQueryBuilder implements PromiseLike<PersonalReportJobQueryResult> {
|
|
private mutation: Mutation | null = null;
|
|
private readonly filters: Filter[] = [];
|
|
private rowLimit: number | null = null;
|
|
private cardinality: "many" | "single" | "maybeSingle" = "many";
|
|
|
|
constructor(private readonly backend: MemoryBackend) {}
|
|
|
|
select() {
|
|
return this;
|
|
}
|
|
|
|
insert(row: Readonly<Record<string, unknown>>) {
|
|
this.mutation = { kind: "insert", row };
|
|
return this;
|
|
}
|
|
|
|
update(values: Readonly<Record<string, unknown>>) {
|
|
this.mutation = { kind: "update", values };
|
|
return this;
|
|
}
|
|
|
|
delete(options?: Readonly<{ count?: string }>) {
|
|
this.mutation = { kind: "delete", exactCount: options?.count === "exact" };
|
|
return this;
|
|
}
|
|
|
|
eq(column: string, value: unknown) {
|
|
this.filters.push({ kind: "eq", column, value });
|
|
return this;
|
|
}
|
|
|
|
gt(column: string, value: unknown) {
|
|
this.filters.push({ kind: "gt", column, value });
|
|
return this;
|
|
}
|
|
|
|
in(column: string, values: readonly unknown[]) {
|
|
this.filters.push({ kind: "in", column, values });
|
|
return this;
|
|
}
|
|
|
|
limit(value: number) {
|
|
this.rowLimit = value;
|
|
return this;
|
|
}
|
|
|
|
single() {
|
|
this.cardinality = "single";
|
|
return this.execute();
|
|
}
|
|
|
|
maybeSingle() {
|
|
this.cardinality = "maybeSingle";
|
|
return this.execute();
|
|
}
|
|
|
|
then<TResult1 = PersonalReportJobQueryResult, TResult2 = never>(
|
|
onfulfilled?: ((value: PersonalReportJobQueryResult) => TResult1 | PromiseLike<TResult1>) | null,
|
|
onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
|
|
): PromiseLike<TResult1 | TResult2> {
|
|
return this.execute().then(onfulfilled, onrejected);
|
|
}
|
|
|
|
private matches(row: Row): boolean {
|
|
return this.filters.every((filter) => {
|
|
if (filter.kind === "eq") return row[filter.column] === filter.value;
|
|
if (filter.kind === "in") return filter.values.includes(row[filter.column]);
|
|
return String(row[filter.column]) > String(filter.value);
|
|
});
|
|
}
|
|
|
|
private cardinal(data: Row[]): PersonalReportJobQueryResult {
|
|
if (this.cardinality === "many") return result(data);
|
|
if (data.length > 1 || (this.cardinality === "single" && data.length !== 1)) {
|
|
return { data: null, error: { code: "PGRST116", message: "unexpected row count" } };
|
|
}
|
|
return result(data[0] ?? null);
|
|
}
|
|
|
|
private async execute(): Promise<PersonalReportJobQueryResult> {
|
|
if (!this.mutation) {
|
|
const rows = this.backend.rows.filter((row) => this.matches(row));
|
|
return this.cardinal(this.rowLimit === null ? rows : rows.slice(0, this.rowLimit));
|
|
}
|
|
|
|
if (this.mutation.kind === "insert") {
|
|
const incoming = this.mutation.row;
|
|
const sameRequest = this.backend.rows.some((row) =>
|
|
row.user_id === incoming.user_id && row.request_id === incoming.request_id);
|
|
const active = this.backend.rows.some((row) =>
|
|
row.user_id === incoming.user_id
|
|
&& ["queued", "running", "suspended", "retrying"].includes(String(row.status)));
|
|
if (sameRequest || active) {
|
|
return {
|
|
data: null,
|
|
error: { code: "23505", message: "personal_report_jobs unique constraint" },
|
|
};
|
|
}
|
|
const at = this.backend.now.toISOString();
|
|
const row: Row = {
|
|
id: uuidFor(++this.backend.sequence),
|
|
user_id: incoming.user_id,
|
|
request_id: incoming.request_id,
|
|
request_fingerprint: incoming.request_fingerprint,
|
|
status: incoming.status ?? "queued",
|
|
attempt_count: incoming.attempt_count ?? 0,
|
|
max_attempts: incoming.max_attempts ?? 3,
|
|
lease_token: null,
|
|
lease_owner: null,
|
|
lease_acquired_at: null,
|
|
lease_expires_at: null,
|
|
heartbeat_at: null,
|
|
next_attempt_at: null,
|
|
progress_phase: incoming.progress_phase ?? "queued",
|
|
progress_percent: incoming.progress_percent ?? 0,
|
|
last_error_code: null,
|
|
last_error_at: null,
|
|
started_at: null,
|
|
finished_at: null,
|
|
created_at: at,
|
|
updated_at: at,
|
|
};
|
|
this.backend.rows.push(row);
|
|
return this.cardinal([row]);
|
|
}
|
|
|
|
const matches = this.backend.rows.filter((row) => this.matches(row));
|
|
if (this.mutation.kind === "delete") {
|
|
this.backend.rows = this.backend.rows.filter((row) => !this.matches(row));
|
|
return result(null, this.mutation.exactCount ? matches.length : undefined);
|
|
}
|
|
|
|
for (const row of matches) {
|
|
if (["ready", "failed", "cancelled"].includes(String(row.status))) {
|
|
return {
|
|
data: null,
|
|
error: { code: "55000", message: "personal_report_job_terminal_immutable" },
|
|
};
|
|
}
|
|
Object.assign(row, this.mutation.values, { updated_at: this.backend.now.toISOString() });
|
|
}
|
|
return this.cardinal(matches);
|
|
}
|
|
}
|
|
|
|
class MemoryBackend {
|
|
rows: Row[] = [];
|
|
sequence = 0;
|
|
tokenSequence = 100;
|
|
lastCompletionArgs: Readonly<Record<string, unknown>> | null = null;
|
|
lastFailureArgs: Readonly<Record<string, unknown>> | null = null;
|
|
|
|
constructor(public now = new Date("2026-08-14T03:00:00.000Z")) {}
|
|
|
|
from(table: string) {
|
|
assert.equal(table, "personal_report_jobs");
|
|
return new MemoryQueryBuilder(this);
|
|
}
|
|
|
|
async rpc(
|
|
functionName: string,
|
|
args: Readonly<Record<string, unknown>> = {},
|
|
): Promise<PersonalReportJobQueryResult> {
|
|
if (functionName === "claim_personal_report_job") {
|
|
const requestedId = args.p_job_id;
|
|
const runnable = this.rows.find((row) =>
|
|
(requestedId === null || requestedId === undefined || row.id === requestedId)
|
|
&& ["queued", "retrying"].includes(String(row.status))
|
|
&& (row.next_attempt_at === null || Date.parse(String(row.next_attempt_at)) <= this.now.getTime())
|
|
&& Number(row.attempt_count) < Number(row.max_attempts));
|
|
if (!runnable) return result([]);
|
|
const at = this.now.toISOString();
|
|
runnable.status = "running";
|
|
runnable.attempt_count = Number(runnable.attempt_count) + 1;
|
|
runnable.lease_token = uuidFor(++this.tokenSequence);
|
|
runnable.lease_owner = String(args.p_worker_id);
|
|
runnable.lease_acquired_at = at;
|
|
runnable.heartbeat_at = at;
|
|
runnable.lease_expires_at = new Date(
|
|
this.now.getTime() + Number(args.p_lease_seconds) * 1000,
|
|
).toISOString();
|
|
runnable.next_attempt_at = null;
|
|
runnable.progress_phase = Number(runnable.attempt_count) === 1 ? "starting" : "retry_starting";
|
|
runnable.started_at ??= at;
|
|
runnable.updated_at = at;
|
|
return result([runnable]);
|
|
}
|
|
|
|
if (functionName === "heartbeat_personal_report_job") {
|
|
const row = this.rows.find((candidate) =>
|
|
candidate.id === args.p_job_id
|
|
&& candidate.status === "running"
|
|
&& candidate.lease_token === args.p_lease_token
|
|
&& Date.parse(String(candidate.lease_expires_at)) > this.now.getTime());
|
|
if (!row) return result([]);
|
|
row.heartbeat_at = this.now.toISOString();
|
|
row.lease_expires_at = new Date(
|
|
this.now.getTime() + Number(args.p_lease_seconds) * 1000,
|
|
).toISOString();
|
|
row.updated_at = this.now.toISOString();
|
|
return result([row]);
|
|
}
|
|
|
|
if (functionName === "complete_personal_report_job") {
|
|
this.lastCompletionArgs = args;
|
|
const row = this.rows.find((candidate) =>
|
|
candidate.id === args.p_job_id
|
|
&& candidate.status === "running"
|
|
&& candidate.lease_token === args.p_lease_token
|
|
&& candidate.user_id === args.p_user_id
|
|
&& candidate.request_id === args.p_request_id
|
|
&& candidate.request_fingerprint === args.p_request_fingerprint
|
|
&& Date.parse(String(candidate.lease_expires_at)) > this.now.getTime());
|
|
if (!row) {
|
|
return { data: null, error: { message: "personal_report_job_lease_lost" } };
|
|
}
|
|
const at = this.now.toISOString();
|
|
row.status = "ready";
|
|
row.lease_token = null;
|
|
row.lease_owner = null;
|
|
row.lease_acquired_at = null;
|
|
row.lease_expires_at = null;
|
|
row.heartbeat_at = at;
|
|
row.next_attempt_at = null;
|
|
row.progress_phase = "ready";
|
|
row.progress_percent = 100;
|
|
row.last_error_code = null;
|
|
row.last_error_at = null;
|
|
row.finished_at = at;
|
|
row.updated_at = at;
|
|
return result([row]);
|
|
}
|
|
|
|
if (functionName === "fail_personal_report_job") {
|
|
this.lastFailureArgs = args;
|
|
const row = this.rows.find((candidate) =>
|
|
candidate.id === args.p_job_id
|
|
&& candidate.status === "running"
|
|
&& candidate.lease_token === args.p_lease_token
|
|
&& candidate.user_id === args.p_user_id
|
|
&& candidate.request_id === args.p_request_id
|
|
&& candidate.request_fingerprint === args.p_request_fingerprint
|
|
&& Date.parse(String(candidate.lease_expires_at)) > this.now.getTime());
|
|
if (!row) {
|
|
return { data: null, error: { message: "personal_report_job_lease_lost" } };
|
|
}
|
|
const at = this.now.toISOString();
|
|
row.status = "failed";
|
|
row.lease_token = null;
|
|
row.lease_owner = null;
|
|
row.lease_acquired_at = null;
|
|
row.lease_expires_at = null;
|
|
row.heartbeat_at = at;
|
|
row.next_attempt_at = null;
|
|
row.progress_phase = "failed";
|
|
row.last_error_code = args.p_error_code;
|
|
row.last_error_at = at;
|
|
row.finished_at = at;
|
|
row.updated_at = at;
|
|
return result([row]);
|
|
}
|
|
|
|
if (functionName === "recover_expired_personal_report_jobs") {
|
|
let retryingCount = 0;
|
|
let failedCount = 0;
|
|
const limit = Number(args.p_limit);
|
|
const expired = this.rows
|
|
.filter((row) => row.status === "running"
|
|
&& Date.parse(String(row.lease_expires_at)) <= this.now.getTime())
|
|
.slice(0, limit);
|
|
for (const row of expired) {
|
|
const at = this.now.toISOString();
|
|
const retry = Number(row.attempt_count) < Number(row.max_attempts);
|
|
row.status = retry ? "retrying" : "failed";
|
|
row.lease_token = null;
|
|
row.lease_owner = null;
|
|
row.lease_acquired_at = null;
|
|
row.lease_expires_at = null;
|
|
row.heartbeat_at = null;
|
|
row.next_attempt_at = retry ? at : null;
|
|
row.progress_phase = retry ? "retry_wait" : "failed";
|
|
row.last_error_code = retry ? "lease_expired" : "lease_expired_attempts_exhausted";
|
|
row.last_error_at = at;
|
|
row.finished_at = retry ? null : at;
|
|
row.updated_at = at;
|
|
if (retry) retryingCount += 1;
|
|
else failedCount += 1;
|
|
}
|
|
return result([{ retrying_count: retryingCount, failed_count: failedCount }]);
|
|
}
|
|
|
|
return { data: null, error: { message: "unknown rpc" } };
|
|
}
|
|
}
|
|
|
|
function fixture() {
|
|
const backend = new MemoryBackend();
|
|
const service = createSupabasePersonalReportJobService(backend, {
|
|
now: () => new Date(backend.now),
|
|
});
|
|
return { backend, service };
|
|
}
|
|
|
|
function reportRecord(): PersonalReportRecord {
|
|
return {
|
|
id: REPORT_ID,
|
|
userId: USER_A,
|
|
sessionId: null,
|
|
chartProfileId: null,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
reportType: "personal_full",
|
|
status: "generating",
|
|
schemaVersion: "report_document.v2",
|
|
presentationMode: "default",
|
|
depth: "standard",
|
|
requestedThemes: ["career"],
|
|
reportDocument: null,
|
|
calculationHash: null,
|
|
evidenceHash: null,
|
|
skillName: String(PROVENANCE.skillName),
|
|
skillVersion: String(PROVENANCE.skillVersion),
|
|
skillSourceCommit: String(PROVENANCE.skillSourceCommit),
|
|
skillSnapshotSha256: String(PROVENANCE.skillSnapshotSha256),
|
|
failureCode: null,
|
|
createdAt: "2026-08-14T03:00:00.000Z",
|
|
updatedAt: "2026-08-14T03:00:00.000Z",
|
|
completedAt: null,
|
|
};
|
|
}
|
|
|
|
async function expectCode(
|
|
promise: Promise<unknown>,
|
|
code: PersonalReportJobServiceError["code"],
|
|
): Promise<void> {
|
|
await assert.rejects(
|
|
promise,
|
|
(error) => error instanceof PersonalReportJobServiceError && error.code === code,
|
|
);
|
|
}
|
|
|
|
test("enqueue replays the same request fingerprint and reports a changed fingerprint conflict", async () => {
|
|
const { backend, service } = fixture();
|
|
const input = {
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
};
|
|
|
|
const created = await service.enqueue(input);
|
|
assert.equal(created.kind, "created");
|
|
const replayed = await service.enqueue(input);
|
|
assert.equal(replayed.kind, "replayed");
|
|
assert.equal(replayed.job.id, created.job.id);
|
|
|
|
const conflict = await service.enqueue({ ...input, requestFingerprint: FINGERPRINT_B });
|
|
assert.equal(conflict.kind, "request_conflict");
|
|
assert.equal(conflict.job.id, created.job.id);
|
|
assert.equal(backend.rows.length, 1);
|
|
assert.deepEqual(
|
|
Object.keys(backend.rows[0]).filter((key) => /payload|prompt|birth|report_document|model/i.test(key)),
|
|
[],
|
|
);
|
|
});
|
|
|
|
test("enqueue preserves one active job per user while allowing another owner", async () => {
|
|
const { service } = fixture();
|
|
const first = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
const blocked = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_B,
|
|
requestFingerprint: FINGERPRINT_B,
|
|
});
|
|
const otherOwner = await service.enqueue({
|
|
userId: USER_B,
|
|
requestId: REQUEST_B,
|
|
requestFingerprint: FINGERPRINT_B,
|
|
});
|
|
|
|
assert.equal(first.kind, "created");
|
|
assert.equal(blocked.kind, "active_job_exists");
|
|
assert.equal(blocked.job.id, first.job.id);
|
|
assert.equal(otherOwner.kind, "created");
|
|
});
|
|
|
|
test("claim and heartbeat require the exact live lease token", async () => {
|
|
const { backend, service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
|
|
const claimed = await service.claimLease({
|
|
workerId: "worker-a",
|
|
leaseSeconds: 30,
|
|
jobId: enqueued.job.id,
|
|
});
|
|
assert.ok(claimed?.leaseToken);
|
|
assert.equal(claimed.status, "running");
|
|
assert.equal(claimed.attemptCount, 1);
|
|
|
|
await expectCode(service.heartbeatLease({
|
|
jobId: claimed.id,
|
|
leaseToken: WRONG_TOKEN,
|
|
leaseSeconds: 60,
|
|
}), "lease_lost");
|
|
|
|
backend.now = new Date("2026-08-14T03:00:10.000Z");
|
|
const heartbeat = await service.heartbeatLease({
|
|
jobId: claimed.id,
|
|
leaseToken: claimed.leaseToken,
|
|
leaseSeconds: 60,
|
|
});
|
|
assert.equal(heartbeat.heartbeatAt, backend.now.toISOString());
|
|
assert.equal(heartbeat.leaseExpiresAt, "2026-08-14T03:01:10.000Z");
|
|
|
|
await expectCode(service.updateProgress({
|
|
jobId: claimed.id,
|
|
leaseToken: WRONG_TOKEN,
|
|
phase: "building_evidence",
|
|
percent: 40,
|
|
}), "lease_lost");
|
|
const progressed = await service.updateProgress({
|
|
jobId: claimed.id,
|
|
leaseToken: claimed.leaseToken,
|
|
phase: "building_evidence",
|
|
percent: 40,
|
|
});
|
|
assert.equal(progressed.progressPhase, "building_evidence");
|
|
assert.equal(progressed.progressPercent, 40);
|
|
});
|
|
|
|
test("atomic completion binds the canonical v2 document to the exact live lease", async () => {
|
|
const { backend, service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const claimed = await service.claimLease({ workerId: "worker-a", jobId: enqueued.job.id });
|
|
assert.ok(claimed?.leaseToken);
|
|
|
|
const completed = await service.completeReportReady({
|
|
jobId: claimed.id,
|
|
leaseToken: claimed.leaseToken,
|
|
report: reportRecord(),
|
|
document: READY_DOCUMENT,
|
|
});
|
|
|
|
assert.equal(completed.status, "ready");
|
|
assert.equal(completed.progressPercent, 100);
|
|
assert.equal(backend.lastCompletionArgs?.p_schema_version, "report_document.v2");
|
|
assert.equal(backend.lastCompletionArgs?.p_report_id, REPORT_ID);
|
|
assert.deepEqual(backend.lastCompletionArgs?.p_report_document, READY_DOCUMENT);
|
|
assert.equal(backend.lastCompletionArgs?.p_evidence_hash, PROVENANCE.evidenceHash);
|
|
});
|
|
|
|
test("atomic failure binds the report failure to the exact live lease", async () => {
|
|
const { backend, service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const claimed = await service.claimLease({ workerId: "worker-a", jobId: enqueued.job.id });
|
|
assert.ok(claimed?.leaseToken);
|
|
|
|
const failed = await service.completeReportFailed({
|
|
jobId: claimed.id,
|
|
leaseToken: claimed.leaseToken,
|
|
report: reportRecord(),
|
|
errorCode: "report_schema_invalid",
|
|
failureCode: "report_schema_invalid",
|
|
});
|
|
|
|
assert.equal(failed.status, "failed");
|
|
assert.equal(failed.lastErrorCode, "report_schema_invalid");
|
|
assert.equal(backend.lastFailureArgs?.p_report_id, REPORT_ID);
|
|
assert.equal(backend.lastFailureArgs?.p_failure_code, "report_schema_invalid");
|
|
});
|
|
|
|
test("atomic failure rejects an expired lease without changing the job", async () => {
|
|
const { backend, service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const claimed = await service.claimLease({
|
|
workerId: "worker-a",
|
|
leaseSeconds: 5,
|
|
jobId: enqueued.job.id,
|
|
});
|
|
assert.ok(claimed?.leaseToken);
|
|
backend.now = new Date("2026-08-14T03:00:06.000Z");
|
|
|
|
await expectCode(service.completeReportFailed({
|
|
jobId: claimed.id,
|
|
leaseToken: claimed.leaseToken,
|
|
report: reportRecord(),
|
|
errorCode: "report_schema_invalid",
|
|
failureCode: "report_schema_invalid",
|
|
}), "lease_lost");
|
|
|
|
assert.equal((await service.getOwnedById(USER_A, claimed.id))?.status, "running");
|
|
});
|
|
|
|
test("atomic completion rejects an expired lease without changing the job", async () => {
|
|
const { backend, service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const claimed = await service.claimLease({
|
|
workerId: "worker-a",
|
|
leaseSeconds: 5,
|
|
jobId: enqueued.job.id,
|
|
});
|
|
assert.ok(claimed?.leaseToken);
|
|
backend.now = new Date("2026-08-14T03:00:06.000Z");
|
|
|
|
await expectCode(service.completeReportReady({
|
|
jobId: claimed.id,
|
|
leaseToken: claimed.leaseToken,
|
|
report: reportRecord(),
|
|
document: READY_DOCUMENT,
|
|
}), "lease_lost");
|
|
|
|
assert.equal((await service.getOwnedById(USER_A, claimed.id))?.status, "running");
|
|
});
|
|
|
|
test("ready is terminal and owner reads/deletes remain owner-scoped", async () => {
|
|
const { service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const claimed = await service.claimLease({ workerId: "worker-a", jobId: enqueued.job.id });
|
|
assert.ok(claimed?.leaseToken);
|
|
|
|
const ready = await service.markReady({ jobId: claimed.id, leaseToken: claimed.leaseToken });
|
|
assert.equal(ready.status, "ready");
|
|
assert.equal(ready.progressPercent, 100);
|
|
await expectCode(service.markFailed({
|
|
jobId: ready.id,
|
|
leaseToken: claimed.leaseToken,
|
|
errorCode: "late_failure",
|
|
}), "terminal_immutable");
|
|
await expectCode(service.cancel({ jobId: ready.id }), "terminal_immutable");
|
|
|
|
assert.equal(await service.getOwnedById(USER_B, ready.id), null);
|
|
assert.equal((await service.getOwnedById(USER_A, ready.id))?.status, "ready");
|
|
assert.equal(await service.deleteOwned(USER_B, ready.id), false);
|
|
assert.equal(await service.deleteOwned(USER_A, ready.id), true);
|
|
assert.equal(await service.getOwnedById(USER_A, ready.id), null);
|
|
});
|
|
|
|
test("retry is bounded and exhaustion preserves the live lease for atomic report failure", async () => {
|
|
const { service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
maxAttempts: 2,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const first = await service.claimLease({ workerId: "worker-a", jobId: enqueued.job.id });
|
|
assert.ok(first?.leaseToken);
|
|
const scheduled = await service.scheduleRetry({
|
|
jobId: first.id,
|
|
leaseToken: first.leaseToken,
|
|
errorCode: "model_unavailable",
|
|
});
|
|
assert.equal(scheduled.kind, "scheduled");
|
|
assert.equal(scheduled.job.status, "retrying");
|
|
|
|
const second = await service.claimLease({ workerId: "worker-b", jobId: first.id });
|
|
assert.ok(second?.leaseToken);
|
|
assert.equal(second.attemptCount, 2);
|
|
const exhausted = await service.scheduleRetry({
|
|
jobId: second.id,
|
|
leaseToken: second.leaseToken,
|
|
errorCode: "model_unavailable",
|
|
});
|
|
assert.equal(exhausted.kind, "exhausted");
|
|
assert.equal(exhausted.job.status, "running");
|
|
assert.equal(exhausted.job.leaseToken, second.leaseToken);
|
|
assert.equal(await service.claimLease({ workerId: "worker-c", jobId: second.id }), null);
|
|
});
|
|
|
|
test("expired lease recovery retries within budget and fails at the bound", async () => {
|
|
const { backend, service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_C,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
maxAttempts: 2,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const first = await service.claimLease({
|
|
workerId: "worker-a",
|
|
leaseSeconds: 5,
|
|
jobId: enqueued.job.id,
|
|
});
|
|
assert.ok(first);
|
|
|
|
backend.now = new Date("2026-08-14T03:00:06.000Z");
|
|
assert.deepEqual(
|
|
await service.recoverExpiredLeases(1),
|
|
{ retryingCount: 1, failedCount: 0 },
|
|
);
|
|
const retrying = await service.getOwnedById(USER_A, first.id);
|
|
assert.equal(retrying?.status, "retrying");
|
|
assert.equal(retrying?.lastErrorCode, "lease_expired");
|
|
|
|
const second = await service.claimLease({
|
|
workerId: "worker-b",
|
|
leaseSeconds: 5,
|
|
jobId: first.id,
|
|
});
|
|
assert.ok(second);
|
|
assert.equal(second.attemptCount, 2);
|
|
backend.now = new Date("2026-08-14T03:00:12.000Z");
|
|
assert.deepEqual(
|
|
await service.recoverExpiredLeases(1),
|
|
{ retryingCount: 0, failedCount: 1 },
|
|
);
|
|
const failed = await service.getOwnedById(USER_A, first.id);
|
|
assert.equal(failed?.status, "failed");
|
|
assert.equal(failed?.lastErrorCode, "lease_expired_attempts_exhausted");
|
|
});
|
|
|
|
test("suspend and cancel enforce valid state and identifier shapes", async () => {
|
|
const { service } = fixture();
|
|
const enqueued = await service.enqueue({
|
|
userId: USER_A,
|
|
requestId: REQUEST_A,
|
|
requestFingerprint: FINGERPRINT_A,
|
|
});
|
|
assert.equal(enqueued.kind, "created");
|
|
const suspended = await service.suspend({ jobId: enqueued.job.id });
|
|
assert.equal(suspended.status, "suspended");
|
|
const cancelled = await service.cancel({ jobId: suspended.id });
|
|
assert.equal(cancelled.status, "cancelled");
|
|
|
|
await expectCode(service.enqueue({
|
|
userId: "not-a-uuid",
|
|
requestId: REQUEST_B,
|
|
requestFingerprint: FINGERPRINT_B,
|
|
}), "invalid_request");
|
|
await expectCode(service.heartbeatLease({
|
|
jobId: enqueued.job.id,
|
|
leaseToken: "not-a-token",
|
|
}), "invalid_request");
|
|
});
|
|
|
|
test("service source exposes only operational job columns", () => {
|
|
const source = readFileSync(
|
|
new URL("../src/lib/personal-report-job-service-core.ts", import.meta.url),
|
|
"utf8",
|
|
);
|
|
assert.doesNotMatch(source, /console\.(?:log|info|warn|error)/);
|
|
const columns = source.match(/const JOB_COLUMNS = \[([\s\S]*?)\]\.join/)?.[1] ?? "";
|
|
assert.doesNotMatch(columns, /birth|prompt|report_document|payload|model/i);
|
|
assert.match(source, /claim_personal_report_job/);
|
|
assert.match(source, /heartbeat_personal_report_job/);
|
|
assert.match(source, /complete_personal_report_job/);
|
|
assert.match(source, /fail_personal_report_job/);
|
|
assert.match(source, /recover_expired_personal_report_jobs/);
|
|
});
|