CI (SIAX Cloud) / integration (push) Skipped
CI (SIAX Cloud) / sonar (push) Skipped
masterplan-lock / check (push) Successful in 10s
CI (SIAX Cloud) / sonar (pull_request) Skipped
Security Scan (SIAX Cloud) / security (push) Successful in 13s
masterplan-lock / check (pull_request) Successful in 7s
CI (SIAX Cloud) / security (push) Successful in 26s
Security Scan (SIAX Cloud) / security (pull_request) Successful in 17s
CI (SIAX Cloud) / security (pull_request) Successful in 19s
CI (SIAX Cloud) / quality (push) Successful in 1m9s
CI (SIAX Cloud) / quality (pull_request) Successful in 2m26s
CI (SIAX Cloud) / integration (pull_request) Successful in 2m33s
- POST /api/0pt/documents/upload: real multipart bytes into DOC0 through the durable attempt journal and the existing coordinator; verified tenant/actor only, project authorization fail-closed. - POST /api/0pt/documents/structure: DOC0 segments -> INF0 -> evidence-bound validation -> optional JSON/CSV export, with credit reserve/settle. - Credits: balance, server-owned price book, Stripe Checkout and idempotent webhook reconciliation via a Stripe re-read of session + payment intent. - /portal/dokument and /portal/krediter: SIAX-styled workspace. - @siax/access: universal, framework-neutral OpenFGA project relationship primitive reusable by DOC0/N0D/other products. - Readiness: real Redis PING probe instead of presence-only; queue is now a live dependency when configured. - Dockerfile: copy every workspace manifest so --frozen-lockfile works. - Format/build hygiene: .prettierignore, .worktrees ignored, valid manifest YAML.
238 lines
8.6 KiB
TypeScript
238 lines
8.6 KiB
TypeScript
/**
|
|
* Unit tests for the dependency probes behind GET /api/health + GET
|
|
* /api/ready (BACKLOG P0-3). Each check is exercised via dependency
|
|
* injection (fake sql/fetch/stripe clients) rather than real network I/O,
|
|
* matching the fake-over-mock-global convention used elsewhere in this repo
|
|
* (e.g. tests/p0/document-intelligence-adapter.test.ts).
|
|
*/
|
|
import { describe, it, expect, afterEach } from "vitest";
|
|
import {
|
|
checkDatabase,
|
|
checkEngine,
|
|
checkStripe,
|
|
checkQueue,
|
|
hasDegradedDependency,
|
|
isReady,
|
|
type DependencyResults,
|
|
type SqlPing,
|
|
} from "@/lib/health-checks";
|
|
|
|
function jsonResponse(body: unknown, status = 200): Response {
|
|
return {
|
|
ok: status < 400,
|
|
status,
|
|
json: async () => body,
|
|
} as unknown as Response;
|
|
}
|
|
|
|
describe("checkDatabase", () => {
|
|
const saved = process.env.DATABASE_URL;
|
|
afterEach(() => {
|
|
if (saved === undefined) delete process.env.DATABASE_URL;
|
|
else process.env.DATABASE_URL = saved;
|
|
});
|
|
|
|
it("reports not_configured when DATABASE_URL is unset, without calling the client", async () => {
|
|
delete process.env.DATABASE_URL;
|
|
let called = false;
|
|
const fakeSql: SqlPing = async () => {
|
|
called = true;
|
|
return [{ "?column?": 1 }];
|
|
};
|
|
const result = await checkDatabase(fakeSql);
|
|
expect(result.status).toBe("not_configured");
|
|
expect(called).toBe(false);
|
|
});
|
|
|
|
it("reports ok when the ping round trip succeeds", async () => {
|
|
process.env.DATABASE_URL = "postgres://user:pass@localhost:5432/opt";
|
|
const fakeSql: SqlPing = async () => [{ "?column?": 1 }];
|
|
const result = await checkDatabase(fakeSql);
|
|
expect(result.status).toBe("ok");
|
|
expect(typeof result.latencyMs).toBe("number");
|
|
});
|
|
|
|
it("reports error with the driver message when the ping fails", async () => {
|
|
process.env.DATABASE_URL = "postgres://user:pass@localhost:5432/opt";
|
|
const fakeSql: SqlPing = async () => {
|
|
throw new Error("ECONNREFUSED 127.0.0.1:5432");
|
|
};
|
|
const result = await checkDatabase(fakeSql);
|
|
expect(result.status).toBe("error");
|
|
expect(result.detail).toContain("ECONNREFUSED");
|
|
});
|
|
|
|
it("reports error on timeout rather than hanging", async () => {
|
|
process.env.DATABASE_URL = "postgres://user:pass@localhost:5432/opt";
|
|
const fakeSql: SqlPing = () => new Promise(() => {}); // never resolves
|
|
const result = await checkDatabase(fakeSql, 20);
|
|
expect(result.status).toBe("error");
|
|
expect(result.detail).toContain("timed out");
|
|
});
|
|
|
|
it("reports not_configured when DATABASE_URL is set but no client is available", async () => {
|
|
process.env.DATABASE_URL = "postgres://user:pass@localhost:5432/opt";
|
|
const result = await checkDatabase(null);
|
|
expect(result.status).toBe("not_configured");
|
|
});
|
|
});
|
|
|
|
describe("checkEngine", () => {
|
|
const saved = process.env.ENGINE_URL;
|
|
afterEach(() => {
|
|
if (saved === undefined) delete process.env.ENGINE_URL;
|
|
else process.env.ENGINE_URL = saved;
|
|
});
|
|
|
|
it("reports not_configured when ENGINE_URL is unset", async () => {
|
|
delete process.env.ENGINE_URL;
|
|
const result = await checkEngine(async () => jsonResponse({ ok: true }));
|
|
expect(result.status).toBe("not_configured");
|
|
});
|
|
|
|
it("reports ok when the engine's /health responds 2xx", async () => {
|
|
process.env.ENGINE_URL = "http://engine.local:8000";
|
|
const fetchMock = (async (url: string) => {
|
|
expect(url).toBe("http://engine.local:8000/health");
|
|
return jsonResponse({ ok: true });
|
|
}) as unknown as typeof fetch;
|
|
const result = await checkEngine(fetchMock);
|
|
expect(result.status).toBe("ok");
|
|
});
|
|
|
|
it("reports error when the engine responds non-2xx", async () => {
|
|
process.env.ENGINE_URL = "http://engine.local:8000";
|
|
const result = await checkEngine(async () => jsonResponse({}, 500));
|
|
expect(result.status).toBe("error");
|
|
expect(result.detail).toContain("500");
|
|
});
|
|
|
|
it("reports error when the fetch throws (host unreachable)", async () => {
|
|
process.env.ENGINE_URL = "http://engine.local:8000";
|
|
const result = await checkEngine(async () => {
|
|
throw new Error("fetch failed");
|
|
});
|
|
expect(result.status).toBe("error");
|
|
});
|
|
|
|
it("REGRESSION: reports error (with the abort message in detail) when the probe times out via AbortController -- the exact 2026-09-30 prod symptom", async () => {
|
|
// Mätt i prod 2026-09-30: ENGINE_URL satt i Coolify-env mot en
|
|
// oprovisionerad host -> AbortController:n nbröt efter 2 s och
|
|
// /api/health rapporterade {"engine":"error",
|
|
// "detail":{"engine":"This operation was aborted"}}. Kollen ska
|
|
// vara ÄRLIG här: URL:en ÄR satt, så detta är error -- inte
|
|
// not_configured och aldrig ok.
|
|
process.env.ENGINE_URL = "http://0pt-engine:8000";
|
|
const result = await checkEngine(async () => {
|
|
throw new DOMException("This operation was aborted", "AbortError");
|
|
});
|
|
expect(result.status).toBe("error");
|
|
expect(result.detail).toContain("aborted");
|
|
});
|
|
});
|
|
|
|
describe("checkStripe", () => {
|
|
it("reports not_configured when no client is available (no STRIPE_SECRET_KEY)", async () => {
|
|
const result = await checkStripe(null);
|
|
expect(result.status).toBe("not_configured");
|
|
});
|
|
|
|
it("reports ok when balance.retrieve() succeeds", async () => {
|
|
const result = await checkStripe({ balance: { retrieve: async () => ({ available: [] }) } });
|
|
expect(result.status).toBe("ok");
|
|
});
|
|
|
|
it("reports error when balance.retrieve() rejects (e.g. revoked key)", async () => {
|
|
const result = await checkStripe({
|
|
balance: {
|
|
retrieve: async () => {
|
|
throw new Error("Invalid API Key provided");
|
|
},
|
|
},
|
|
});
|
|
expect(result.status).toBe("error");
|
|
expect(result.detail).toContain("Invalid API Key");
|
|
});
|
|
});
|
|
|
|
describe("checkQueue", () => {
|
|
const saved = process.env.REDIS_URL;
|
|
afterEach(() => {
|
|
if (saved === undefined) delete process.env.REDIS_URL;
|
|
else process.env.REDIS_URL = saved;
|
|
});
|
|
|
|
it("reports not_configured when REDIS_URL is unset", async () => {
|
|
delete process.env.REDIS_URL;
|
|
expect((await checkQueue()).status).toBe("not_configured");
|
|
});
|
|
|
|
it("reports ok only when the real probe completes", async () => {
|
|
process.env.REDIS_URL = "redis://localhost:6379";
|
|
const result = await checkQueue(async () => undefined);
|
|
expect(result.status).toBe("ok");
|
|
});
|
|
|
|
it("reports error when a configured queue cannot be reached", async () => {
|
|
process.env.REDIS_URL = "redis://localhost:6379";
|
|
const result = await checkQueue(async () => {
|
|
throw new Error("connection refused");
|
|
});
|
|
expect(result.status).toBe("error");
|
|
expect(result.detail).toContain("connection refused");
|
|
});
|
|
});
|
|
|
|
describe("hasDegradedDependency / isReady", () => {
|
|
function deps(overrides: Partial<DependencyResults> = {}): DependencyResults {
|
|
return {
|
|
db: { status: "not_configured" },
|
|
engine: { status: "not_configured" },
|
|
stripe: { status: "not_configured" },
|
|
queue: { status: "not_configured" },
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
it("hasDegradedDependency is false when nothing is configured", () => {
|
|
expect(hasDegradedDependency(deps())).toBe(false);
|
|
});
|
|
|
|
it("hasDegradedDependency is true when any dependency errored", () => {
|
|
expect(hasDegradedDependency(deps({ engine: { status: "error", detail: "boom" } }))).toBe(true);
|
|
});
|
|
|
|
it("isReady is false when db is not ok, even if nothing else is broken", () => {
|
|
expect(isReady(deps())).toBe(false);
|
|
expect(isReady(deps({ db: { status: "error" } }))).toBe(false);
|
|
});
|
|
|
|
it("isReady is true once db is ok and no configured integration is failing", () => {
|
|
expect(isReady(deps({ db: { status: "ok" } }))).toBe(true);
|
|
});
|
|
|
|
it("isReady stays true for integrations that are merely absent (0pt boots without them)", () => {
|
|
expect(
|
|
isReady(
|
|
deps({
|
|
db: { status: "ok" },
|
|
engine: { status: "not_configured" },
|
|
stripe: { status: "not_configured" },
|
|
queue: { status: "not_configured" },
|
|
}),
|
|
),
|
|
).toBe(true);
|
|
});
|
|
|
|
it("REGRESSION: isReady is false when a CONFIGURED integration is failing its live round trip", () => {
|
|
// Mätt i prod 2026-09-25: ENGINE_URL pekade på 0pt-engine:8000, en värd
|
|
// utan DNS-post någonstans i flottan, och /api/ready svarade ändå
|
|
// {"ready":true,...,"engine":"error"}. En konfigurerad-men-död motor är
|
|
// inte "valfri" -- någon har bett om den och den svarar inte.
|
|
expect(isReady(deps({ db: { status: "ok" }, engine: { status: "error", detail: "fetch failed" } }))).toBe(
|
|
false,
|
|
);
|
|
expect(isReady(deps({ db: { status: "ok" }, stripe: { status: "error", detail: "bad key" } }))).toBe(false);
|
|
});
|
|
});
|