import { SafeError, ToolInputError } from "@snapotter/shared"; import { beforeEach, describe, expect, it } from "vitest"; import { classifyError, errorSignature, resetThrottleForTests, safeFormatTag, shouldReport, vetSettings, } from "../../../apps/api/src/lib/error-report.js"; describe("safeFormatTag", () => { it("returns the lowercase extension as a safe, non-PII tag", () => { expect(safeFormatTag("photo.JPEG")).toBe("jpeg"); expect(safeFormatTag("doc.pdf")).toBe("pdf"); expect(safeFormatTag("clip.final.mp4")).toBe("mp4"); }); it("returns undefined when there is no plausible extension", () => { expect(safeFormatTag(undefined)).toBeUndefined(); expect(safeFormatTag("noext")).toBeUndefined(); expect(safeFormatTag("weird.name-with-dashes")).toBeUndefined(); }); }); describe("classifyError", () => { it("expected: tool input, aborts, worker cancel/timeout strings, zod, upload validation", () => { expect(classifyError(new ToolInputError("bad csv"))).toBe("expected"); expect(classifyError(Object.assign(new Error("aborted"), { code: "ECONNRESET" }))).toBe( "expected", ); expect(classifyError(new Error("Canceled"))).toBe("expected"); expect(classifyError(new Error("Timed out after 120s"))).toBe("expected"); expect( classifyError(Object.assign(new Error("zodish"), { name: "ZodError", issues: [] })), ).toBe("expected"); expect( classifyError(Object.assign(new Error("bad png"), { name: "InputValidationError" })), ).toBe("expected"); }); it("operational: connectivity, disk, perms, operational SafeError, marker-copied SafeError without kind", () => { const pg = Object.assign(new Error("Failed query: q"), { cause: Object.assign(new Error("57P01"), { code: "57P01" }), }); expect(classifyError(pg)).toBe("operational"); expect(classifyError(Object.assign(new Error("full"), { code: "ENOSPC" }))).toBe("operational"); expect(classifyError(new SafeError("AI dispatcher exited", { kind: "operational" }))).toBe( "operational", ); expect(classifyError(Object.assign(new Error("copied"), { isSafeMessage: true }))).toBe( "operational", ); }); it("operational: environmental database errors (auth, permission, resources), not query bugs", () => { // The deployment's DB is misconfigured or starved -- the operator's // environment, not our code. These flooded the bug view as pg auth / // permission failures from background sweeps (NODE-1G/1F/1D). expect( classifyError(Object.assign(new Error("password authentication failed"), { code: "28P01" })), ).toBe("operational"); // drizzle wraps the pg error, so the SQLSTATE is on the cause, not the top level. expect( classifyError( Object.assign(new Error("Failed query: DELETE FROM jobs"), { cause: Object.assign(new Error("permission denied for relation jobs"), { code: "42501" }), }), ), ).toBe("operational"); expect( classifyError(Object.assign(new Error("no space left on device"), { code: "53100" })), ).toBe("operational"); // A pg SYNTAX error is our query bug, not the environment -- must stay a bug. expect( classifyError(Object.assign(new Error("syntax error at or near"), { code: "42601" })), ).toBe("bug"); }); it("bug: everything else, including bug-kind SafeError and ReplyError", () => { expect(classifyError(new Error("undefined is not a function"))).toBe("bug"); expect(classifyError(new SafeError("Impossible state", { kind: "bug" }))).toBe("bug"); expect(classifyError(Object.assign(new Error("ERR bad cmd"), { name: "ReplyError" }))).toBe( "bug", ); }); it("worker source: zod is a bug (schema drift) and bare resets are operational", () => { const zod = Object.assign(new Error("z"), { name: "ZodError", issues: [] }); expect(classifyError(zod, "worker")).toBe("bug"); expect(classifyError(zod, "http")).toBe("expected"); const reset = Object.assign(new Error("read ECONNRESET"), { code: "ECONNRESET" }); expect(classifyError(reset, "worker")).toBe("operational"); expect(classifyError(reset, "http")).toBe("expected"); }); it("InputValidationError is a user 400 wherever it surfaces, not only on http", () => { // Tools throw InputValidationError from processV2 in the worker (e.g. // sprite-sheet "Provide at least two images"); it must not be logged as a bug. const e = Object.assign(new Error("Provide at least two images"), { name: "InputValidationError", }); expect(classifyError(e, "worker")).toBe("expected"); expect(classifyError(e, "cron")).toBe("expected"); expect(classifyError(e, "http")).toBe("expected"); expect(classifyError(e)).toBe("expected"); }); it("operational: a BullMQ UnrecoverableError (stalled/lock-lost job) is a strained instance, not our bug", () => { // BullMQ raises UnrecoverableError from its own worker loop when a job loses // its lock (a stall), e.g. a heavy `upscale` under CPU/memory pressure. We // never throw it ourselves, so it always means the instance could not keep // the job's lock alive -- environmental, worth one warning/hour not bug spam // (NODE-27). A ReplyError (a real Redis command failure) stays a bug. const stalled = Object.assign(new Error("Missing lock for job 42. moveToFinished"), { name: "UnrecoverableError", }); expect(classifyError(stalled, "worker")).toBe("operational"); expect(classifyError(stalled)).toBe("operational"); }); }); describe("classifyError redis", () => { it("classifies a Redis OOM ReplyError as operational", () => { const err = Object.assign(new Error("OOM command not allowed"), { name: "ReplyError" }); expect(classifyError(err, "worker")).toBe("operational"); }); it("classifies a Redis READONLY ReplyError as operational", () => { const err = Object.assign(new Error("READONLY You can't write"), { name: "ReplyError" }); expect(classifyError(err, "worker")).toBe("operational"); }); }); describe("throttle", () => { beforeEach(() => resetThrottleForTests()); it("operational: 1 per signature per hour; bug: 10", () => { expect(shouldReport("operational", "sig-a")).toBe(true); expect(shouldReport("operational", "sig-a")).toBe(false); expect(shouldReport("operational", "sig-b")).toBe(true); for (let i = 0; i < 10; i++) expect(shouldReport("bug", "sig-c")).toBe(true); expect(shouldReport("bug", "sig-c")).toBe(false); }); it("window resets after an hour", () => { expect(shouldReport("operational", "sig", 1_000)).toBe(true); expect(shouldReport("operational", "sig", 2_000)).toBe(false); expect(shouldReport("operational", "sig", 1_000 + 3_600_001)).toBe(true); }); it("same signature under different classes throttles independently", () => { expect(shouldReport("operational", "sig-x")).toBe(true); expect(shouldReport("bug", "sig-x")).toBe(true); }); }); describe("errorSignature", () => { it("combines name, code, and first in-repo frame", () => { const err = Object.assign(new Error("x"), { code: "EACCES" }); err.stack = "Error: x\n at mkdir (node:fs:1)\n at startCleanupCron (/app/apps/api/src/lib/cleanup.ts:48:3)"; expect(errorSignature(err)).toBe("Error:EACCES:cleanup.ts:48"); }); it("degrades gracefully without stack or code", () => { expect(errorSignature(new TypeError("t"))).toMatch(/^TypeError:-:/); expect(errorSignature(null)).toBe("Unknown:-:-"); }); }); describe("vetSettings", () => { it("keeps numbers, booleans, and short enum-like string values", () => { expect(vetSettings({ quality: 80, lossless: true, format: "png", fit: "cover" })).toEqual({ quality: 80, lossless: true, format: "png", fit: "cover", }); }); it("drops sensitive keys, free-text/PII-shaped values, objects and arrays", () => { // A password, a filename, and watermark text must never reach Sentry; nested // objects/arrays and long strings can carry user data, so drop them too. expect( vetSettings({ password: "hunter2", filename: "IMG_1234.png", watermarkText: "Property of Jane", crop: { x: 1, y: 2 }, sizes: [1, 2, 3], width: 1024, format: "webp", }), ).toEqual({ width: 1024, format: "webp" }); }); it("returns undefined for non-objects and when nothing safe survives", () => { expect(vetSettings(undefined)).toBeUndefined(); expect(vetSettings("nope")).toBeUndefined(); expect(vetSettings([1, 2])).toBeUndefined(); expect( vetSettings({ note: "a long free-text field well beyond the safe length" }), ).toBeUndefined(); }); });