Skip to content

Open-source status page, incident response and uptime monitoring

tests: add more tests (#2885)

Thibault Le Ouaye36446dc7d69
diff --git a/apps/dashboard/src/components/chat/tool-renderers/details.test.tsx b/apps/dashboard/src/components/chat/tool-renderers/details.test.tsx
new file mode 100644
index 000000000..3306be180
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/details.test.tsx
@@ -0,0 +1,197 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import type { ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import type { DetailsTableData } from "./details-table";
+import { getMonitorDetails } from "./get-monitor";
+import { getMonitorSummaryDetails } from "./get-monitor-summary";
+import { getResponseLogDetails } from "./get-response-log";
+
+// safe because the mappers only read the fields each fixture sets
+function asFixture<T>(value: Record<string, unknown>): T {
+ return value as T;
+}
+
+function text(node: ReactNode) {
+ return renderToStaticMarkup(<>{node}</>).replace(/<[^>]+>/g, "");
+}
+
+function labels(data: DetailsTableData) {
+ return data.sections.map((s) => s.rows.map((r) => r.label));
+}
+
+function value(data: DetailsTableData, label: string) {
+ for (const section of data.sections) {
+ const row = section.rows.find((r) => r.label === label);
+ if (row) return text(row.value);
+ }
+ return undefined;
+}
+
+describe("getMonitorDetails", () => {
+ type Input = Parameters<typeof getMonitorDetails>[0];
+ type Output = Parameters<typeof getMonitorDetails>[1];
+
+ const monitor = {
+ id: 1,
+ name: "API",
+ url: "https://api.openstatus.dev",
+ jobType: "http",
+ method: "GET",
+ active: true,
+ periodicity: "1m",
+ regions: ["ams", "iad"],
+ timeout: 45000,
+ degradedAfter: 3000,
+ retry: 3,
+ followRedirects: true,
+ public: false,
+ tags: [{ name: "prod" }, { name: "api" }],
+ notifications: [{ name: "Ops", provider: "slack" }],
+ privateLocationIds: [7, 8],
+ };
+ const input = asFixture<Input>({ id: 1 });
+
+ it("groups rows into sections", () => {
+ const data = getMonitorDetails(input, asFixture<Output>(monitor));
+ expect(data.sections.map((s) => s.title)).toEqual([
+ "Monitor",
+ "Behavior",
+ "Visibility",
+ "Private locations",
+ ]);
+ expect(value(data, "Type")).toBe("HTTP");
+ expect(value(data, "Regions")).toBe("ams, iad");
+ expect(value(data, "Degraded after")).toBe("3000ms");
+ expect(value(data, "Tags")).toBe("prod, api");
+ expect(value(data, "Notifications")).toBe("Ops (slack)");
+ expect(value(data, "IDs")).toBe("7, 8");
+ });
+
+ it("drops optional rows and sections when absent", () => {
+ const data = getMonitorDetails(
+ input,
+ asFixture<Output>({
+ ...monitor,
+ jobType: "tcp",
+ method: null,
+ degradedAfter: null,
+ privateLocationIds: [],
+ }),
+ );
+ expect(data.sections).toHaveLength(3);
+ expect(labels(data).flat()).not.toContain("Method");
+ expect(labels(data).flat()).not.toContain("Degraded after");
+ });
+});
+
+describe("getMonitorSummaryDetails", () => {
+ type Input = Parameters<typeof getMonitorSummaryDetails>[0];
+ type Output = Parameters<typeof getMonitorSummaryDetails>[1];
+
+ it("shows counts, percentiles and the window", () => {
+ const data = getMonitorSummaryDetails(
+ asFixture<Input>({ timeRange: "7d" }),
+ asFixture<Output>({
+ monitorId: 1,
+ lastPingAt: null,
+ totalSuccessful: 90,
+ totalDegraded: 5,
+ totalFailed: 5,
+ p50: 100,
+ p75: 150,
+ p90: 200,
+ p95: 250,
+ p99: 400,
+ }),
+ );
+ expect(labels(data)).toEqual([
+ ["ID", "Window", "Last check"],
+ ["Successful", "Degraded", "Failed"],
+ ["p50", "p75", "p90", "p95", "p99"],
+ ]);
+ expect(value(data, "Window")).toBe("7d");
+ expect(value(data, "Last check")).toBe("-");
+ expect(value(data, "Failed")).toBe("5");
+ expect(value(data, "p99")).toBe("400ms");
+ });
+});
+
+describe("getResponseLogDetails", () => {
+ type Input = Parameters<typeof getResponseLogDetails>[0];
+ type Output = Parameters<typeof getResponseLogDetails>[1];
+
+ const log = {
+ id: "log_1",
+ monitorId: "1",
+ region: "ams",
+ requestStatus: "success",
+ trigger: "api",
+ statusCode: 200,
+ latency: 200,
+ cronTimestamp: 0,
+ timestamp: Date.UTC(2024, 0, 1),
+ url: "https://openstatus.dev",
+ error: false,
+ message: null,
+ headers: {},
+ body: null,
+ assertions: null,
+ timing: null,
+ };
+ const input = asFixture<Input>({ id: "log_1" });
+
+ it("shows only the request section for a bare log", () => {
+ const data = getResponseLogDetails(input, asFixture<Output>(log));
+ expect(data.sections).toHaveLength(1);
+ expect(value(data, "Status code")).toBe("200");
+ expect(value(data, "Error")).toBe("false");
+ });
+
+ it("adds headers, timing, message, body and assertions when present", () => {
+ const data = getResponseLogDetails(
+ input,
+ asFixture<Output>({
+ ...log,
+ headers: { "content-type": "text/html" },
+ timing: { dns: 50, connect: 50, tls: 0, ttfb: 100, transfer: 0 },
+ message: "Timeout",
+ body: "<h1>ok</h1>",
+ assertions: "status eq 200",
+ }),
+ );
+ expect(labels(data)).toEqual([
+ expect.any(Array),
+ ["Headers"],
+ ["DNS", "CONNECT", "TLS", "TTFB", "TRANSFER"],
+ ["Message"],
+ ["Body"],
+ ["Assertions"],
+ ]);
+ expect(value(data, "Headers")).toContain("content-type");
+ expect(value(data, "DNS")).toBe("25%50 ms");
+ expect(value(data, "TTFB")).toBe("50%100 ms");
+ });
+
+ it("does not divide by zero for a zero-latency timing", () => {
+ const data = getResponseLogDetails(
+ input,
+ asFixture<Output>({
+ ...log,
+ latency: 0,
+ timing: { dns: 0, connect: 0, tls: 0, ttfb: 0, transfer: 0 },
+ }),
+ );
+ expect(value(data, "DNS")).toBe("0%0 ms");
+ });
+
+ // statusCode is nullable, but TableCellNumber renders Number(null) as 0.
+ it.ignore("does not show 0 for a missing status code", () => {
+ const data = getResponseLogDetails(
+ input,
+ asFixture<Output>({ ...log, statusCode: null }),
+ );
+ expect(value(data, "Status code")).not.toBe("0");
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/get-audit-log.test.ts b/apps/dashboard/src/components/chat/tool-renderers/get-audit-log.test.ts
new file mode 100644
index 000000000..a7ed3b83a
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/get-audit-log.test.ts
@@ -0,0 +1,65 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { getAuditLogChanges } from "./get-audit-log";
+
+type Output = Parameters<typeof getAuditLogChanges>[0];
+
+// safe because getAuditLogChanges only reads before, after and changedFields
+function asOutput(value: Record<string, unknown>): Output {
+ return value as Output;
+}
+
+describe("getAuditLogChanges", () => {
+ it("diffs only the changed fields of an update, hiding bookkeeping", () => {
+ expect(
+ getAuditLogChanges(
+ asOutput({
+ before: { name: "old", url: "a", updatedAt: 1 },
+ after: { name: "new", url: "a", updatedAt: 2 },
+ changedFields: ["name", "updatedAt"],
+ }),
+ ),
+ ).toEqual([{ field: "name", before: "old", after: "new" }]);
+ });
+
+ it("returns nothing for an update without changed fields", () => {
+ expect(
+ getAuditLogChanges(
+ asOutput({ before: { a: 1 }, after: { a: 1 }, changedFields: null }),
+ ),
+ ).toEqual([]);
+ });
+
+ it("lists the created fields", () => {
+ expect(
+ getAuditLogChanges(
+ asOutput({
+ before: null,
+ after: { name: "api", workspaceId: 1 },
+ changedFields: null,
+ }),
+ ),
+ ).toEqual([{ field: "name", after: "api" }]);
+ });
+
+ it("lists the deleted fields", () => {
+ expect(
+ getAuditLogChanges(
+ asOutput({
+ before: { name: "api", deletedAt: 1 },
+ after: null,
+ changedFields: null,
+ }),
+ ),
+ ).toEqual([{ field: "name", before: "api" }]);
+ });
+
+ it("returns nothing without snapshots", () => {
+ expect(
+ getAuditLogChanges(
+ asOutput({ before: null, after: null, changedFields: ["x"] }),
+ ),
+ ).toEqual([]);
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/incidents.test.tsx b/apps/dashboard/src/components/chat/tool-renderers/incidents.test.tsx
new file mode 100644
index 000000000..cd2ee601c
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/incidents.test.tsx
@@ -0,0 +1,187 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import type { ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import {
+ declareIncidentChanges,
+ getIncidentDetails,
+ listIncidentsTable,
+ resolveIncidentChanges,
+ updateIncidentChanges,
+} from "./incidents";
+
+// safe because the mappers only read the fields each fixture sets
+function asFixture<T>(value: Record<string, unknown>): T {
+ return value as T;
+}
+
+function text(node: ReactNode) {
+ return renderToStaticMarkup(<>{node}</>).replace(/<[^>]+>/g, "");
+}
+
+describe("declareIncidentChanges", () => {
+ type Input = Parameters<typeof declareIncidentChanges>[0];
+
+ it("lists title and severity for a minimal draft", () => {
+ expect(
+ declareIncidentChanges(
+ asFixture<Input>({ title: "Checkout down", severity: "critical" }),
+ ),
+ ).toEqual([
+ { field: "title", after: "Checkout down" },
+ { field: "severity", after: "critical" },
+ ]);
+ });
+
+ it("leads with the created id and keeps a commander id of 0", () => {
+ const rows = declareIncidentChanges(
+ asFixture<Input>({
+ title: "Checkout down",
+ severity: "major",
+ summary: "Payments failing",
+ commanderId: 0,
+ startedAt: "2024-01-01T00:00:00Z",
+ statusReportId: 4,
+ }),
+ { id: 12 },
+ );
+ expect(rows.map((r) => r.field)).toEqual([
+ "id",
+ "title",
+ "severity",
+ "summary",
+ "commanderId",
+ "startedAt",
+ "statusReportId",
+ ]);
+ expect(rows[0]).toEqual({ field: "id", after: 12 });
+ expect(rows[4]).toEqual({ field: "commanderId", after: 0 });
+ });
+});
+
+describe("updateIncidentChanges", () => {
+ type Input = Parameters<typeof updateIncidentChanges>[0];
+
+ it("lists only the provided fields, keeping explicit nulls", () => {
+ expect(
+ updateIncidentChanges(
+ asFixture<Input>({ id: 3, severity: "minor", commanderId: null }),
+ ),
+ ).toEqual([
+ { field: "incidentId", after: 3 },
+ { field: "severity", after: "minor" },
+ { field: "commanderId", after: null },
+ ]);
+ });
+});
+
+describe("resolveIncidentChanges", () => {
+ type Input = Parameters<typeof resolveIncidentChanges>[0];
+
+ it("marks the incident resolved and appends a note when given", () => {
+ expect(resolveIncidentChanges(asFixture<Input>({ id: 3 }))).toEqual([
+ { field: "incidentId", after: 3 },
+ { field: "status", after: "resolved" },
+ ]);
+ expect(
+ resolveIncidentChanges(
+ asFixture<Input>({ id: 3, note: "Rolled back" }),
+ ).at(-1),
+ ).toEqual({ field: "note", after: "Rolled back" });
+ });
+});
+
+describe("listIncidentsTable", () => {
+ type Output = Parameters<typeof listIncidentsTable>[0];
+
+ it("has an empty message and handles a missing output", () => {
+ const table = listIncidentsTable(undefined as unknown as Output);
+ expect(table.rows).toEqual([]);
+ expect(table.empty).toBe("No incidents.");
+ });
+
+ it("marks closed incidents and falls back for a missing commander", () => {
+ const table = listIncidentsTable(
+ asFixture<Output>({
+ items: [
+ {
+ id: 1,
+ title: "DNS",
+ severity: "major",
+ status: "resolved",
+ closed: true,
+ commander: null,
+ },
+ {
+ id: 2,
+ title: "API",
+ severity: "minor",
+ status: "open",
+ closed: false,
+ commander: { name: "Ada" },
+ },
+ ],
+ }),
+ );
+ expect(table.columns.map((c) => c.key)).toEqual([
+ "title",
+ "severity",
+ "status",
+ "commander",
+ "id",
+ ]);
+ const [closed, open] = table.rows;
+ expect(text(closed.cells.status)).toBe("resolved · closed");
+ expect(text(closed.cells.commander)).toBe("-");
+ expect(text(open.cells.status)).toBe("open");
+ expect(text(open.cells.commander)).toBe("Ada");
+ expect(text(open.cells.id)).toBe("2");
+ });
+});
+
+describe("getIncidentDetails", () => {
+ type Output = Parameters<typeof getIncidentDetails>[0];
+
+ const output = asFixture<Output>({
+ id: 5,
+ title: "Checkout down",
+ severity: "critical",
+ status: "open",
+ commander: null,
+ summary: null,
+ startedAt: "2024-01-01T00:00:00Z",
+ statusReport: { title: "Payments degraded" },
+ events: Array.from({ length: 12 }, (_, i) => ({
+ type: "status_changed",
+ message: `event ${i}`,
+ })),
+ });
+
+ it("builds an overview section", () => {
+ const [overview] = getIncidentDetails(output).sections;
+ expect(overview.title).toBeUndefined();
+ expect(overview.rows.map((r) => r.label)).toEqual([
+ "ID",
+ "Title",
+ "Severity",
+ "Status",
+ "Commander",
+ "Summary",
+ "Started",
+ "Status report",
+ ]);
+ const value = (label: string) =>
+ text(overview.rows.find((r) => r.label === label)?.value);
+ expect(value("Commander")).toBe("-");
+ expect(value("Status report")).toBe("Payments degraded");
+ });
+
+ it("caps the timeline at ten events and humanizes their type", () => {
+ const timeline = getIncidentDetails(output).sections[1];
+ expect(timeline.title).toBe("Timeline");
+ expect(timeline.rows).toHaveLength(10);
+ expect(timeline.rows[0].label).toBe("status changed");
+ expect(text(timeline.rows[9].value)).toBe("event 9");
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/list-tables.test.tsx b/apps/dashboard/src/components/chat/tool-renderers/list-tables.test.tsx
new file mode 100644
index 000000000..08a247974
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/list-tables.test.tsx
@@ -0,0 +1,202 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import type { ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { listMonitorsTable } from "./list-monitors";
+import { listNotificationsTable } from "./list-notifications";
+import { listPageComponentsTable } from "./list-page-components";
+import { listPrivateLocationsTable } from "./list-private-locations";
+import { listStatusPagesTable } from "./list-status-pages";
+import { listStatusReportsTable } from "./list-status-reports";
+import { searchContentTable } from "./search-content";
+import { searchDocsTable } from "./search-docs";
+
+// safe because the mappers only read the fields each fixture sets
+function asOutput<T>(value: Record<string, unknown> | undefined): T {
+ return value as T;
+}
+
+function html(node: ReactNode) {
+ return renderToStaticMarkup(<>{node}</>);
+}
+
+function text(node: ReactNode) {
+ return html(node).replace(/<[^>]+>/g, "");
+}
+
+function hrefOf(node: ReactNode) {
+ return html(node).match(/<a [^>]*href="([^"]+)"/)?.[1];
+}
+
+describe("listMonitorsTable", () => {
+ const table = listMonitorsTable(
+ asOutput({
+ items: [
+ {
+ id: 3,
+ name: "API",
+ jobType: "http",
+ periodicity: "1m",
+ regions: [],
+ active: true,
+ },
+ ],
+ }),
+ );
+
+ it("links to the monitor overview", () => {
+ expect(hrefOf(table.rows[0].cells.name)).toBe("/monitors/3/overview");
+ });
+
+ it("upper-cases the job type and shows a dash without regions", () => {
+ expect(text(table.rows[0].cells.jobType)).toBe("HTTP");
+ expect(text(table.rows[0].cells.regions)).toBe("—");
+ });
+
+ it("handles a missing output", () => {
+ const empty = listMonitorsTable(asOutput(undefined));
+ expect(empty.rows).toEqual([]);
+ expect(empty.empty).toBe("No monitors.");
+ });
+});
+
+describe("listNotificationsTable", () => {
+ const table = listNotificationsTable(
+ asOutput({
+ items: [
+ { id: 1, name: "Slack", provider: "slack", monitorIds: [4, 5] },
+ { id: 2, name: "Mail", provider: "email", monitorIds: [] },
+ ],
+ }),
+ );
+
+ it("links to the notification", () => {
+ expect(hrefOf(table.rows[0].cells.name)).toBe("/notifications/1");
+ });
+
+ it("summarises attached monitors", () => {
+ expect(text(table.rows[0].cells.monitors)).toBe("2 (4, 5)");
+ expect(text(table.rows[1].cells.monitors)).toBe("none");
+ });
+});
+
+describe("listPageComponentsTable", () => {
+ const table = listPageComponentsTable(
+ asOutput({
+ items: [
+ { id: 9, name: "API", type: "monitor", pageId: 2, monitorId: 4 },
+ { id: 10, name: "Docs", type: "static", pageId: 2, monitorId: null },
+ ],
+ }),
+ );
+
+ it("links to the page's components", () => {
+ expect(hrefOf(table.rows[0].cells.name)).toBe("/status-pages/2/components");
+ });
+
+ it("shows the monitor id, or a placeholder for static components", () => {
+ expect(text(table.rows[0].cells.monitor)).toContain("4");
+ expect(text(table.rows[1].cells.monitor).trim()).toBe("-");
+ });
+});
+
+describe("listPrivateLocationsTable", () => {
+ const table = listPrivateLocationsTable(
+ asOutput({
+ items: [
+ {
+ id: 1,
+ name: "office",
+ monitorIds: [],
+ metadata: { rack: "a1" },
+ lastSeenAt: null,
+ },
+ ],
+ }),
+ );
+
+ it("links to the private locations settings", () => {
+ expect(hrefOf(table.rows[0].cells.name)).toBe(
+ "/settings/private-locations",
+ );
+ });
+
+ it("shows 'never' for a location that never reported", () => {
+ expect(text(table.rows[0].cells.lastSeenAt)).toBe("never");
+ expect(text(table.rows[0].cells.monitors)).toBe("none");
+ });
+
+ it("renders metadata as pills", () => {
+ expect(text(table.rows[0].cells.metadata)).toContain("a1");
+ });
+});
+
+describe("listStatusPagesTable", () => {
+ it("links to the page's status reports", () => {
+ const table = listStatusPagesTable(
+ asOutput({ items: [{ id: 2, title: "Acme", slug: "acme" }] }),
+ );
+ expect(hrefOf(table.rows[0].cells.title)).toBe(
+ "/status-pages/2/status-reports",
+ );
+ expect(text(table.rows[0].cells.slug)).toBe("acme");
+ });
+});
+
+describe("listStatusReportsTable", () => {
+ const table = listStatusReportsTable(
+ asOutput({
+ items: [
+ { id: 5, title: "Outage", status: "investigating", pageId: 2 },
+ { id: 6, title: "Orphan", status: "resolved", pageId: null },
+ ],
+ }),
+ );
+
+ it("links a report to its page", () => {
+ expect(hrefOf(table.rows[0].cells.title)).toBe(
+ "/status-pages/2/status-reports/5",
+ );
+ });
+
+ it("does not link a report without a page", () => {
+ expect(hrefOf(table.rows[1].cells.title)).toBeUndefined();
+ expect(text(table.rows[1].cells.title)).toContain("Orphan");
+ });
+});
+
+describe("search tables", () => {
+ const results = [
+ {
+ path: "/docs/a",
+ url: "https://docs.openstatus.dev/a",
+ title: "A",
+ snippet: "about a",
+ type: "blog",
+ },
+ ];
+
+ it("links docs results externally in a new tab", () => {
+ const out = html(
+ searchDocsTable(asOutput({ results })).rows[0].cells.title,
+ );
+ expect(out).toContain('href="https://docs.openstatus.dev/a"');
+ expect(out).toContain('target="_blank"');
+ });
+
+ it("uses the result path as the row id", () => {
+ expect(searchContentTable(asOutput({ results })).rows[0].id).toBe(
+ "/docs/a",
+ );
+ });
+
+ it("surfaces the search error as the empty message", () => {
+ expect(searchDocsTable(asOutput({ error: "rate limited" })).empty).toBe(
+ "rate limited",
+ );
+ expect(searchContentTable(asOutput({ results: [] })).empty).toBe(
+ "No results.",
+ );
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/maintenance-changes.test.ts b/apps/dashboard/src/components/chat/tool-renderers/maintenance-changes.test.ts
new file mode 100644
index 000000000..d3f5c954f
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/maintenance-changes.test.ts
@@ -0,0 +1,108 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { createMaintenanceChanges } from "./create-maintenance";
+import {
+ addMaintenanceUpdateChanges,
+ deleteMaintenanceUpdateChanges,
+ updateMaintenanceUpdateChanges,
+} from "./maintenance-update";
+
+// safe because the mappers only read the fields each fixture sets
+function asInput<T>(value: Record<string, unknown>): T {
+ return value as T;
+}
+
+describe("createMaintenanceChanges", () => {
+ const input = asInput<Parameters<typeof createMaintenanceChanges>[0]>({
+ title: "DB upgrade",
+ message: "Short downtime",
+ from: "2024-01-01T00:00:00Z",
+ to: "2024-01-01T01:00:00Z",
+ pageId: 1,
+ pageComponentIds: [2, 3],
+ notify: true,
+ });
+
+ it("lists every field in a fixed order", () => {
+ expect(createMaintenanceChanges(input)).toEqual([
+ { field: "title", after: "DB upgrade" },
+ { field: "message", after: "Short downtime" },
+ { field: "from", after: "2024-01-01T00:00:00Z" },
+ { field: "to", after: "2024-01-01T01:00:00Z" },
+ { field: "pageId", after: 1 },
+ { field: "pageComponentIds", after: [2, 3] },
+ { field: "notify", after: true },
+ ]);
+ });
+
+ it("prefers the applied notify flag", () => {
+ const rows = createMaintenanceChanges(input, { id: 1, notified: false });
+ expect(rows.at(-1)).toEqual({ field: "notify", after: false });
+ });
+});
+
+describe("addMaintenanceUpdateChanges", () => {
+ type Input = Parameters<typeof addMaintenanceUpdateChanges>[0];
+
+ it("omits the id and date for a draft without a date", () => {
+ expect(
+ addMaintenanceUpdateChanges(
+ asInput<Input>({ maintenanceId: 4, message: "Started", notify: true }),
+ ),
+ ).toEqual([
+ { field: "maintenanceId", after: 4 },
+ { field: "message", after: "Started" },
+ { field: "notify", after: true },
+ ]);
+ });
+
+ it("leads with the applied id and uses the applied notify flag", () => {
+ expect(
+ addMaintenanceUpdateChanges(
+ asInput<Input>({
+ maintenanceId: 4,
+ message: "Started",
+ date: "2024-01-01T00:00:00Z",
+ notify: true,
+ }),
+ { id: 11, notified: false },
+ ),
+ ).toEqual([
+ { field: "id", after: 11 },
+ { field: "maintenanceId", after: 4 },
+ { field: "message", after: "Started" },
+ { field: "date", after: "2024-01-01T00:00:00Z" },
+ { field: "notify", after: false },
+ ]);
+ });
+});
+
+describe("updateMaintenanceUpdateChanges", () => {
+ type Input = Parameters<typeof updateMaintenanceUpdateChanges>[0];
+
+ it("lists only the provided fields", () => {
+ expect(updateMaintenanceUpdateChanges(asInput<Input>({ id: 3 }))).toEqual([
+ { field: "id", after: 3 },
+ ]);
+ expect(
+ updateMaintenanceUpdateChanges(
+ asInput<Input>({ id: 3, message: "Edited", date: "2024-01-01" }),
+ ),
+ ).toEqual([
+ { field: "id", after: 3 },
+ { field: "message", after: "Edited" },
+ { field: "date", after: "2024-01-01" },
+ ]);
+ });
+});
+
+describe("deleteMaintenanceUpdateChanges", () => {
+ it("shows the id as removed", () => {
+ const rows = deleteMaintenanceUpdateChanges(
+ asInput<Parameters<typeof deleteMaintenanceUpdateChanges>[0]>({ id: 8 }),
+ );
+ expect(rows).toEqual([{ field: "id", before: 8 }]);
+ expect("after" in rows[0]).toBe(false);
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/registry.test.tsx b/apps/dashboard/src/components/chat/tool-renderers/registry.test.tsx
new file mode 100644
index 000000000..40e7a274a
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/registry.test.tsx
@@ -0,0 +1,146 @@
+import { expect } from "@std/expect";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { type Stub, stub } from "@std/testing/mock";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import {
+ renderToolDraft,
+ renderToolResult,
+ summarizeToolOutput,
+ toolRenderers,
+} from "./index";
+
+let warnStub: Stub | undefined;
+beforeEach(() => {
+ warnStub = stub(console, "warn");
+});
+afterEach(() => warnStub?.restore());
+
+describe("summarizeToolOutput", () => {
+ it("pluralises item counts", () => {
+ expect(summarizeToolOutput("list_monitors", { items: [] })).toBe(
+ "0 results",
+ );
+ expect(summarizeToolOutput("list_monitors", { items: [{}] })).toBe(
+ "1 result",
+ );
+ expect(summarizeToolOutput("list_monitors", { items: [{}, {}] })).toBe(
+ "2 results",
+ );
+ });
+
+ it("flags paginated response logs", () => {
+ expect(
+ summarizeToolOutput("list_response_logs", {
+ logs: [{}],
+ hasMore: true,
+ }),
+ ).toBe("1 log (more available)");
+ });
+
+ it("prefers the search error over the count", () => {
+ expect(
+ summarizeToolOutput("search_docs", { error: "down", results: [{}] }),
+ ).toBe("down");
+ expect(summarizeToolOutput("search_docs", { results: [{}] })).toBe(
+ "1 result",
+ );
+ });
+
+ it("describes doc page reads", () => {
+ expect(
+ summarizeToolOutput("get_doc_page", {
+ url: "/docs/a",
+ truncated: true,
+ }),
+ ).toBe("read /docs/a (truncated)");
+ });
+
+ it("totals monitor summary checks", () => {
+ expect(
+ summarizeToolOutput("get_monitor_summary", {
+ totalSuccessful: 8,
+ totalDegraded: 1,
+ totalFailed: 1,
+ p95: 120,
+ }),
+ ).toBe("10 checks · p95 120ms");
+ });
+
+ it("handles a missing postmortem", () => {
+ expect(summarizeToolOutput("get_postmortem", { exists: false })).toBe(
+ "no postmortem",
+ );
+ });
+
+ it("returns undefined while the output is pending", () => {
+ expect(summarizeToolOutput("list_monitors", undefined)).toBeUndefined();
+ });
+});
+
+describe("renderToolDraft", () => {
+ it("builds inline drafts", () => {
+ expect(
+ renderToolDraft("set_incident_status", { id: 4, status: "mitigated" }),
+ ).toEqual([
+ { field: "incidentId", after: 4 },
+ { field: "status", after: "mitigated" },
+ ]);
+ });
+
+ it("includes the note only when present", () => {
+ expect(
+ renderToolDraft("set_incident_status", {
+ id: 4,
+ status: "mitigated",
+ note: "rolled back",
+ })?.at(-1),
+ ).toEqual({ field: "note", after: "rolled back" });
+ });
+
+ it("returns undefined for read-only tools", () => {
+ expect(renderToolDraft("list_monitors", {})).toBeUndefined();
+ });
+});
+
+describe("renderToolResult", () => {
+ it("returns undefined while the output is pending", () => {
+ expect(renderToolResult("list_monitors", {}, undefined)).toBeUndefined();
+ });
+
+ it("renders a result table for list tools", () => {
+ const node = renderToolResult(
+ "list_status_pages",
+ {},
+ { items: [{ id: 1, title: "Acme", slug: "acme" }] },
+ );
+ expect(renderToStaticMarkup(<>{node}</>)).toContain("Acme");
+ });
+
+ it("has no result renderer for full-page reads", () => {
+ expect(
+ renderToolResult("get_doc_page", {}, { url: "/docs/a" }),
+ ).toBeUndefined();
+ });
+});
+
+describe("unknown tools", () => {
+ it("fall back to undefined and warn once per name", () => {
+ expect(summarizeToolOutput("not_a_tool", {})).toBeUndefined();
+ expect(renderToolDraft("not_a_tool", {})).toBeUndefined();
+ expect(renderToolResult("not_a_tool", {}, {})).toBeUndefined();
+ expect(warnStub?.calls).toHaveLength(1);
+ });
+});
+
+describe("toolRenderers", () => {
+ it("gives every tool at least a summary or a renderer", () => {
+ for (const [name, renderer] of Object.entries(toolRenderers)) {
+ const r = renderer as Record<string, unknown>;
+ expect({
+ name,
+ covered: Boolean(r.summary || r.renderDraft || r.renderResult),
+ }).toEqual({ name, covered: true });
+ }
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/status-report-changes.test.ts b/apps/dashboard/src/components/chat/tool-renderers/status-report-changes.test.ts
new file mode 100644
index 000000000..1e7417799
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/status-report-changes.test.ts
@@ -0,0 +1,180 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { addStatusReportUpdateChanges } from "./add-status-report-update";
+import { createStatusReportChanges } from "./create-status-report";
+import { resolveStatusReportChanges } from "./resolve-status-report";
+import { updateStatusReportChanges } from "./update-status-report";
+
+type CreateInput = Parameters<typeof createStatusReportChanges>[0];
+type AddInput = Parameters<typeof addStatusReportUpdateChanges>[0];
+type UpdateInput = Parameters<typeof updateStatusReportChanges>[0];
+type ResolveInput = Parameters<typeof resolveStatusReportChanges>[0];
+
+// safe because the mappers only read the fields each fixture sets
+function asInput<T>(value: Record<string, unknown>): T {
+ return value as T;
+}
+
+const fields = (rows: { field: string }[]) => rows.map((r) => r.field);
+
+describe("createStatusReportChanges", () => {
+ const base = {
+ title: "API outage",
+ status: "investigating",
+ message: "Looking into it",
+ pageId: 7,
+ notify: true,
+ };
+
+ it("lists the required fields for a draft", () => {
+ expect(createStatusReportChanges(asInput<CreateInput>(base))).toEqual([
+ { field: "title", after: "API outage" },
+ { field: "status", after: "investigating" },
+ { field: "message", after: "Looking into it" },
+ { field: "pageId", after: 7 },
+ { field: "notify", after: true },
+ ]);
+ });
+
+ it("adds optional fields only when present", () => {
+ const rows = createStatusReportChanges(
+ asInput<CreateInput>({
+ ...base,
+ pageComponentIds: [1, 2],
+ componentImpacts: [{ pageComponentId: 1, impact: "major_outage" }],
+ date: "2024-01-01T00:00:00Z",
+ }),
+ );
+ expect(rows.slice(5)).toEqual([
+ { field: "pageComponentIds", after: [1, 2] },
+ { field: "componentImpacts", after: ["1 → major_outage"] },
+ { field: "date", after: "2024-01-01T00:00:00Z" },
+ ]);
+ });
+
+ it("skips empty component lists and a null date", () => {
+ const rows = createStatusReportChanges(
+ asInput<CreateInput>({
+ ...base,
+ pageComponentIds: [],
+ componentImpacts: [],
+ date: null,
+ }),
+ );
+ expect(fields(rows)).toEqual([
+ "title",
+ "status",
+ "message",
+ "pageId",
+ "notify",
+ ]);
+ });
+
+ it("prefers the applied notify flag and appends createdAt", () => {
+ const rows = createStatusReportChanges(asInput<CreateInput>(base), {
+ id: 1,
+ notified: false,
+ createdAt: "2024-01-02T00:00:00Z",
+ });
+ expect(rows.find((r) => r.field === "notify")?.after).toBe(false);
+ expect(rows.at(-1)).toEqual({
+ field: "createdAt",
+ after: "2024-01-02T00:00:00Z",
+ });
+ });
+
+ it("keeps the input notify flag when the result omits it", () => {
+ const rows = createStatusReportChanges(asInput<CreateInput>(base), {
+ id: 1,
+ });
+ expect(rows.find((r) => r.field === "notify")?.after).toBe(true);
+ expect(fields(rows)).not.toContain("createdAt");
+ });
+});
+
+describe("addStatusReportUpdateChanges", () => {
+ const base = {
+ statusReportId: 3,
+ status: "monitoring",
+ message: "Fix deployed",
+ notify: false,
+ };
+
+ it("lists the update fields", () => {
+ expect(addStatusReportUpdateChanges(asInput<AddInput>(base))).toEqual([
+ { field: "statusReportId", after: 3 },
+ { field: "status", after: "monitoring" },
+ { field: "message", after: "Fix deployed" },
+ { field: "notify", after: false },
+ ]);
+ });
+
+ it("formats impacts, keeps the date and uses the applied notify flag", () => {
+ const rows = addStatusReportUpdateChanges(
+ asInput<AddInput>({
+ ...base,
+ componentImpacts: [{ pageComponentId: 4, impact: "operational" }],
+ date: "2024-01-01T00:00:00Z",
+ }),
+ { statusReportUpdateId: 9, notified: true },
+ );
+ expect(rows.find((r) => r.field === "notify")?.after).toBe(true);
+ expect(rows.slice(4)).toEqual([
+ { field: "componentImpacts", after: ["4 → operational"] },
+ { field: "date", after: "2024-01-01T00:00:00Z" },
+ ]);
+ });
+});
+
+describe("updateStatusReportChanges", () => {
+ it("only lists the fields the model proposed", () => {
+ expect(
+ updateStatusReportChanges(
+ asInput<UpdateInput>({ statusReportId: 5, title: "New title" }),
+ ),
+ ).toEqual([
+ { field: "statusReportId", after: 5 },
+ { field: "title", after: "New title" },
+ ]);
+ });
+
+ it("keeps an explicitly empty component list", () => {
+ expect(
+ fields(
+ updateStatusReportChanges(
+ asInput<UpdateInput>({
+ statusReportId: 5,
+ status: "resolved",
+ pageComponentIds: [],
+ }),
+ ),
+ ),
+ ).toEqual(["statusReportId", "status", "pageComponentIds"]);
+ });
+});
+
+describe("resolveStatusReportChanges", () => {
+ const base = { statusReportId: 2, message: "All good", notify: true };
+
+ it("always sets the status to resolved", () => {
+ expect(resolveStatusReportChanges(asInput<ResolveInput>(base))).toEqual([
+ { field: "statusReportId", after: 2 },
+ { field: "status", after: "resolved" },
+ { field: "message", after: "All good" },
+ { field: "notify", after: true },
+ ]);
+ });
+
+ it("appends the date and uses the applied notify flag", () => {
+ const rows = resolveStatusReportChanges(
+ asInput<ResolveInput>({ ...base, date: "2024-01-01T00:00:00Z" }),
+ { statusReportUpdateId: 1, notified: false },
+ );
+ expect(rows.find((r) => r.field === "notify")?.after).toBe(false);
+ expect(rows.at(-1)).toEqual({
+ field: "date",
+ after: "2024-01-01T00:00:00Z",
+ });
+ });
+});
diff --git a/apps/dashboard/src/components/chat/tool-renderers/tables.test.tsx b/apps/dashboard/src/components/chat/tool-renderers/tables.test.tsx
new file mode 100644
index 000000000..d5b601a22
--- /dev/null
+++ b/apps/dashboard/src/components/chat/tool-renderers/tables.test.tsx
@@ -0,0 +1,208 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import type { ReactNode } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { DetailsTable } from "./details-table";
+import { getMonitorStatusTable } from "./get-monitor-status";
+import { listAuditLogsTable } from "./list-audit-logs";
+import { listMaintenancesTable } from "./list-maintenances";
+import { listResponseLogsTable } from "./list-response-logs";
+import { ResultTable } from "./result-table";
+
+// safe because the mappers only read the fields each fixture sets
+function asOutput<T>(value: Record<string, unknown>): T {
+ return value as T;
+}
+
+function html(node: ReactNode) {
+ return renderToStaticMarkup(<>{node}</>);
+}
+
+function strip(markup: string) {
+ return markup.replace(/<[^>]+>/g, "");
+}
+
+function text(node: ReactNode) {
+ return strip(html(node));
+}
+
+describe("ResultTable", () => {
+ it("shows the empty message without rows", () => {
+ const out = html(<ResultTable columns={[]} rows={[]} empty="Nothing." />);
+ expect(out).not.toContain("<table");
+ expect(strip(out)).toBe("Nothing.");
+ });
+
+ it("renders headers and cells in column order", () => {
+ const out = html(
+ <ResultTable
+ columns={[
+ { key: "b", header: "B" },
+ { key: "a", header: "A", cellClassName: "font-mono" },
+ ]}
+ rows={[{ id: 1, cells: { a: "a1", b: "b1" } }]}
+ empty="Nothing."
+ />,
+ );
+ expect(out.match(/<th[^>]*>([^<]*)<\/th>/g)?.map(strip)).toEqual([
+ "B",
+ "A",
+ ]);
+ expect(out.match(/<td[^>]*>([^<]*)<\/td>/g)?.map(strip)).toEqual([
+ "b1",
+ "a1",
+ ]);
+ expect(out).toMatch(/<td[^>]*class="[^"]*font-mono[^"]*"[^>]*>a1/);
+ });
+});
+
+describe("DetailsTable", () => {
+ it("falls back to a default empty message", () => {
+ expect(text(<DetailsTable sections={[{ rows: [] }]} />)).toBe(
+ "No details to show.",
+ );
+ expect(text(<DetailsTable sections={[]} empty="Gone." />)).toBe("Gone.");
+ });
+
+ it("renders section titles and label/value rows", () => {
+ const out = text(
+ <DetailsTable
+ sections={[
+ { title: "Monitor", rows: [{ label: "ID", value: "42" }] },
+ { rows: [{ label: "Name", value: "API" }] },
+ ]}
+ />,
+ );
+ expect(out).toBe("MonitorID42NameAPI");
+ });
+});
+
+describe("listAuditLogsTable", () => {
+ type Output = Parameters<typeof listAuditLogsTable>[0];
+
+ it("colours actions by verb and joins the entity reference", () => {
+ const table = listAuditLogsTable(
+ asOutput<Output>({
+ items: [
+ "monitor.create",
+ "page.update",
+ "page.delete",
+ "user.login",
+ ].map((action, i) => ({
+ id: i,
+ action,
+ entityType: "monitor",
+ entityId: "7",
+ actor: "user:1",
+ createdAt: "2024-01-01T00:00:00Z",
+ })),
+ }),
+ );
+ const badges = table.rows.map((r) => html(r.cells.action));
+ expect(badges[0]).toContain("text-success");
+ expect(badges[1]).toContain("text-info");
+ expect(badges[2]).toContain("text-destructive");
+ expect(badges[3]).toContain("text-muted-foreground");
+ expect(text(table.rows[0].cells.entity)).toBe("monitor#7");
+ expect(text(table.rows[0].cells.actor)).toBe("user:1");
+ });
+});
+
+describe("listMaintenancesTable", () => {
+ type Output = Parameters<typeof listMaintenancesTable>[0];
+
+ it("splits the duration into amount and unit", () => {
+ const table = listMaintenancesTable(
+ asOutput<Output>({
+ items: [
+ {
+ id: 1,
+ title: "Upgrade",
+ from: "2024-01-01T00:00:00Z",
+ to: "2024-01-01T02:00:00Z",
+ pageId: null,
+ },
+ {
+ id: 2,
+ title: "Patch",
+ from: "2024-01-01T00:00:00Z",
+ to: "2024-01-01T00:30:00Z",
+ pageId: 9,
+ },
+ ],
+ }),
+ );
+ expect(text(table.rows[0].cells.duration)).toBe("2hours");
+ expect(text(table.rows[1].cells.duration)).toBe("30minutes");
+ expect(text(table.rows[0].cells.page)).toBe("-");
+ expect(text(table.rows[1].cells.page)).toBe("9");
+ });
+
+ it("handles a missing output", () => {
+ expect(listMaintenancesTable(undefined as unknown as Output).rows).toEqual(
+ [],
+ );
+ });
+});
+
+describe("listResponseLogsTable", () => {
+ type Output = Parameters<typeof listResponseLogsTable>[0];
+
+ const log = {
+ id: "log_1",
+ monitorId: "1",
+ region: "ams",
+ requestStatus: "error",
+ trigger: "cron",
+ statusCode: 503,
+ latency: 120,
+ cronTimestamp: 0,
+ timestamp: Date.UTC(2024, 0, 1),
+ timing: null,
+ };
+
+ it("colours the indicator and status code", () => {
+ const [row] = listResponseLogsTable(asOutput<Output>({ logs: [log] })).rows;
+ expect(row.id).toBe("log_1");
+ expect(html(row.cells.indicator)).toContain("bg-destructive");
+ expect(html(row.cells.status)).toContain("text-destructive");
+ expect(text(row.cells.status)).toBe("503");
+ expect(text(row.cells.latency)).toBe("120ms");
+ });
+
+ it("uses placeholders for missing id, status and timing", () => {
+ const [row] = listResponseLogsTable(
+ asOutput<Output>({
+ logs: [{ ...log, id: null, requestStatus: null, statusCode: null }],
+ }),
+ ).rows;
+ expect(row.id).toBe("row-0");
+ expect(text(row.cells.indicator)).toBe("-");
+ expect(text(row.cells.status)).toBe("—");
+ expect(text(row.cells.timing)).toBe("-");
+ expect(text(row.cells.id)).toBe("—");
+ });
+});
+
+describe("getMonitorStatusTable", () => {
+ type Output = Parameters<typeof getMonitorStatusTable>[0];
+
+ it("keys rows by region and colours the status", () => {
+ const table = getMonitorStatusTable(
+ asOutput<Output>({
+ regions: [
+ { region: "ams", status: "active" },
+ { region: "iad", status: "degraded" },
+ { region: "sin", status: "error" },
+ ],
+ }),
+ );
+ expect(table.rows.map((r) => r.id)).toEqual(["ams", "iad", "sin"]);
+ expect(table.rows.map((r) => html(r.cells.status))).toEqual([
+ expect.stringContaining("text-success"),
+ expect.stringContaining("text-warning"),
+ expect.stringContaining("text-destructive"),
+ ]);
+ });
+});
diff --git a/apps/dashboard/src/components/command-menu/groups/entities.test.ts b/apps/dashboard/src/components/command-menu/groups/entities.test.ts
new file mode 100644
index 000000000..213981dde
--- /dev/null
+++ b/apps/dashboard/src/components/command-menu/groups/entities.test.ts
@@ -0,0 +1,190 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ incidentsGroup,
+ maintenancesGroup,
+ monitorsGroup,
+ statusPagesGroup,
+ statusReportsGroup,
+ workspacesGroup,
+} from "./entities";
+
+// safe because each group builder only reads the fields set in the fixtures
+function rows<T>(items: Record<string, unknown>[]): T[] {
+ return items as unknown as T[];
+}
+
+type Arg<F extends (...args: never[]) => unknown> = NonNullable<
+ Parameters<F>[0]
+>[number];
+
+describe("empty input", () => {
+ it("returns null so the group is hidden", () => {
+ expect(incidentsGroup(undefined)).toBeNull();
+ expect(incidentsGroup([])).toBeNull();
+ expect(monitorsGroup(undefined)).toBeNull();
+ expect(statusPagesGroup([])).toBeNull();
+ expect(statusReportsGroup(undefined)).toBeNull();
+ expect(maintenancesGroup([], new Map())).toBeNull();
+ expect(workspacesGroup([], () => {})).toBeNull();
+ });
+});
+
+describe("incidentsGroup", () => {
+ const group = incidentsGroup(
+ rows<Arg<typeof incidentsGroup>>([
+ {
+ id: 1,
+ title: "API down",
+ status: "open",
+ severity: "critical",
+ commander: { name: "Ada" },
+ },
+ {
+ id: 2,
+ title: "Slow DB",
+ status: "mitigated",
+ severity: "minor",
+ commander: null,
+ },
+ ]),
+ );
+
+ it("caps idle items and links to the incident", () => {
+ expect(group?.idleLimit).toBe(5);
+ expect(group?.items[0]).toMatchObject({
+ value: "incident-1",
+ label: "API down",
+ description: "open · critical",
+ action: { type: "navigate", href: "/incidents/1" },
+ });
+ });
+
+ it("searches by commander only when one is assigned", () => {
+ expect(group?.items[0].keywords).toEqual([
+ "API down",
+ "open",
+ "critical",
+ "Ada",
+ ]);
+ expect(group?.items[1].keywords).toEqual(["Slow DB", "mitigated", "minor"]);
+ });
+});
+
+describe("monitorsGroup", () => {
+ it("pushes the monitor scope page", () => {
+ const group = monitorsGroup(
+ rows<Arg<typeof monitorsGroup>>([
+ { id: 3, name: "API", url: "https://api.acme.dev" },
+ ]),
+ );
+ expect(group?.items[0]).toMatchObject({
+ value: "monitor-3",
+ description: "https://api.acme.dev",
+ keywords: ["API", "https://api.acme.dev"],
+ action: { type: "push", page: { type: "monitor", id: 3, name: "API" } },
+ });
+ });
+});
+
+describe("statusPagesGroup", () => {
+ it("pushes the status page scope and indexes the custom domain", () => {
+ const group = statusPagesGroup(
+ rows<Arg<typeof statusPagesGroup>>([
+ { id: 4, title: "Acme", slug: "acme", customDomain: "status.acme.dev" },
+ { id: 5, title: "Beta", slug: "beta", customDomain: "" },
+ ]),
+ );
+ expect(group?.items[0]).toMatchObject({
+ value: "status-page-4",
+ description: "acme",
+ keywords: ["Acme", "acme", "status.acme.dev"],
+ action: {
+ type: "push",
+ page: { type: "status-page", id: 4, title: "Acme" },
+ },
+ });
+ expect(group?.items[1].keywords).toEqual(["Beta", "beta"]);
+ });
+});
+
+describe("statusReportsGroup", () => {
+ it("links into the report under its page", () => {
+ const group = statusReportsGroup(
+ rows<Arg<typeof statusReportsGroup>>([
+ {
+ id: 9,
+ pageId: 4,
+ title: "Outage",
+ status: "investigating",
+ page: { title: "Acme" },
+ },
+ ]),
+ );
+ expect(group?.items[0]).toMatchObject({
+ value: "status-report-9",
+ description: "investigating · Acme",
+ keywords: ["Outage", "investigating", "Acme"],
+ action: { type: "navigate", href: "/status-pages/4/status-reports/9" },
+ });
+ });
+});
+
+describe("maintenancesGroup", () => {
+ const from = new Date("2024-06-01T10:00:00Z");
+
+ it("links to the page's maintenances and indexes the page title", () => {
+ const group = maintenancesGroup(
+ rows<Arg<typeof maintenancesGroup>>([
+ { id: 11, pageId: 4, title: "DB upgrade", from },
+ ]),
+ new Map([[4, "Acme"]]),
+ );
+ expect(group?.items[0]).toMatchObject({
+ value: "maintenance-11",
+ description: from.toLocaleString(),
+ keywords: ["DB upgrade", "Acme"],
+ action: { type: "navigate", href: "/status-pages/4/maintenances" },
+ });
+ });
+
+ it("drops the page keyword when the page is unknown", () => {
+ const group = maintenancesGroup(
+ rows<Arg<typeof maintenancesGroup>>([
+ { id: 12, pageId: 99, title: "Patch", from },
+ ]),
+ new Map(),
+ );
+ expect(group?.items[0].keywords).toEqual(["Patch"]);
+ });
+});
+
+describe("workspacesGroup", () => {
+ it("switches to the selected workspace slug", () => {
+ const switched: string[] = [];
+ const group = workspacesGroup(
+ rows<Parameters<typeof workspacesGroup>[0][number]>([
+ { id: 1, name: "Acme", slug: "acme" },
+ { id: 2, name: "", slug: "unnamed" },
+ ]),
+ (slug) => switched.push(slug),
+ );
+ const [acme, unnamed] = group?.items ?? [];
+ expect(acme.value).toBe("workspace-1");
+ expect(unnamed.label).toBe("Untitled Workspace");
+ expect(unnamed.keywords).toEqual(["Untitled Workspace", "unnamed"]);
+ if (unnamed.action.type === "run") unnamed.action.run();
+ expect(switched).toEqual(["unnamed"]);
+ });
+
+ it("does not cap idle items", () => {
+ const group = workspacesGroup(
+ rows<Parameters<typeof workspacesGroup>[0][number]>([
+ { id: 1, name: "Acme", slug: "acme" },
+ ]),
+ () => {},
+ );
+ expect(group?.idleLimit).toBeUndefined();
+ });
+});
diff --git a/apps/dashboard/src/components/command-menu/groups/scope.test.ts b/apps/dashboard/src/components/command-menu/groups/scope.test.ts
new file mode 100644
index 000000000..31ce56dd8
--- /dev/null
+++ b/apps/dashboard/src/components/command-menu/groups/scope.test.ts
@@ -0,0 +1,115 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { MONITOR_TABS } from "@/app/(dashboard)/monitors/[id]/constants";
+import { STATUS_PAGE_TABS } from "@/app/(dashboard)/status-pages/[id]/constants";
+
+import { monitorScopeGroups } from "./monitor-scope";
+import { statusPageScopeGroups } from "./status-page-scope";
+
+type ScopeInput = Parameters<typeof statusPageScopeGroups>[0];
+
+// safe because statusPageScopeGroups only reads the fields set in the fixtures
+function rows<K extends "statusReports" | "maintenances">(
+ items: Record<string, unknown>[],
+): ScopeInput[K] {
+ return items as unknown as ScopeInput[K];
+}
+
+describe("monitorScopeGroups", () => {
+ it("lists every monitor tab under the monitor name", () => {
+ const [group] = monitorScopeGroups({ type: "monitor", id: 3, name: "API" });
+ expect(group.heading).toBe("API");
+ expect(group.items.map((i) => i.action)).toEqual(
+ MONITOR_TABS.map((t) => ({
+ type: "navigate",
+ href: `/monitors/3/${t.value}`,
+ })),
+ );
+ });
+});
+
+describe("statusPageScopeGroups", () => {
+ const page = { type: "status-page" as const, id: 4, title: "Acme" };
+ const from = new Date("2024-06-01T10:00:00Z");
+
+ const groups = statusPageScopeGroups({
+ page,
+ statusReports: rows<"statusReports">([
+ { id: 1, pageId: 4, title: "Outage", status: "investigating" },
+ { id: 2, pageId: 4, title: "Old", status: "resolved" },
+ { id: 3, pageId: 5, title: "Elsewhere", status: "investigating" },
+ ]),
+ maintenances: rows<"maintenances">([
+ { id: 10, pageId: 4, title: "DB upgrade", from },
+ { id: 11, pageId: 5, title: "Other page", from },
+ ]),
+ });
+ const byHeading = Object.fromEntries(groups.map((g) => [g.heading, g]));
+
+ it("returns the groups in order", () => {
+ expect(groups.map((g) => g.heading)).toEqual([
+ "Actions",
+ "Status Reports",
+ "Maintenances",
+ "Pages",
+ ]);
+ });
+
+ it("scopes create actions to the page", () => {
+ const [report, maintenance] = byHeading.Actions.items;
+ expect(report.action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "status-report", pageId: 4 },
+ });
+ expect(maintenance.action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "maintenance", pageId: 4 },
+ });
+ });
+
+ it("offers an update only for this page's unresolved reports", () => {
+ const updates = byHeading.Actions.items.slice(2);
+ expect(updates.map((i) => i.label)).toEqual(["Add Update to Outage"]);
+ expect(updates[0].action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "status-report-update", reportId: 1 },
+ });
+ });
+
+ it("lists all of this page's reports, resolved included", () => {
+ expect(byHeading["Status Reports"].items.map((i) => i.action)).toEqual([
+ { type: "navigate", href: "/status-pages/4/status-reports/1" },
+ { type: "navigate", href: "/status-pages/4/status-reports/2" },
+ ]);
+ });
+
+ it("lists only this page's maintenances", () => {
+ expect(byHeading.Maintenances.items.map((i) => i.value)).toEqual([
+ "maintenance-10",
+ ]);
+ });
+
+ it("links every page tab", () => {
+ expect(byHeading.Pages.items.map((i) => i.action)).toEqual(
+ STATUS_PAGE_TABS.map((t) => ({
+ type: "navigate",
+ href: `/status-pages/4/${t.value}`,
+ })),
+ );
+ });
+
+ it("keeps the static groups when data is still loading", () => {
+ const loading = statusPageScopeGroups({
+ page,
+ statusReports: undefined,
+ maintenances: undefined,
+ });
+ expect(loading.map((g) => g.items.length)).toEqual([
+ 2,
+ 0,
+ 0,
+ STATUS_PAGE_TABS.length,
+ ]);
+ });
+});
diff --git a/apps/dashboard/src/components/command-menu/groups/static.test.ts b/apps/dashboard/src/components/command-menu/groups/static.test.ts
new file mode 100644
index 000000000..4df096607
--- /dev/null
+++ b/apps/dashboard/src/components/command-menu/groups/static.test.ts
@@ -0,0 +1,160 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { HELP_LINKS } from "@/config/help";
+import { SETTINGS_TABS } from "@/config/settings";
+
+import {
+ createGroup,
+ createMaintenanceItem,
+ createStatusReportItem,
+ helpGroup,
+ navigationGroup,
+ settingsGroup,
+ themeGroup,
+} from "./static";
+
+describe("navigationGroup", () => {
+ it("places Incidents right after Overview", () => {
+ const labels = navigationGroup().items.map((i) => i.label);
+ expect(labels.slice(0, 2)).toEqual(["Overview", "Incidents"]);
+ });
+
+ it("lists Incidents exactly once", () => {
+ const labels = navigationGroup().items.map((i) => i.label);
+ expect(labels.filter((l) => l === "Incidents")).toHaveLength(1);
+ });
+
+ it("navigates to each item's href", () => {
+ expect(navigationGroup().items.map((item) => item.action)).toEqual(
+ [
+ "/overview",
+ "/incidents",
+ "/monitors",
+ "/status-pages",
+ "/notifications",
+ "/chat",
+ "/agents/slack",
+ "/agents/cli",
+ "/agents/mcp",
+ ].map((href) => ({ type: "navigate", href })),
+ );
+ });
+
+ it("keeps values unique", () => {
+ const values = navigationGroup().items.map((i) => i.value);
+ expect(new Set(values).size).toBe(values.length);
+ });
+});
+
+describe("createStatusReportItem / createMaintenanceItem", () => {
+ it("opens the sheet without a page at the root", () => {
+ expect(createStatusReportItem().action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "status-report", pageId: undefined },
+ });
+ expect(createMaintenanceItem().action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "maintenance", pageId: undefined },
+ });
+ });
+
+ it("passes the page id through when scoped", () => {
+ expect(createStatusReportItem(7).action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "status-report", pageId: 7 },
+ });
+ expect(createMaintenanceItem(7).action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "maintenance", pageId: 7 },
+ });
+ });
+
+ it("uses a distinct value when scoped so it never collides with the root item", () => {
+ expect(createStatusReportItem().value).toBe("Create Status Report");
+ expect(createStatusReportItem(7).value).toBe("create-status-report");
+ expect(createMaintenanceItem().value).toBe("Create Maintenance");
+ expect(createMaintenanceItem(7).value).toBe("create-maintenance");
+ });
+});
+
+describe("createGroup", () => {
+ it("leads with Declare Incident", () => {
+ const [first] = createGroup().items;
+ expect(first.label).toBe("Declare Incident");
+ expect(first.action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "declare-incident" },
+ });
+ });
+
+ it("routes monitor and status page creation to their pages", () => {
+ const hrefs = createGroup().items.flatMap((i) =>
+ i.action.type === "navigate" ? [i.action.href] : [],
+ );
+ expect(hrefs).toEqual(["/monitors/create", "/status-pages/create"]);
+ });
+});
+
+describe("settingsGroup", () => {
+ it("starts with every settings tab", () => {
+ const items = settingsGroup().items;
+ expect(items.slice(0, SETTINGS_TABS.length).map((i) => i.label)).toEqual(
+ SETTINGS_TABS.map((t) => t.label),
+ );
+ });
+
+ it("deep-links to settings anchors", () => {
+ const apiKeys = settingsGroup().items.find((i) => i.label === "API Keys");
+ expect(apiKeys?.action).toEqual({
+ type: "navigate",
+ href: "/settings/general#api-keys",
+ });
+ });
+
+ it("keeps values unique", () => {
+ const values = settingsGroup().items.map((i) => i.value);
+ expect(new Set(values).size).toBe(values.length);
+ });
+});
+
+describe("helpGroup", () => {
+ it("opens the support sheet first", () => {
+ const [support] = helpGroup().items;
+ expect(support.action).toEqual({
+ type: "sheet",
+ sheet: { sheet: "support" },
+ });
+ });
+
+ it("opens help links externally", () => {
+ const links = helpGroup().items.slice(1);
+ expect(links.map((i) => i.action)).toEqual(
+ HELP_LINKS.map((l) => ({ type: "external", href: l.href })),
+ );
+ });
+});
+
+describe("themeGroup", () => {
+ function toggle(resolvedTheme: string | undefined) {
+ const calls: string[] = [];
+ const [item] = themeGroup(resolvedTheme, (t) => calls.push(t)).items;
+ if (item.action.type === "run") item.action.run();
+ return { label: item.label, calls };
+ }
+
+ it("switches dark to light", () => {
+ expect(toggle("dark")).toEqual({
+ label: "Switch to light theme",
+ calls: ["light"],
+ });
+ });
+
+ it("switches light or unknown to dark", () => {
+ expect(toggle("light").calls).toEqual(["dark"]);
+ expect(toggle(undefined)).toEqual({
+ label: "Switch to dark theme",
+ calls: ["dark"],
+ });
+ });
+});
diff --git a/apps/dashboard/src/components/command-menu/types.test.ts b/apps/dashboard/src/components/command-menu/types.test.ts
new file mode 100644
index 000000000..7f3ae5965
--- /dev/null
+++ b/apps/dashboard/src/components/command-menu/types.test.ts
@@ -0,0 +1,16 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { pageLabel } from "./types";
+
+describe("pageLabel", () => {
+ it("uses the monitor name", () => {
+ expect(pageLabel({ type: "monitor", id: 1, name: "API" })).toBe("API");
+ });
+
+ it("uses the status page title", () => {
+ expect(
+ pageLabel({ type: "status-page", id: 2, title: "Acme Status" }),
+ ).toBe("Acme Status");
+ });
+});
diff --git a/apps/dashboard/src/components/common/changes-table.test.tsx b/apps/dashboard/src/components/common/changes-table.test.tsx
new file mode 100644
index 000000000..f3aff5032
--- /dev/null
+++ b/apps/dashboard/src/components/common/changes-table.test.tsx
@@ -0,0 +1,109 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import {
+ ChangesTable,
+ buildAuditLogChangeRows,
+ formatValue,
+} from "./changes-table";
+
+describe("formatValue", () => {
+ for (const [label, value, expected] of [
+ ["null", null, "—"],
+ ["undefined", undefined, "—"],
+ ["empty string", "", "—"],
+ ["empty array", [], "—"],
+ ["string", "hello", "hello"],
+ ["zero", 0, "0"],
+ ["false", false, "false"],
+ ["date", new Date("2024-01-02T03:04:05Z"), "2024-01-02T03:04:05.000Z"],
+ ["array", [1, 2], "[1,2]"],
+ ["object", { a: 1 }, '{"a":1}'],
+ ] as const) {
+ it(`formats ${label}`, () => {
+ expect(formatValue(value)).toBe(expected);
+ });
+ }
+});
+
+describe("buildAuditLogChangeRows", () => {
+ it("uses changedFields for an update and hides bookkeeping fields", () => {
+ expect(
+ buildAuditLogChangeRows({
+ before: { name: "old", url: "a", updatedAt: 1 },
+ after: { name: "new", url: "a", updatedAt: 2 },
+ changedFields: ["name", "updatedAt"],
+ }),
+ ).toEqual([{ field: "name", before: "old", after: "new" }]);
+ });
+
+ it("returns nothing for an update without changedFields", () => {
+ expect(
+ buildAuditLogChangeRows({
+ before: { name: "a" },
+ after: { name: "b" },
+ changedFields: null,
+ }),
+ ).toEqual([]);
+ });
+
+ it("lists the created fields for a create", () => {
+ expect(
+ buildAuditLogChangeRows({
+ before: null,
+ after: { name: "x", workspaceId: 1, createdAt: 0 },
+ changedFields: null,
+ }),
+ ).toEqual([{ field: "name", after: "x" }]);
+ });
+
+ it("lists the removed fields for a delete", () => {
+ const rows = buildAuditLogChangeRows({
+ before: { name: "x", deletedAt: 0 },
+ after: undefined,
+ changedFields: undefined,
+ });
+ expect(rows).toEqual([{ field: "name", before: "x" }]);
+ expect("after" in rows[0]).toBe(false);
+ });
+
+ it("returns nothing without before or after", () => {
+ expect(
+ buildAuditLogChangeRows({ before: null, after: null, changedFields: [] }),
+ ).toEqual([]);
+ });
+});
+
+describe("ChangesTable", () => {
+ it("renders nothing for no changes", () => {
+ expect(renderToStaticMarkup(<ChangesTable changes={[]} />)).toBe("");
+ });
+
+ it("renders a removed and an added line for an update", () => {
+ const html = renderToStaticMarkup(
+ <ChangesTable
+ changes={[{ field: "name", before: "old", after: "new" }]}
+ />,
+ );
+ expect(html).toContain("name");
+ expect(html).toMatch(/data-kind="removed".*old.*data-kind="added".*new/);
+ });
+
+ it("renders only an added line for a create", () => {
+ const html = renderToStaticMarkup(
+ <ChangesTable changes={[{ field: "name", after: "new" }]} />,
+ );
+ expect(html).toContain('data-kind="added"');
+ expect(html).not.toContain('data-kind="removed"');
+ });
+
+ it("distinguishes an explicit null from an absent value", () => {
+ const html = renderToStaticMarkup(
+ <ChangesTable changes={[{ field: "description", before: null }]} />,
+ );
+ expect(html).toContain('data-kind="removed"');
+ expect(html).toContain("—");
+ expect(html).not.toContain('data-kind="added"');
+ });
+});
diff --git a/apps/dashboard/src/components/common/status-badge.test.tsx b/apps/dashboard/src/components/common/status-badge.test.tsx
new file mode 100644
index 000000000..e504b0430
--- /dev/null
+++ b/apps/dashboard/src/components/common/status-badge.test.tsx
@@ -0,0 +1,32 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { StatusBadge } from "./status-badge";
+
+describe("StatusBadge", () => {
+ it("tints the badge by variant", () => {
+ const html = renderToStaticMarkup(
+ <StatusBadge variant="destructive">Down</StatusBadge>,
+ );
+ expect(html).toContain("bg-destructive/10");
+ expect(html).toContain("Down");
+ expect(html).not.toContain('data-slot="status-dot"');
+ });
+
+ it("stays neutral and renders a coloured dot with dot", () => {
+ const html = renderToStaticMarkup(
+ <StatusBadge variant="success" dot>
+ Up
+ </StatusBadge>,
+ );
+ expect(html).not.toMatch(/bg-(?:success|warning|destructive|info)\/10/);
+ expect(html).toMatch(/data-slot="status-dot"[^>]*bg-success/);
+ });
+
+ it("uses the default tint without a variant", () => {
+ expect(renderToStaticMarkup(<StatusBadge>Idle</StatusBadge>)).toContain(
+ "bg-muted/50",
+ );
+ });
+});
diff --git a/apps/dashboard/src/components/data-table/table-cell-metadata.test.tsx b/apps/dashboard/src/components/data-table/table-cell-metadata.test.tsx
new file mode 100644
index 000000000..87eb14ab9
--- /dev/null
+++ b/apps/dashboard/src/components/data-table/table-cell-metadata.test.tsx
@@ -0,0 +1,47 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { TableCellMetadata, getMetadataEntries } from "./table-cell-metadata";
+
+describe("getMetadataEntries", () => {
+ it("returns no entries for non-objects", () => {
+ for (const value of [null, undefined, "x", 1, ["a"]]) {
+ expect(getMetadataEntries(value)).toEqual([]);
+ }
+ });
+
+ it("sorts keys and keeps only non-blank strings", () => {
+ expect(
+ getMetadataEntries({ zone: "eu", app: "api", blank: " ", count: 3 }),
+ ).toEqual([
+ ["app", "api"],
+ ["zone", "eu"],
+ ]);
+ });
+});
+
+describe("TableCellMetadata", () => {
+ it("renders a dash without entries", () => {
+ expect(renderToStaticMarkup(<TableCellMetadata value={{}} />)).toMatch(
+ />-<\/div>$/,
+ );
+ });
+
+ it("collapses entries beyond maxEntries into a +n chip", () => {
+ const html = renderToStaticMarkup(
+ <TableCellMetadata value={{ a: "1", b: "2", c: "3" }} maxEntries={1} />,
+ );
+ expect(html).toContain("+2");
+ });
+
+ it("shows every entry without maxEntries", () => {
+ const html = renderToStaticMarkup(
+ <TableCellMetadata value={{ a: "1", b: "2" }} />,
+ );
+ for (const part of ["a", "1", "b", "2"]) {
+ expect(html).toContain(`>${part}<`);
+ }
+ expect(html).not.toMatch(/>\+\d+</);
+ });
+});
diff --git a/apps/dashboard/src/components/incidents/incident-actions.test.ts b/apps/dashboard/src/components/incidents/incident-actions.test.ts
new file mode 100644
index 000000000..6c3ea1d96
--- /dev/null
+++ b/apps/dashboard/src/components/incidents/incident-actions.test.ts
@@ -0,0 +1,50 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { hasIncidentActions } from "./incident-actions";
+
+type Incident = Parameters<typeof hasIncidentActions>[0];
+
+// safe because hasIncidentActions only reads status, closedAt and deletable
+function incident(fields: {
+ status: string;
+ closedAt: Date | null;
+ deletable: boolean;
+}): Incident {
+ return fields as unknown as Incident;
+}
+
+describe("hasIncidentActions", () => {
+ it("offers closing a resolved, unclosed incident", () => {
+ expect(
+ hasIncidentActions(
+ incident({ status: "resolved", closedAt: null, deletable: false }),
+ ),
+ ).toBe(true);
+ });
+
+ it("offers deleting a deletable incident", () => {
+ expect(
+ hasIncidentActions(
+ incident({ status: "open", closedAt: null, deletable: true }),
+ ),
+ ).toBe(true);
+ });
+
+ it("offers nothing for an open or already closed incident", () => {
+ expect(
+ hasIncidentActions(
+ incident({ status: "open", closedAt: null, deletable: false }),
+ ),
+ ).toBe(false);
+ expect(
+ hasIncidentActions(
+ incident({
+ status: "resolved",
+ closedAt: new Date(),
+ deletable: false,
+ }),
+ ),
+ ).toBe(false);
+ });
+});
diff --git a/apps/dashboard/src/components/onboarding/checks-table-adapter.test.ts b/apps/dashboard/src/components/onboarding/checks-table-adapter.test.ts
new file mode 100644
index 000000000..f47183b5d
--- /dev/null
+++ b/apps/dashboard/src/components/onboarding/checks-table-adapter.test.ts
@@ -0,0 +1,103 @@
+import type { CheckResult } from "@openstatus/services/monitor";
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { checkResultToResponseLog } from "./checks-table-adapter";
+
+const timing = {
+ dnsStart: 100,
+ dnsDone: 110,
+ connectStart: 110,
+ connectDone: 130,
+ tlsHandshakeStart: 0,
+ tlsHandshakeDone: 0,
+ firstByteStart: 130,
+ firstByteDone: 180,
+ transferStart: 180,
+ transferDone: 185,
+};
+
+function success(status: number): CheckResult {
+ return {
+ state: "success",
+ type: "http",
+ region: "ams",
+ status,
+ latency: 85,
+ timestamp: 1_700_000_000_000,
+ timing,
+ headers: { "content-type": "text/html" },
+ };
+}
+
+describe("checkResultToResponseLog", () => {
+ it("maps a successful check", () => {
+ const row = checkResultToResponseLog(success(200), 42, "https://x.dev");
+ expect(row).toMatchObject({
+ id: "ams",
+ region: "ams",
+ statusCode: 200,
+ latency: 85,
+ requestStatus: "success",
+ monitorId: "42",
+ url: "https://x.dev",
+ error: false,
+ message: null,
+ body: null,
+ headers: { "content-type": "text/html" },
+ timestamp: 1_700_000_000_000,
+ cronTimestamp: 1_700_000_000_000,
+ trigger: "api",
+ });
+ });
+
+ it("derives phase durations and zeroes phases that never fired", () => {
+ const row = checkResultToResponseLog(success(200), 1, "");
+ expect(row.type === "http" && row.timing).toEqual({
+ dns: 10,
+ connect: 20,
+ tls: 0,
+ ttfb: 50,
+ transfer: 5,
+ });
+ });
+
+ for (const [status, expected] of [
+ [100, "error"],
+ [204, "success"],
+ [301, "success"],
+ [404, "error"],
+ [503, "error"],
+ ] as const) {
+ it(`treats status ${status} as ${expected}`, () => {
+ expect(
+ checkResultToResponseLog(success(status), 1, "").requestStatus,
+ ).toBe(expected);
+ });
+ }
+
+ it("maps a failed check", () => {
+ const row = checkResultToResponseLog(
+ {
+ state: "error",
+ type: "http",
+ region: "iad",
+ message: "timeout",
+ timestamp: 5,
+ },
+ 7,
+ "https://x.dev",
+ );
+ expect(row).toMatchObject({
+ id: "iad",
+ statusCode: 0,
+ latency: 0,
+ requestStatus: "error",
+ error: true,
+ message: "timeout",
+ timing: null,
+ monitorId: "7",
+ timestamp: 5,
+ });
+ });
+});
diff --git a/apps/dashboard/src/components/ui/checkbox-tree.test.tsx b/apps/dashboard/src/components/ui/checkbox-tree.test.tsx
new file mode 100644
index 000000000..642cd27c4
--- /dev/null
+++ b/apps/dashboard/src/components/ui/checkbox-tree.test.tsx
@@ -0,0 +1,77 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { CheckboxTree, toCheckboxTreeItems } from "./checkbox-tree";
+
+describe("toCheckboxTreeItems", () => {
+ it("nests grouped components and keeps ungrouped ones as leaves", () => {
+ expect(
+ toCheckboxTreeItems(
+ [
+ { id: 1, name: "Website", order: 0 },
+ { id: 2, name: "REST", order: 1, groupId: 7, groupOrder: 0 },
+ { id: 3, name: "GraphQL", order: 2, groupId: 7, groupOrder: 1 },
+ ],
+ [{ id: 7, name: "API" }],
+ ),
+ ).toEqual([
+ { id: 1, label: "Website" },
+ {
+ id: 7,
+ label: "API",
+ children: [
+ { id: 2, label: "REST" },
+ { id: 3, label: "GraphQL" },
+ ],
+ },
+ ]);
+ });
+});
+
+describe("CheckboxTree", () => {
+ const noop = () => {};
+ const items = [
+ { id: 1, label: "Website" },
+ {
+ id: 7,
+ label: "API",
+ children: [
+ { id: 2, label: "REST" },
+ { id: 3, label: "GraphQL" },
+ ],
+ },
+ ];
+
+ function states(value: number[]) {
+ const html = renderToStaticMarkup(
+ <CheckboxTree items={items} value={value} onValueChange={noop} />,
+ );
+ return [...html.matchAll(/role="checkbox" aria-checked="([^"]+)"/g)].map(
+ (m) => m[1],
+ );
+ }
+
+ it("renders a row per leaf, group and child", () => {
+ expect(states([])).toEqual(["false", "false", "false", "false"]);
+ });
+
+ it("marks a partially selected group as indeterminate", () => {
+ expect(states([2])).toEqual(["false", "mixed", "true", "false"]);
+ });
+
+ it("marks a fully selected group as checked", () => {
+ expect(states([1, 2, 3])).toEqual(["true", "true", "true", "true"]);
+ });
+
+ it("hides a group without children", () => {
+ const html = renderToStaticMarkup(
+ <CheckboxTree
+ items={[{ id: 9, label: "Empty group", children: [] }]}
+ value={[]}
+ onValueChange={noop}
+ />,
+ );
+ expect(html).not.toContain("Empty group");
+ });
+});
diff --git a/apps/dashboard/src/data/metrics.client.test.ts b/apps/dashboard/src/data/metrics.client.test.ts
new file mode 100644
index 000000000..3ba9fb785
--- /dev/null
+++ b/apps/dashboard/src/data/metrics.client.test.ts
@@ -0,0 +1,139 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ getMonitorListMetrics,
+ isPaidPeriod,
+ mapMetrics,
+ mapRegionMetrics,
+} from "./metrics.client";
+
+type Monitors = Parameters<typeof getMonitorListMetrics>[0];
+type Metrics = Parameters<typeof mapMetrics>[0];
+type Timeline = Parameters<typeof mapRegionMetrics>[0];
+
+describe("isPaidPeriod", () => {
+ it("gates only the long periods", () => {
+ expect(isPaidPeriod("30d")).toBe(true);
+ expect(isPaidPeriod("90d")).toBe(true);
+ expect(isPaidPeriod("14d")).toBe(false);
+ expect(isPaidPeriod("1d")).toBe(false);
+ });
+});
+
+describe("mapMetrics", () => {
+ it("counts degraded checks as up", () => {
+ const [row] =
+ mapMetrics({
+ data: [
+ {
+ p50Latency: 1,
+ p75Latency: 2,
+ p90Latency: 3,
+ p95Latency: 4,
+ p99Latency: 5,
+ count: 10,
+ success: 7,
+ degraded: 2,
+ error: 1,
+ lastTimestamp: 123,
+ },
+ ],
+ } as unknown as Metrics) ?? [];
+ expect(row).toEqual({
+ p50: 1,
+ p75: 2,
+ p90: 3,
+ p95: 4,
+ p99: 5,
+ total: 10,
+ uptime: 0.9,
+ degraded: 2,
+ error: 1,
+ lastTimestamp: 123,
+ });
+ });
+});
+
+describe("mapRegionMetrics", () => {
+ function row(region: string, timestamp: number, p50: number, p99: number) {
+ return {
+ region,
+ timestamp,
+ p50Latency: p50,
+ p75Latency: null,
+ p90Latency: p50,
+ p95Latency: null,
+ p99Latency: p99,
+ };
+ }
+
+ it("returns empty sorted entries without a timeline", () => {
+ expect(mapRegionMetrics(undefined, ["iad", "ams"], "p50")).toEqual([
+ { region: "ams", p50: 0, p90: 0, p99: 0, trend: [] },
+ { region: "iad", p50: 0, p90: 0, p99: 0, trend: [] },
+ ]);
+ });
+
+ it("averages percentiles and reverses the trend per region", () => {
+ const timeline = {
+ data: [
+ row("iad", 2, 100, 300),
+ row("iad", 1, 201, 400),
+ row("ams", 2, 50, 60),
+ row("fra", 2, 999, 999),
+ ],
+ } as unknown as Timeline;
+
+ const result = mapRegionMetrics(timeline, ["ams", "iad"], "p99");
+ expect(result.map((r) => r.region)).toEqual(["ams", "iad"]);
+
+ const iad = result[1];
+ expect(iad.p50).toBe(151);
+ expect(iad.p99).toBe(350);
+ expect(iad.trend).toEqual([
+ { latency: 400, timestamp: 1, iad: 400 },
+ { latency: 300, timestamp: 2, iad: 300 },
+ ]);
+ });
+
+ it("treats missing percentile values as 0", () => {
+ const timeline = {
+ data: [row("ams", 1, 10, 20)],
+ } as unknown as Timeline;
+ expect(mapRegionMetrics(timeline, ["ams"], "p75")[0].trend).toEqual([
+ { latency: 0, timestamp: 1, ams: 0 },
+ ]);
+ });
+});
+
+describe("getMonitorListMetrics", () => {
+ const monitors = [
+ { status: "active", active: true },
+ { status: "active", active: true },
+ { status: "degraded", active: true },
+ { status: "error", active: true },
+ { status: "error", active: false },
+ ] as unknown as Monitors;
+
+ it("counts active monitors per status and inactive ones separately", () => {
+ const metrics = getMonitorListMetrics(monitors, [
+ { monitorId: "1", p95Latency: 120 },
+ { monitorId: "2", p95Latency: 1500 },
+ ]);
+ expect(
+ metrics.map(({ key, value, variant }) => ({ key, value, variant })),
+ ).toEqual([
+ { key: "active", value: 2, variant: "success" },
+ { key: "degraded", value: 1, variant: "warning" },
+ { key: "error", value: 1, variant: "destructive" },
+ { key: "inactive", value: 1, variant: "default" },
+ { key: "p95", value: "1.5 sec", variant: "ghost" },
+ ]);
+ });
+
+ it("shows N/A without latency data", () => {
+ const p95 = getMonitorListMetrics().find((m) => m.key === "p95");
+ expect(p95?.value).toBe("N/A");
+ });
+});
diff --git a/apps/dashboard/src/data/overview-events.client.test.ts b/apps/dashboard/src/data/overview-events.client.test.ts
new file mode 100644
index 000000000..6137ca3fc
--- /dev/null
+++ b/apps/dashboard/src/data/overview-events.client.test.ts
@@ -0,0 +1,163 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ buildOverviewData,
+ getIncidentStatus,
+ getMaintenanceStatus,
+} from "./overview-events.client";
+
+type Input = Parameters<typeof buildOverviewData>[0];
+
+const now = new Date("2024-06-15T12:00:00Z");
+const daysAgo = (n: number) => new Date(now.getTime() - n * 86_400_000);
+
+// safe because buildOverviewData only reads the fields set below
+function input(partial: Partial<Record<keyof Input, unknown[]>>): Input {
+ return {
+ monitors: [],
+ pages: [],
+ monitorIncidents: [],
+ statusReports: [],
+ maintenances: [],
+ ...partial,
+ } as unknown as Input;
+}
+
+function metric(data: ReturnType<typeof buildOverviewData>, title: string) {
+ return data.metrics.find((m) => m.title === title);
+}
+
+describe("getIncidentStatus", () => {
+ it("prefers resolved over acknowledged", () => {
+ expect(
+ getIncidentStatus({ acknowledgedAt: daysAgo(2), resolvedAt: daysAgo(1) }),
+ ).toBe("resolved");
+ expect(
+ getIncidentStatus({ acknowledgedAt: daysAgo(2), resolvedAt: null }),
+ ).toBe("acknowledged");
+ expect(getIncidentStatus({ acknowledgedAt: null, resolvedAt: null })).toBe(
+ "ongoing",
+ );
+ });
+});
+
+describe("getMaintenanceStatus", () => {
+ const window = { from: daysAgo(1), to: daysAgo(-1) };
+
+ it("classifies relative to now", () => {
+ expect(getMaintenanceStatus(window, daysAgo(2))).toBe("scheduled");
+ expect(getMaintenanceStatus(window, now)).toBe("in-progress");
+ expect(getMaintenanceStatus(window, daysAgo(-2))).toBe("completed");
+ });
+
+ it("counts the window bounds as in progress", () => {
+ expect(getMaintenanceStatus(window, window.from)).toBe("in-progress");
+ expect(getMaintenanceStatus(window, window.to)).toBe("in-progress");
+ });
+});
+
+describe("buildOverviewData", () => {
+ it("splits monitor incidents into open and recently resolved", () => {
+ const open = { startedAt: daysAgo(1), resolvedAt: null };
+ const recent = { startedAt: daysAgo(3), resolvedAt: daysAgo(2) };
+ const old = { startedAt: daysAgo(30), resolvedAt: daysAgo(20) };
+ const data = buildOverviewData(
+ input({ monitorIncidents: [open, recent, old] }),
+ now,
+ );
+ expect(data.needsAttention.map((e) => e.type)).toEqual(["incident"]);
+ expect(data.recentlyResolved).toHaveLength(1);
+ expect(metric(data, "Open Incidents")).toMatchObject({
+ value: 1,
+ variant: "destructive",
+ href: undefined,
+ });
+ });
+
+ it("counts managed incidents instead of monitor incidents when provided", () => {
+ const data = buildOverviewData(
+ {
+ ...input({ monitorIncidents: [{ resolvedAt: null }] }),
+ managedIncidents: [
+ { status: "open" },
+ { status: "mitigated" },
+ ] as unknown as Input["managedIncidents"],
+ endedIncidents: [
+ {
+ status: "resolved",
+ resolvedAt: daysAgo(1),
+ closedAt: daysAgo(1),
+ },
+ ] as unknown as Input["endedIncidents"],
+ },
+ now,
+ );
+ expect(metric(data, "Open Incidents")).toMatchObject({
+ value: 2,
+ href: "/incidents",
+ });
+ expect(
+ data.recentlyResolved.filter((e) => e.type === "managedIncident"),
+ ).toHaveLength(1);
+ });
+
+ it("separates maintenances from triage", () => {
+ const upcoming = { from: daysAgo(-1), to: daysAgo(-2) };
+ const finished = { from: daysAgo(3), to: daysAgo(2) };
+ const data = buildOverviewData(
+ input({ maintenances: [upcoming, finished] }),
+ now,
+ );
+ expect(data.needsAttention).toEqual([]);
+ expect(data.upcomingMaintenances).toHaveLength(1);
+ expect(data.recentlyResolved).toHaveLength(1);
+ expect(metric(data, "Scheduled Maintenances")).toMatchObject({
+ value: 1,
+ variant: "info",
+ });
+ });
+
+ it("flags open status reports", () => {
+ const data = buildOverviewData(
+ input({
+ statusReports: [
+ { status: "investigating", createdAt: daysAgo(1), updates: [] },
+ {
+ status: "resolved",
+ createdAt: daysAgo(3),
+ updatedAt: daysAgo(2),
+ updates: [{ date: daysAgo(2) }],
+ },
+ ],
+ }),
+ now,
+ );
+ expect(data.needsAttention.map((e) => e.type)).toEqual(["report"]);
+ expect(data.recentlyResolved.map((e) => e.type)).toEqual(["report"]);
+ expect(metric(data, "Open Reports")).toMatchObject({
+ value: 1,
+ variant: "warning",
+ });
+ });
+
+ it("uses default variants when nothing is open", () => {
+ const data = buildOverviewData(
+ input({ monitors: [{}, {}], pages: [{}] }),
+ now,
+ );
+ expect(
+ data.metrics.map(({ title, value, variant }) => ({
+ title,
+ value,
+ variant,
+ })),
+ ).toEqual([
+ { title: "Monitors", value: 2, variant: "default" },
+ { title: "Status Pages", value: 1, variant: "default" },
+ { title: "Open Incidents", value: 0, variant: "default" },
+ { title: "Open Reports", value: 0, variant: "default" },
+ { title: "Scheduled Maintenances", value: 0, variant: "default" },
+ ]);
+ });
+});
diff --git a/apps/dashboard/src/data/page-components.client.test.ts b/apps/dashboard/src/data/page-components.client.test.ts
new file mode 100644
index 000000000..742ecc9f2
--- /dev/null
+++ b/apps/dashboard/src/data/page-components.client.test.ts
@@ -0,0 +1,91 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ getActions,
+ toComponentSections,
+ toGroupNameLookup,
+} from "./page-components.client";
+
+const groups = [
+ { id: 1, name: "API" },
+ { id: 2, name: "Empty" },
+];
+
+function component(
+ id: number,
+ order: number,
+ groupId: number | null = null,
+ groupOrder: number | null = null,
+) {
+ return { id, name: `c${id}`, order, groupId, groupOrder };
+}
+
+function shape(sections: ReturnType<typeof toComponentSections>) {
+ return sections.map((s) => ({
+ group: s.group?.name ?? null,
+ items: s.items.map((c) => c.id),
+ }));
+}
+
+describe("toComponentSections", () => {
+ it("places a group at its first member's order and sorts members by groupOrder", () => {
+ const sections = toComponentSections(
+ [
+ component(10, 0),
+ component(11, 3, 1, 2),
+ component(12, 2, 1, 1),
+ component(13, 5),
+ ],
+ groups,
+ );
+ expect(shape(sections)).toEqual([
+ { group: null, items: [10] },
+ { group: "API", items: [12, 11] },
+ { group: null, items: [13] },
+ ]);
+ });
+
+ it("merges consecutive ungrouped components into one section", () => {
+ const sections = toComponentSections(
+ [component(3, 2), component(1, 0), component(2, 1)],
+ groups,
+ );
+ expect(shape(sections)).toEqual([{ group: null, items: [1, 2, 3] }]);
+ });
+
+ it("drops empty groups and treats unknown groupIds as ungrouped", () => {
+ const sections = toComponentSections([component(1, 0, 99)], groups);
+ expect(shape(sections)).toEqual([{ group: null, items: [1] }]);
+ });
+
+ it("treats missing order as 0", () => {
+ const sections = toComponentSections(
+ [component(1, 1), { id: 2, name: "c2" }],
+ [],
+ );
+ expect(shape(sections)).toEqual([{ group: null, items: [2, 1] }]);
+ });
+});
+
+describe("toGroupNameLookup", () => {
+ it("maps grouped components to their group name only", () => {
+ const lookup = toGroupNameLookup(
+ [
+ { id: 1, groupId: 1 },
+ { id: 2, groupId: null },
+ { id: 3, groupId: 99 },
+ ],
+ groups,
+ );
+ expect([...lookup]).toEqual([[1, "API"]]);
+ });
+});
+
+describe("getActions", () => {
+ it("attaches the delete handler", () => {
+ const onDelete = () => {};
+ expect(getActions({ delete: onDelete })[0].onClick).toBe(onDelete);
+ expect(getActions({})[0].onClick).toBeUndefined();
+ });
+});
diff --git a/apps/dashboard/src/data/status-codes.test.ts b/apps/dashboard/src/data/status-codes.test.ts
new file mode 100644
index 000000000..6b0e5d101
--- /dev/null
+++ b/apps/dashboard/src/data/status-codes.test.ts
@@ -0,0 +1,24 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { getStatusCodeVariant } from "./status-codes";
+
+describe("getStatusCodeVariant", () => {
+ for (const [code, variant] of [
+ [200, "success"],
+ [204, "success"],
+ [301, "info"],
+ [404, "warning"],
+ [429, "warning"],
+ [500, "destructive"],
+ [503, "destructive"],
+ [100, "muted"],
+ [0, "muted"],
+ [null, "muted"],
+ [undefined, "muted"],
+ ] as const) {
+ it(`${code} -> ${variant}`, () => {
+ expect(getStatusCodeVariant(code)).toBe(variant);
+ });
+ }
+});
diff --git a/apps/dashboard/src/data/status-page-history.test.ts b/apps/dashboard/src/data/status-page-history.test.ts
new file mode 100644
index 000000000..9cb61f0b1
--- /dev/null
+++ b/apps/dashboard/src/data/status-page-history.test.ts
@@ -0,0 +1,104 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { FakeTime } from "@std/testing/time";
+
+import {
+ type HistoryEvent,
+ cellFromPercentage,
+ eventsForMonth,
+ getColumnVisibility,
+ monthKeyToFullLabel,
+ monthKeyToLabel,
+ parseWindow,
+} from "./status-page-history";
+
+describe("parseWindow", () => {
+ it("accepts the known windows", () => {
+ expect(parseWindow("6")).toBe(6);
+ expect(parseWindow("12")).toBe(12);
+ expect(parseWindow("24")).toBe(24);
+ });
+
+ it("falls back to the first window", () => {
+ expect(parseWindow("3")).toBe(6);
+ expect(parseWindow("abc")).toBe(6);
+ expect(parseWindow("")).toBe(6);
+ });
+});
+
+describe("cellFromPercentage", () => {
+ it("marks missing data", () => {
+ expect(cellFromPercentage(null)).toEqual({
+ percentage: null,
+ status: "no-data",
+ });
+ });
+
+ it("marks the current month as in progress", () => {
+ expect(cellFromPercentage(50, true).status).toBe("in-progress");
+ });
+
+ it("applies the thresholds", () => {
+ expect(cellFromPercentage(100).status).toBe("operational");
+ expect(cellFromPercentage(99.9).status).toBe("operational");
+ expect(cellFromPercentage(99.89).status).toBe("degraded");
+ expect(cellFromPercentage(99).status).toBe("degraded");
+ expect(cellFromPercentage(98.99).status).toBe("down");
+ });
+});
+
+describe("eventsForMonth", () => {
+ function event(from: string, to: string | null) {
+ return {
+ from: new Date(from),
+ to: to ? new Date(to) : null,
+ } as unknown as HistoryEvent;
+ }
+
+ it("keeps events overlapping the UTC month", () => {
+ const inside = event("2025-03-10T00:00:00Z", "2025-03-11T00:00:00Z");
+ const spanningStart = event("2025-02-28T23:00:00Z", "2025-03-01T01:00:00Z");
+ const spanningEnd = event("2025-03-31T23:00:00Z", "2025-04-01T01:00:00Z");
+ const before = event("2025-02-01T00:00:00Z", "2025-02-28T23:59:59Z");
+ const after = event("2025-04-01T00:00:00Z", "2025-04-02T00:00:00Z");
+ expect(
+ eventsForMonth(
+ [inside, spanningStart, spanningEnd, before, after],
+ "2025-03",
+ ),
+ ).toEqual([inside, spanningStart, spanningEnd]);
+ });
+
+ it("treats open-ended events as lasting until now", () => {
+ const time = new FakeTime(new Date("2025-05-15T00:00:00Z"));
+ try {
+ const open = event("2025-03-20T00:00:00Z", null);
+ expect(eventsForMonth([open], "2025-04")).toEqual([open]);
+ expect(eventsForMonth([open], "2025-06")).toEqual([]);
+ } finally {
+ time.restore();
+ }
+ });
+});
+
+describe("month labels", () => {
+ it("formats short and full labels", () => {
+ expect(monthKeyToLabel("2025-10")).toBe("Oct 25");
+ expect(monthKeyToFullLabel("2025-10")).toBe("October 2025");
+ });
+});
+
+describe("getColumnVisibility", () => {
+ it("shows everything when the window covers all months", () => {
+ expect(getColumnVisibility(12, 12)).toEqual({});
+ expect(getColumnVisibility(24, 12)).toEqual({});
+ });
+
+ it("hides the slots beyond the window", () => {
+ expect(getColumnVisibility(6, 9)).toEqual({
+ "7": false,
+ "8": false,
+ "9": false,
+ });
+ });
+});
diff --git a/apps/dashboard/src/data/status-reports.client.test.ts b/apps/dashboard/src/data/status-reports.client.test.ts
new file mode 100644
index 000000000..85dca282c
--- /dev/null
+++ b/apps/dashboard/src/data/status-reports.client.test.ts
@@ -0,0 +1,111 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { incidentEndedAt } from "./managed-incidents.client";
+import {
+ getActions,
+ reportResolvedAt,
+ reportStartedAt,
+} from "./status-reports.client";
+
+const d = (iso: string) => new Date(iso);
+
+function report(
+ status: string,
+ updates: string[],
+ createdAt: string | null = "2024-01-01T00:00:00Z",
+ updatedAt: string | null = "2024-01-09T00:00:00Z",
+) {
+ return {
+ status,
+ createdAt: createdAt ? d(createdAt) : null,
+ updatedAt: updatedAt ? d(updatedAt) : null,
+ updates: updates.map((date) => ({ date: d(date) })),
+ };
+}
+
+describe("reportStartedAt", () => {
+ it("uses the earliest update regardless of order", () => {
+ expect(
+ reportStartedAt(
+ report("investigating", [
+ "2024-01-05T00:00:00Z",
+ "2024-01-03T00:00:00Z",
+ ]),
+ ),
+ ).toEqual(d("2024-01-03T00:00:00Z"));
+ });
+
+ it("falls back to createdAt, then the epoch", () => {
+ expect(reportStartedAt(report("investigating", []))).toEqual(
+ d("2024-01-01T00:00:00Z"),
+ );
+ expect(reportStartedAt(report("investigating", [], null))).toEqual(
+ new Date(0),
+ );
+ });
+});
+
+describe("reportResolvedAt", () => {
+ it("is null while the report is open", () => {
+ expect(
+ reportResolvedAt(report("monitoring", ["2024-01-05T00:00:00Z"])),
+ ).toBeNull();
+ });
+
+ it("uses the latest update once resolved", () => {
+ expect(
+ reportResolvedAt(
+ report("resolved", ["2024-01-07T00:00:00Z", "2024-01-05T00:00:00Z"]),
+ ),
+ ).toEqual(d("2024-01-07T00:00:00Z"));
+ });
+
+ it("falls back to updatedAt, then createdAt, for legacy reports", () => {
+ expect(reportResolvedAt(report("resolved", []))).toEqual(
+ d("2024-01-09T00:00:00Z"),
+ );
+ expect(
+ reportResolvedAt(report("resolved", [], "2024-01-01T00:00:00Z", null)),
+ ).toEqual(d("2024-01-01T00:00:00Z"));
+ });
+});
+
+describe("getActions", () => {
+ it("wires handlers by action id", () => {
+ const onDelete = () => {};
+ const actions = getActions({ delete: onDelete });
+ expect(actions.map((a) => a.id)).toEqual(["view-report", "delete"]);
+ expect(actions[0].onClick).toBeUndefined();
+ expect(actions[1].onClick).toBe(onDelete);
+ });
+});
+
+describe("incidentEndedAt", () => {
+ const resolvedAt = d("2024-01-02T00:00:00Z");
+ const closedAt = d("2024-01-03T00:00:00Z");
+
+ it("prefers resolvedAt for resolved incidents", () => {
+ expect(
+ incidentEndedAt({ status: "resolved", resolvedAt, closedAt }),
+ ).toEqual(resolvedAt);
+ });
+
+ it("uses closedAt for canceled incidents", () => {
+ expect(
+ incidentEndedAt({ status: "canceled", resolvedAt: null, closedAt }),
+ ).toEqual(closedAt);
+ });
+
+ it("uses closedAt for a resolved incident missing resolvedAt", () => {
+ expect(
+ incidentEndedAt({ status: "resolved", resolvedAt: null, closedAt }),
+ ).toEqual(closedAt);
+ });
+
+ it("is null while ongoing", () => {
+ expect(
+ incidentEndedAt({ status: "open", resolvedAt: null, closedAt: null }),
+ ).toBeNull();
+ });
+});
diff --git a/apps/dashboard/src/lib/composition.test.ts b/apps/dashboard/src/lib/composition.test.ts
new file mode 100644
index 000000000..1f21141e1
--- /dev/null
+++ b/apps/dashboard/src/lib/composition.test.ts
@@ -0,0 +1,82 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { composeEventHandlers, composeRefs } from "./composition";
+
+describe("composeEventHandlers", () => {
+ it("runs the original handler before ours", () => {
+ const calls: string[] = [];
+ const handler = composeEventHandlers(
+ () => calls.push("original"),
+ () => calls.push("ours"),
+ );
+ handler(new Event("click"));
+ expect(calls).toEqual(["original", "ours"]);
+ });
+
+ it("skips ours when the original prevents default", () => {
+ let called = false;
+ const handler = composeEventHandlers(
+ (e: Event) => e.preventDefault(),
+ () => {
+ called = true;
+ },
+ );
+ handler(new Event("click", { cancelable: true }));
+ expect(called).toBe(false);
+ });
+
+ it("runs ours anyway when the check is disabled", () => {
+ let called = false;
+ const handler = composeEventHandlers(
+ (e: Event) => e.preventDefault(),
+ () => {
+ called = true;
+ },
+ { checkForDefaultPrevented: false },
+ );
+ handler(new Event("click", { cancelable: true }));
+ expect(called).toBe(true);
+ });
+
+ it("tolerates missing handlers", () => {
+ expect(() => composeEventHandlers()(new Event("click"))).not.toThrow();
+ });
+});
+
+describe("composeRefs", () => {
+ it("assigns object refs and calls callback refs", () => {
+ const objectRef = { current: null as string | null };
+ let callbackValue: string | null = null;
+ const ref = composeRefs<string | null>(objectRef, (v) => {
+ callbackValue = v;
+ });
+ ref("node");
+ expect(objectRef.current).toBe("node");
+ expect(callbackValue).toBe("node");
+ });
+
+ it("ignores null and undefined refs", () => {
+ const ref = composeRefs<string>(null, undefined);
+ expect(ref("node")).toBeUndefined();
+ });
+
+ it("returns no cleanup when no ref returns one", () => {
+ const ref = composeRefs<string>({ current: null }, () => {});
+ expect(ref("node")).toBeUndefined();
+ });
+
+ it("runs ref cleanups and nulls the other refs on cleanup", () => {
+ const objectRef = { current: null as string | null };
+ let cleaned = false;
+ const ref = composeRefs<string | null>(objectRef, () => () => {
+ cleaned = true;
+ });
+ const cleanup = ref("node");
+ expect(objectRef.current).toBe("node");
+ expect(typeof cleanup).toBe("function");
+ (cleanup as () => void)();
+ expect(cleaned).toBe(true);
+ expect(objectRef.current).toBeNull();
+ });
+});
diff --git a/apps/dashboard/src/lib/domains.test.ts b/apps/dashboard/src/lib/domains.test.ts
new file mode 100644
index 000000000..e24e0d3a9
--- /dev/null
+++ b/apps/dashboard/src/lib/domains.test.ts
@@ -0,0 +1,62 @@
+import { expect } from "@std/expect";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+import { type Stub, stub } from "@std/testing/mock";
+
+import { extractDomain, getApexDomain, getSubdomain } from "./domains";
+
+let errorStub: Stub | undefined;
+beforeEach(() => {
+ errorStub = stub(console, "error");
+});
+afterEach(() => errorStub?.restore());
+
+describe("getSubdomain", () => {
+ it("returns null for the apex itself", () => {
+ expect(getSubdomain("openstatus.dev", "openstatus.dev")).toBeNull();
+ });
+
+ it("strips the apex and its dot", () => {
+ expect(getSubdomain("status.openstatus.dev", "openstatus.dev")).toBe(
+ "status",
+ );
+ expect(getSubdomain("a.b.openstatus.dev", "openstatus.dev")).toBe("a.b");
+ });
+});
+
+describe("getApexDomain", () => {
+ it("keeps a two-label hostname", () => {
+ expect(getApexDomain("https://openstatus.dev/pricing")).toBe(
+ "openstatus.dev",
+ );
+ });
+
+ it("drops subdomains", () => {
+ expect(getApexDomain("https://status.app.openstatus.dev")).toBe(
+ "openstatus.dev",
+ );
+ });
+
+ it("returns an empty string for an invalid URL", () => {
+ expect(getApexDomain("not a url")).toBe("");
+ });
+});
+
+describe("extractDomain", () => {
+ it("returns the label of a bare domain", () => {
+ expect(extractDomain("https://mxkaske.dev")).toBe("mxkaske");
+ });
+
+ it("joins subdomains with dashes", () => {
+ expect(extractDomain("https://craft.mxkaske.dev")).toBe("craft-mxkaske");
+ expect(extractDomain("https://a.b.mxkaske.dev")).toBe("a-b-mxkaske");
+ });
+
+ it("returns an empty string for single-label hosts", () => {
+ expect(extractDomain("http://localhost:3000")).toBe("");
+ });
+
+ it("returns an empty string for blank or invalid input", () => {
+ expect(extractDomain(" ")).toBe("");
+ expect(extractDomain("craft.mxkaske.dev")).toBe("");
+ });
+});
diff --git a/apps/dashboard/src/lib/formatter.test.ts b/apps/dashboard/src/lib/formatter.test.ts
new file mode 100644
index 000000000..9612f3d97
--- /dev/null
+++ b/apps/dashboard/src/lib/formatter.test.ts
@@ -0,0 +1,126 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { FakeTime } from "@std/testing/time";
+
+import {
+ formatDateForInput,
+ formatDateRange,
+ formatDistanceToNowShort,
+ formatMilliseconds,
+ formatNumber,
+ formatPercentage,
+} from "./formatter";
+
+describe("formatMilliseconds", () => {
+ it("keeps milliseconds up to one second", () => {
+ expect(formatMilliseconds(250)).toBe("250 ms");
+ expect(formatMilliseconds(1000)).toBe("1,000 ms");
+ });
+
+ it("switches to seconds above one second", () => {
+ expect(formatMilliseconds(1500)).toBe("1.5 sec");
+ expect(formatMilliseconds(12_345)).toBe("12.35 sec");
+ });
+});
+
+describe("formatPercentage", () => {
+ it("uses two fraction digits by default", () => {
+ expect(formatPercentage(0.99951)).toBe("99.95%");
+ expect(formatPercentage(1)).toBe("100.00%");
+ });
+
+ it("honours a custom precision", () => {
+ expect(formatPercentage(0.5, 0)).toBe("50%");
+ });
+
+ it("treats NaN as full uptime", () => {
+ expect(formatPercentage(Number.NaN)).toBe("100%");
+ });
+});
+
+describe("formatNumber", () => {
+ it("groups thousands", () => {
+ expect(formatNumber(1234567)).toBe("1,234,567");
+ });
+});
+
+describe("formatDateRange", () => {
+ it("returns 'All time' without bounds", () => {
+ expect(formatDateRange()).toBe("All time");
+ });
+
+ it("describes open-ended ranges", () => {
+ const date = new Date(2024, 0, 15, 9, 5);
+ expect(formatDateRange(date)).toMatch(/^Since January 15/);
+ expect(formatDateRange(undefined, date)).toMatch(/^Until January 15/);
+ });
+
+ it("shows only the end time for a same-day range", () => {
+ const range = formatDateRange(
+ new Date(2024, 0, 15, 9, 5),
+ new Date(2024, 0, 15, 17, 30),
+ );
+ expect(range).toMatch(/^January 15.* - 5:30\sPM$/);
+ });
+
+ it("shows only dates for whole-day ranges", () => {
+ expect(
+ formatDateRange(
+ new Date(2024, 0, 1),
+ new Date(2024, 0, 31, 23, 59, 59, 999),
+ ),
+ ).toBe("January 1, 2024 - January 31, 2024");
+ });
+
+ it("shows date and time for partial-day ranges", () => {
+ const range = formatDateRange(
+ new Date(2024, 0, 1, 8, 0),
+ new Date(2024, 0, 3, 18, 0),
+ );
+ expect(range).toMatch(/^January 1.*8:00\sAM - January 3.*6:00\sPM$/);
+ });
+});
+
+describe("formatDistanceToNowShort", () => {
+ const now = new Date("2024-06-01T12:00:00Z");
+
+ for (const [secondsAgo, expected] of [
+ [0, "0s ago"],
+ [59, "59s ago"],
+ [60, "1m ago"],
+ [59 * 60, "59m ago"],
+ [60 * 60, "1h ago"],
+ [23 * 60 * 60, "23h ago"],
+ [24 * 60 * 60, "1d ago"],
+ [10 * 24 * 60 * 60, "10d ago"],
+ ] as const) {
+ it(`${secondsAgo}s -> ${expected}`, () => {
+ const time = new FakeTime(now);
+ try {
+ const date = new Date(now.getTime() - secondsAgo * 1000);
+ expect(formatDistanceToNowShort(date)).toBe(expected);
+ } finally {
+ time.restore();
+ }
+ });
+ }
+
+ it("clamps future dates to 0s", () => {
+ const time = new FakeTime(now);
+ try {
+ expect(formatDistanceToNowShort(new Date(now.getTime() + 60_000))).toBe(
+ "0s ago",
+ );
+ } finally {
+ time.restore();
+ }
+ });
+});
+
+describe("formatDateForInput", () => {
+ it("formats a local datetime-local value with zero padding", () => {
+ expect(formatDateForInput(new Date(2024, 2, 5, 7, 4))).toBe(
+ "2024-03-05T07:04",
+ );
+ });
+});
diff --git a/apps/dashboard/src/lib/onboarding/email-domain.test.ts b/apps/dashboard/src/lib/onboarding/email-domain.test.ts
new file mode 100644
index 000000000..34112fc3d
--- /dev/null
+++ b/apps/dashboard/src/lib/onboarding/email-domain.test.ts
@@ -0,0 +1,32 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { getCompanyDomainFromEmail } from "./email-domain";
+
+describe("getCompanyDomainFromEmail", () => {
+ it("returns the domain of a company email", () => {
+ expect(getCompanyDomainFromEmail("[email protected]")).toBe(
+ "openstatus.dev",
+ );
+ });
+
+ it("lowercases the domain", () => {
+ expect(getCompanyDomainFromEmail("[email protected]")).toBe(
+ "openstatus.dev",
+ );
+ });
+
+ it("ignores generic providers regardless of case", () => {
+ expect(getCompanyDomainFromEmail("[email protected]")).toBeNull();
+ expect(getCompanyDomainFromEmail("[email protected]")).toBeNull();
+ expect(getCompanyDomainFromEmail("[email protected]")).toBeNull();
+ });
+
+ it("returns null for missing or malformed input", () => {
+ expect(getCompanyDomainFromEmail(null)).toBeNull();
+ expect(getCompanyDomainFromEmail(undefined)).toBeNull();
+ expect(getCompanyDomainFromEmail("")).toBeNull();
+ expect(getCompanyDomainFromEmail("no-at-sign")).toBeNull();
+ expect(getCompanyDomainFromEmail("max@")).toBeNull();
+ });
+});
diff --git a/apps/dashboard/src/test/next-link.mock.tsx b/apps/dashboard/src/test/next-link.mock.tsx
new file mode 100644
index 000000000..03dcc1836
--- /dev/null
+++ b/apps/dashboard/src/test/next-link.mock.tsx
@@ -0,0 +1,26 @@
+// Test double for next/link, swapped in via --import-map: Deno cannot resolve
+// Next's extensionless CJS entrypoints. Renders a plain anchor.
+import type * as React from "react";
+
+type LinkProps = Omit<React.ComponentProps<"a">, "href"> & {
+ href: string | { pathname?: string; query?: Record<string, string> };
+ prefetch?: boolean | null;
+ replace?: boolean;
+ scroll?: boolean;
+};
+
+function toHref(href: LinkProps["href"]) {
+ if (typeof href === "string") return href;
+ const query = new URLSearchParams(href.query).toString();
+ return `${href.pathname ?? ""}${query ? `?${query}` : ""}`;
+}
+
+export default function Link({
+ href,
+ prefetch: _prefetch,
+ replace: _replace,
+ scroll: _scroll,
+ ...props
+}: LinkProps) {
+ return <a href={toHref(href)} {...props} />;
+}
diff --git a/apps/dashboard/src/test/next-navigation.mock.ts b/apps/dashboard/src/test/next-navigation.mock.ts
new file mode 100644
index 000000000..c5a9a0bc7
--- /dev/null
+++ b/apps/dashboard/src/test/next-navigation.mock.ts
@@ -0,0 +1,48 @@
+// Test double for next/navigation, swapped in via --import-map. Router calls
+// are recorded on `routerCalls`; reset it between tests.
+export const routerCalls: { method: string; args: unknown[] }[] = [];
+
+function record(method: string) {
+ return (...args: unknown[]) => {
+ routerCalls.push({ method, args });
+ };
+}
+
+const router = {
+ push: record("push"),
+ replace: record("replace"),
+ refresh: record("refresh"),
+ back: record("back"),
+ forward: record("forward"),
+ prefetch: record("prefetch"),
+};
+
+export const navigationState: {
+ pathname: string;
+ params: Record<string, string | string[]>;
+ searchParams: URLSearchParams;
+} = { pathname: "/", params: {}, searchParams: new URLSearchParams() };
+
+export function useRouter() {
+ return router;
+}
+
+export function usePathname() {
+ return navigationState.pathname;
+}
+
+export function useParams() {
+ return navigationState.params;
+}
+
+export function useSearchParams() {
+ return navigationState.searchParams;
+}
+
+export function notFound(): never {
+ throw new Error("NEXT_NOT_FOUND");
+}
+
+export function redirect(url: string): never {
+ throw new Error(`NEXT_REDIRECT ${url}`);
+}
diff --git a/apps/dashboard/test.importmap.json b/apps/dashboard/test.importmap.json
index b9dd92bcf..4a9e12782 100644
--- a/apps/dashboard/test.importmap.json
+++ b/apps/dashboard/test.importmap.json
@@ -1,6 +1,9 @@
{
"imports": {
"@/": "./src/",
- "@openstatus/upstash": "./src/test/upstash.mock.ts"
+ "@openstatus/upstash": "./src/test/upstash.mock.ts",
+ "@openstatus/tinybird/src/schema": "../../packages/tinybird/src/schema.ts",
+ "next/link": "./src/test/next-link.mock.tsx",
+ "next/navigation": "./src/test/next-navigation.mock.ts"
}
}
diff --git a/apps/status-page/package.json b/apps/status-page/package.json
index 4431ef339..eefbf6057 100644
--- a/apps/status-page/package.json
+++ b/apps/status-page/package.json
@@ -8,7 +8,7 @@
"build": "next build",
"start": "next start",
"lint": "next lint",
- "test": "deno test --parallel -A --no-check --sloppy-imports",
+ "test": "deno test --parallel -A --no-check --sloppy-imports --import-map=test.importmap.json",
"tsc": "tsc --noEmit"
},
"dependencies": {
diff --git a/apps/status-page/src/components/button/buttons.test.tsx b/apps/status-page/src/components/button/buttons.test.tsx
new file mode 100644
index 000000000..ea891d4c2
--- /dev/null
+++ b/apps/status-page/src/components/button/buttons.test.tsx
@@ -0,0 +1,72 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { ChartTooltipNumber } from "../chart/chart-tooltip-number";
+import { PopoverQuantile } from "../popover/popover-quantile";
+import { ButtonBack } from "./button-back";
+import { ButtonCopyLink } from "./button-copy-link";
+
+describe("ButtonBack", () => {
+ it("links home by default", () => {
+ const html = renderToStaticMarkup(<ButtonBack />);
+ expect(html).toMatch(/<a [^>]*href="\/"/);
+ expect(html).toContain("Back");
+ });
+
+ it("links to a custom href", () => {
+ expect(renderToStaticMarkup(<ButtonBack href="/events" />)).toMatch(
+ /<a [^>]*href="\/events"/,
+ );
+ });
+});
+
+describe("ButtonCopyLink", () => {
+ it("has an accessible label", () => {
+ expect(renderToStaticMarkup(<ButtonCopyLink />)).toMatch(
+ /<span class="sr-only">Copy Link<\/span>/,
+ );
+ });
+});
+
+describe("PopoverQuantile", () => {
+ it("wraps its children in a popover trigger", () => {
+ const html = renderToStaticMarkup(<PopoverQuantile>p95</PopoverQuantile>);
+ expect(html).toContain('aria-haspopup="dialog"');
+ expect(html).toContain("p95");
+ });
+});
+
+describe("ChartTooltipNumber", () => {
+ const chartConfig = { p50: { label: "P50" } };
+
+ it("uses the config label and a millisecond suffix", () => {
+ const html = renderToStaticMarkup(
+ <ChartTooltipNumber chartConfig={chartConfig} name="p50" value={120} />,
+ );
+ expect(html).toContain("<span>P50</span>");
+ expect(html).toMatch(/120<span[^>]*>ms<\/span>/);
+ expect(html).toContain("--color-bg:var(--color-p50)");
+ });
+
+ it("falls back to the series name", () => {
+ expect(
+ renderToStaticMarkup(
+ <ChartTooltipNumber chartConfig={chartConfig} name="p99" value={1} />,
+ ),
+ ).toContain("<span>p99</span>");
+ });
+
+ it("prefers a custom label formatter", () => {
+ expect(
+ renderToStaticMarkup(
+ <ChartTooltipNumber
+ chartConfig={chartConfig}
+ name="p50"
+ value={1}
+ labelFormatter={(_, name) => `median (${name})`}
+ />,
+ ),
+ ).toContain("<span>median (p50)</span>");
+ });
+});
diff --git a/apps/status-page/src/components/common/link.test.tsx b/apps/status-page/src/components/common/link.test.tsx
new file mode 100644
index 000000000..2ad2294d0
--- /dev/null
+++ b/apps/status-page/src/components/common/link.test.tsx
@@ -0,0 +1,63 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { NuqsTestingAdapter } from "nuqs/adapters/testing";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { Link } from "./link";
+
+function render(props: React.ComponentProps<typeof Link>, searchParams = "") {
+ return renderToStaticMarkup(
+ <NuqsTestingAdapter searchParams={searchParams}>
+ <Link {...props} />
+ </NuqsTestingAdapter>,
+ );
+}
+
+describe("Link", () => {
+ it("keeps internal links in the same tab outside embeds", () => {
+ const html = render({ href: "/events", children: "Events" });
+ expect(html).toContain('href="/events"');
+ expect(html).not.toContain("target=");
+ });
+
+ it("opens internal links in a new tab inside an embed", () => {
+ const html = render({ href: "/events", children: "Events" }, "?embed=all");
+ expect(html).toContain('target="_blank"');
+ expect(html).toContain('rel="noopener noreferrer"');
+ });
+
+ it("keeps a caller-provided rel inside an embed", () => {
+ const html = render(
+ { href: "/events", rel: "nofollow", children: "Events" },
+ "?embed=feed",
+ );
+ expect(html).toContain('rel="nofollow"');
+ });
+
+ for (const href of [
+ "https://openstatus.dev",
+ "mailto:[email protected]",
+ "tel:+123",
+ "//cdn.acme.dev",
+ "#components",
+ ]) {
+ it(`leaves ${href} untouched inside an embed`, () => {
+ expect(render({ href, children: "x" }, "?embed=all")).not.toContain(
+ 'target="_blank"',
+ );
+ });
+ }
+
+ it("respects an explicit target outside embeds", () => {
+ expect(
+ render({ href: "https://x.dev", target: "_blank", children: "x" }),
+ ).toContain('target="_blank"');
+ });
+
+ it("applies the variant classes", () => {
+ expect(render({ href: "/", children: "x" })).toContain("font-medium");
+ expect(
+ render({ href: "/", variant: "unstyled", children: "x" }),
+ ).not.toContain("font-medium");
+ });
+});
diff --git a/apps/status-page/src/components/content/process-message.test.tsx b/apps/status-page/src/components/content/process-message.test.tsx
new file mode 100644
index 000000000..75db588b1
--- /dev/null
+++ b/apps/status-page/src/components/content/process-message.test.tsx
@@ -0,0 +1,51 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { ProcessMessage } from "./process-message";
+
+function render(value: string) {
+ return renderToStaticMarkup(<ProcessMessage value={value} />);
+}
+
+describe("ProcessMessage", () => {
+ it("renders markdown formatting", () => {
+ const html = render("We are **investigating** `api` latency.");
+ expect(html).toContain("<strong>investigating</strong>");
+ expect(html).toContain("<code>api</code>");
+ });
+
+ it("opens links in a new tab without a referrer", () => {
+ const html = render("See [the docs](https://docs.openstatus.dev).");
+ expect(html).toMatch(
+ /<a [^>]*href="https:\/\/docs\.openstatus\.dev"[^>]*>the docs<\/a>/,
+ );
+ expect(html).toContain('target="_blank"');
+ expect(html).toContain('rel="noreferrer"');
+ });
+
+ it("styles unordered lists and keeps their items", () => {
+ const html = render("- first\n- second");
+ expect(html).toContain("list-disc");
+ expect(html).toContain("<li>first</li>");
+ expect(html).toContain("<li>second</li>");
+ });
+
+ it("does not render raw HTML from the message", () => {
+ const html = render('<img src=x onerror="alert(1)">\n\n<script>x</script>');
+ expect(html).not.toContain("<img");
+ expect(html).not.toContain("<script");
+ });
+
+ // remark keeps the URL; React swaps it for a throwing stub
+ it("does not ship a javascript: link payload", () => {
+ expect(render("[click](javascript:alert(1))")).not.toContain("alert(1)");
+ });
+
+ // the `ol` override drops its props, so ordered list items vanish
+ it.ignore("keeps the items of ordered lists", () => {
+ const html = render("1. first\n2. second");
+ expect(html).toContain("list-decimal");
+ expect(html).toContain("<li>first</li>");
+ });
+});
diff --git a/apps/status-page/src/components/date-picker.test.tsx b/apps/status-page/src/components/date-picker.test.tsx
new file mode 100644
index 000000000..eb47b7471
--- /dev/null
+++ b/apps/status-page/src/components/date-picker.test.tsx
@@ -0,0 +1,89 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { DatePicker } from "./date-picker";
+
+const day = 86_400_000;
+const now = new Date();
+const presets = [
+ {
+ id: "1d",
+ label: "Last day",
+ shortcut: "d",
+ values: { from: new Date(now.getTime() - day), to: now },
+ },
+ {
+ id: "7d",
+ label: "Last 7 days",
+ shortcut: "w",
+ values: { from: new Date(now.getTime() - 7 * day), to: now },
+ },
+];
+
+function presetVariants(html: string) {
+ return [
+ ...html.matchAll(/data-variant="(\w+)"[^>]*>\s*<span>([^<]+)<\/span>/g),
+ ].map((m) => [m[2], m[1]]);
+}
+
+describe("DatePicker", () => {
+ it("highlights the preset matching the range", () => {
+ const html = renderToStaticMarkup(
+ <DatePicker
+ range={presets[1].values}
+ onSelect={() => {}}
+ presets={presets}
+ />,
+ );
+ expect(presetVariants(html)).toEqual([
+ ["Last day", "ghost"],
+ ["Last 7 days", "outline"],
+ ]);
+ });
+
+ it("highlights nothing for a custom range", () => {
+ const html = renderToStaticMarkup(
+ <DatePicker
+ range={{ from: new Date(now.getTime() - 2 * day), to: now }}
+ onSelect={() => {}}
+ presets={presets}
+ />,
+ );
+ expect(presetVariants(html).map(([, v]) => v)).toEqual(["ghost", "ghost"]);
+ });
+
+ it("fills the custom range inputs in local time", () => {
+ const from = new Date(2024, 0, 5, 9, 7);
+ const html = renderToStaticMarkup(
+ <DatePicker range={{ from }} onSelect={() => {}} presets={presets} />,
+ );
+ expect(html).toMatch(/id="from"[^>]*value="2024-01-05T09:07"/);
+ expect(html).toMatch(/id="to"[^>]*value=""/);
+ });
+
+ it("limits the inputs to the oldest preset", () => {
+ const html = renderToStaticMarkup(
+ <DatePicker
+ range={{ from: undefined }}
+ onSelect={() => {}}
+ presets={presets}
+ />,
+ );
+ const min = presets[1].values.from;
+ const pad = (n: number) => String(n).padStart(2, "0");
+ const expected = `${min.getFullYear()}-${pad(min.getMonth() + 1)}-${pad(min.getDate())}T${pad(min.getHours())}:${pad(min.getMinutes())}`;
+ expect(html).toContain(`min="${expected}"`);
+ });
+
+ it("shows the preset shortcuts", () => {
+ const html = renderToStaticMarkup(
+ <DatePicker
+ range={{ from: undefined }}
+ onSelect={() => {}}
+ presets={presets}
+ />,
+ );
+ expect(html).toMatch(/Last day[\s\S]*>d<\/kbd>/);
+ });
+});
diff --git a/apps/status-page/src/components/forms/form-manage-subscription.test.tsx b/apps/status-page/src/components/forms/form-manage-subscription.test.tsx
new file mode 100644
index 000000000..63af75e18
--- /dev/null
+++ b/apps/status-page/src/components/forms/form-manage-subscription.test.tsx
@@ -0,0 +1,99 @@
+import type { RouterOutputs } from "@openstatus/api";
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { FormManageSubscription } from "./form-manage-subscription";
+
+type Page = NonNullable<RouterOutputs["statusPage"]["get"]>;
+
+// safe because the form only reads `page.trackers`
+function asPage(trackers: unknown[]): Page {
+ return { trackers } as unknown as Page;
+}
+
+const page = asPage([
+ {
+ type: "group",
+ groupId: 1,
+ groupName: "API",
+ components: [
+ { id: 2, name: "REST" },
+ { id: 3, name: "GraphQL" },
+ ],
+ },
+ { type: "component", component: { id: 4, name: "Website" } },
+]);
+
+const onSubmit = async () => {};
+
+function checkboxes(html: string) {
+ return [
+ ...html.matchAll(
+ /role="checkbox" aria-checked="([^"]+)"[\s\S]*?<label[^>]*>([^<]+)<\/label>/g,
+ ),
+ ].map((m) => [m[2], m[1]]);
+}
+
+describe("FormManageSubscription", () => {
+ it("checks the selected components and marks a partial group as mixed", () => {
+ const html = renderToStaticMarkup(
+ <FormManageSubscription
+ page={page}
+ onSubmit={onSubmit}
+ defaultValues={{ pageComponents: [2, 4], subscribeComponents: true }}
+ />,
+ );
+ expect(checkboxes(html)).toEqual([
+ ["Subscribe to specific components", "true"],
+ ["API", "mixed"],
+ ["REST", "true"],
+ ["GraphQL", "false"],
+ ["Website", "true"],
+ ]);
+ });
+
+ it("marks a group checked once all its components are selected", () => {
+ const html = renderToStaticMarkup(
+ <FormManageSubscription
+ page={page}
+ onSubmit={onSubmit}
+ defaultValues={{ pageComponents: [2, 3], subscribeComponents: true }}
+ />,
+ );
+ expect(checkboxes(html)).toContainEqual(["API", "true"]);
+ });
+
+ it("subscribes to specific components by default", () => {
+ const html = renderToStaticMarkup(
+ <FormManageSubscription page={page} onSubmit={onSubmit} />,
+ );
+ expect(checkboxes(html)[0]).toEqual([
+ "Subscribe to specific components",
+ "true",
+ ]);
+ expect(html).toContain("REST");
+ });
+
+ it("hides the component list when subscribed to the whole page", () => {
+ const html = renderToStaticMarkup(
+ <FormManageSubscription
+ page={page}
+ onSubmit={onSubmit}
+ defaultValues={{ pageComponents: [], subscribeComponents: false }}
+ />,
+ );
+ expect(html).not.toContain("REST");
+ expect(html).not.toContain("Website");
+ });
+
+ it("shows an empty state for a page without components", () => {
+ const html = renderToStaticMarkup(
+ <FormManageSubscription page={asPage([])} onSubmit={onSubmit} />,
+ );
+ expect(html).toContain("No components to subscribe to");
+ expect(html).toContain(
+ "This status page has no components to subscribe to.",
+ );
+ });
+});
diff --git a/apps/status-page/src/components/forms/forms.test.tsx b/apps/status-page/src/components/forms/forms.test.tsx
new file mode 100644
index 000000000..979a1cd42
--- /dev/null
+++ b/apps/status-page/src/components/forms/forms.test.tsx
@@ -0,0 +1,68 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import {
+ FormCard,
+ FormCardContent,
+ FormCardHeader,
+ FormCardTitle,
+} from "./form-card";
+import { FormEmail } from "./form-email";
+import { FormPassword } from "./form-password";
+import { FormSubscribeEmail } from "./form-subscribe-email";
+
+const onSubmit = async () => {};
+
+describe("FormEmail", () => {
+ it("renders an empty, labelled email input", () => {
+ const html = renderToStaticMarkup(<FormEmail id="f" onSubmit={onSubmit} />);
+ expect(html).toContain('id="f"');
+ expect(html).toMatch(/<label[^>]*>Email<\/label>/);
+ expect(html).toMatch(/<input type="email"[^>]*value=""/);
+ });
+});
+
+describe("FormPassword", () => {
+ it("renders a masked, labelled password input", () => {
+ const html = renderToStaticMarkup(<FormPassword onSubmit={onSubmit} />);
+ expect(html).toMatch(/<label[^>]*>Password<\/label>/);
+ expect(html).toContain('type="password"');
+ });
+});
+
+describe("FormSubscribeEmail", () => {
+ it("starts subscribed to the whole page", () => {
+ const html = renderToStaticMarkup(
+ <FormSubscribeEmail onSubmit={onSubmit} />,
+ );
+ expect(html).toContain('placeholder="[email protected]"');
+ expect(html).toMatch(
+ /role="checkbox" aria-checked="false"[\s\S]*Subscribe to specific components/,
+ );
+ expect(html).not.toContain("No components to subscribe to");
+ });
+});
+
+describe("FormCard", () => {
+ it("applies the variant border", () => {
+ expect(
+ renderToStaticMarkup(<FormCard variant="destructive">x</FormCard>),
+ ).toContain("border-destructive");
+ expect(
+ renderToStaticMarkup(<FormCard variant="info">x</FormCard>),
+ ).toContain("border-info");
+ });
+
+ it("composes header, title and content", () => {
+ const html = renderToStaticMarkup(
+ <FormCard>
+ <FormCardHeader>
+ <FormCardTitle>Subscribe</FormCardTitle>
+ </FormCardHeader>
+ <FormCardContent>Body</FormCardContent>
+ </FormCard>,
+ );
+ expect(html).toMatch(/Subscribe[\s\S]*Body/);
+ });
+});
diff --git a/apps/status-page/src/components/locale-switcher.test.tsx b/apps/status-page/src/components/locale-switcher.test.tsx
new file mode 100644
index 000000000..bedb8d2b2
--- /dev/null
+++ b/apps/status-page/src/components/locale-switcher.test.tsx
@@ -0,0 +1,23 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { LocaleSwitcher } from "./locale-switcher";
+
+describe("LocaleSwitcher", () => {
+ it("renders nothing for a single-locale page", () => {
+ expect(renderToStaticMarkup(<LocaleSwitcher pageLocales={["en"]} />)).toBe(
+ "",
+ );
+ expect(renderToStaticMarkup(<LocaleSwitcher pageLocales={null} />)).toBe(
+ "",
+ );
+ expect(renderToStaticMarkup(<LocaleSwitcher />)).toBe("");
+ });
+
+ it("renders a skeleton before mount on a multi-locale page", () => {
+ expect(
+ renderToStaticMarkup(<LocaleSwitcher pageLocales={["en", "fr"]} />),
+ ).toContain('data-slot="status-locale-switcher-skeleton"');
+ });
+});
diff --git a/apps/status-page/src/components/status-page/status-component-group.test.tsx b/apps/status-page/src/components/status-page/status-component-group.test.tsx
new file mode 100644
index 000000000..7a8a10bb9
--- /dev/null
+++ b/apps/status-page/src/components/status-page/status-component-group.test.tsx
@@ -0,0 +1,35 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { StatusComponentGroup } from "./status-component-group";
+
+describe("StatusComponentGroup", () => {
+ it("renders the title and carries the aggregated status", () => {
+ const html = renderToStaticMarkup(
+ <StatusComponentGroup title="API" status="degraded" />,
+ );
+ expect(html).toContain("API");
+ expect(html).toMatch(/<button[^>]*data-variant="degraded"/);
+ });
+
+ it("starts collapsed by default", () => {
+ const html = renderToStaticMarkup(
+ <StatusComponentGroup title="API">
+ <span>child component</span>
+ </StatusComponentGroup>,
+ );
+ expect(html).toContain('aria-expanded="false"');
+ expect(html).not.toContain("child component");
+ });
+
+ it("shows children when open by default", () => {
+ const html = renderToStaticMarkup(
+ <StatusComponentGroup title="API" defaultOpen>
+ <span>child component</span>
+ </StatusComponentGroup>,
+ );
+ expect(html).toContain('aria-expanded="true"');
+ expect(html).toContain("child component");
+ });
+});
diff --git a/apps/status-page/src/components/status-page/status-feed.test.tsx b/apps/status-page/src/components/status-page/status-feed.test.tsx
new file mode 100644
index 000000000..a154a186f
--- /dev/null
+++ b/apps/status-page/src/components/status-page/status-feed.test.tsx
@@ -0,0 +1,82 @@
+import { expect } from "@std/expect";
+import { afterEach, describe, it } from "@std/testing/bdd";
+import { NuqsTestingAdapter } from "nuqs/adapters/testing";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { pathnamePrefix } from "@/test/use-pathname-prefix.mock";
+
+import { StatusFeed } from "./status-feed";
+
+type Props = React.ComponentProps<typeof StatusFeed>;
+
+function render(props: Props = {}) {
+ return renderToStaticMarkup(
+ <NuqsTestingAdapter>
+ <StatusFeed {...props} />
+ </NuqsTestingAdapter>,
+ );
+}
+
+const report = {
+ id: 7,
+ title: "API outage",
+ affected: ["API"],
+ updates: [
+ {
+ date: new Date("2024-05-01T10:00:00Z"),
+ status: "investigating" as const,
+ message: "Looking into **errors**.",
+ },
+ ],
+};
+
+const maintenance = {
+ id: 3,
+ title: "DB upgrade",
+ affected: [],
+ message: "Planned work",
+ from: new Date("2024-06-01T10:00:00Z"),
+ to: new Date("2024-06-01T11:00:00Z"),
+};
+
+afterEach(() => {
+ pathnamePrefix.value = "";
+});
+
+describe("StatusFeed", () => {
+ it("links to the events history when empty", () => {
+ const html = render();
+ expect(html).toContain('href="/events"');
+ expect(html).toContain("View events history");
+ });
+
+ it("links each event to its detail page", () => {
+ const html = render({
+ statusReports: [report],
+ maintenances: [maintenance],
+ });
+ expect(html).toContain('href="/events/report/7"');
+ expect(html).toContain('href="/events/maintenance/3"');
+ });
+
+ it("prefixes links with the locale or slug", () => {
+ pathnamePrefix.value = "acme";
+ const html = render({ statusReports: [report] });
+ expect(html).toContain('href="/acme/events/report/7"');
+ expect(html).toContain('href="/acme/events"');
+ });
+
+ it("lists the newest event first", () => {
+ const html = render({
+ statusReports: [report],
+ maintenances: [maintenance],
+ });
+ expect(html.indexOf("DB upgrade")).toBeLessThan(html.indexOf("API outage"));
+ });
+
+ it("renders report messages as markdown", () => {
+ expect(render({ statusReports: [report] })).toContain(
+ "<strong>errors</strong>",
+ );
+ });
+});
diff --git a/apps/status-page/src/components/status-page/utils.test.ts b/apps/status-page/src/components/status-page/utils.test.ts
new file mode 100644
index 000000000..ea5fa252d
--- /dev/null
+++ b/apps/status-page/src/components/status-page/utils.test.ts
@@ -0,0 +1,88 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ type ChartData,
+ getHighestPriorityStatus,
+ getHighestStatus,
+ getPercentagePriorityStatus,
+} from "./utils";
+
+function day(
+ counts: Partial<Pick<ChartData, "success" | "degraded" | "error" | "info">>,
+): ChartData {
+ return {
+ timestamp: 0,
+ success: 0,
+ degraded: 0,
+ error: 0,
+ info: 0,
+ ...counts,
+ };
+}
+
+describe("getHighestPriorityStatus", () => {
+ it("returns empty for a day without data", () => {
+ expect(getHighestPriorityStatus(day({}))).toBe("empty");
+ });
+
+ it("ranks error over degraded over info over success", () => {
+ expect(
+ getHighestPriorityStatus(
+ day({ success: 1, info: 1, degraded: 1, error: 1 }),
+ ),
+ ).toBe("error");
+ expect(
+ getHighestPriorityStatus(day({ success: 1, info: 1, degraded: 1 })),
+ ).toBe("degraded");
+ expect(getHighestPriorityStatus(day({ success: 1, info: 1 }))).toBe("info");
+ expect(getHighestPriorityStatus(day({ success: 1 }))).toBe("success");
+ });
+
+ it("lets a single error minute outrank a full day of success", () => {
+ expect(getHighestPriorityStatus(day({ success: 1439, error: 1 }))).toBe(
+ "error",
+ );
+ });
+});
+
+describe("getPercentagePriorityStatus", () => {
+ it("returns empty for a day without data", () => {
+ expect(getPercentagePriorityStatus(day({}))).toBe("empty");
+ });
+
+ it("applies the 95% and 75% success thresholds", () => {
+ expect(getPercentagePriorityStatus(day({ success: 95, error: 5 }))).toBe(
+ "success",
+ );
+ expect(getPercentagePriorityStatus(day({ success: 94, error: 6 }))).toBe(
+ "degraded",
+ );
+ expect(getPercentagePriorityStatus(day({ success: 75, error: 25 }))).toBe(
+ "degraded",
+ );
+ expect(getPercentagePriorityStatus(day({ success: 74, error: 26 }))).toBe(
+ "error",
+ );
+ });
+
+ it("treats a day with no successful checks as error", () => {
+ expect(getPercentagePriorityStatus(day({ error: 10 }))).toBe("error");
+ expect(getPercentagePriorityStatus(day({ info: 10 }))).toBe("error");
+ });
+});
+
+describe("getHighestStatus", () => {
+ it("picks the most severe status", () => {
+ expect(getHighestStatus(["success", "info", "degraded", "error"])).toBe(
+ "error",
+ );
+ expect(getHighestStatus(["success", "info", "degraded"])).toBe("degraded");
+ expect(getHighestStatus(["success", "info"])).toBe("info");
+ expect(getHighestStatus(["success"])).toBe("success");
+ });
+
+ it("defaults to success for an empty list", () => {
+ expect(getHighestStatus([])).toBe("success");
+ });
+});
diff --git a/apps/status-page/src/components/themes/theme-builder-provider.test.tsx b/apps/status-page/src/components/themes/theme-builder-provider.test.tsx
new file mode 100644
index 000000000..ebb5dfd6b
--- /dev/null
+++ b/apps/status-page/src/components/themes/theme-builder-provider.test.tsx
@@ -0,0 +1,65 @@
+import { THEMES } from "@openstatus/theme-store";
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import { NuqsTestingAdapter } from "nuqs/adapters/testing";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { ThemePromptButton } from "./theme-agent-actions";
+import {
+ ThemeBuilderProvider,
+ useThemeBuilder,
+} from "./theme-builder-provider";
+import { ThemePasteDialog } from "./theme-paste-dialog";
+
+function Probe() {
+ const { theme, isModified } = useThemeBuilder();
+ return (
+ <p>
+ {theme.id}|{String(isModified)}
+ </p>
+ );
+}
+
+function render(node: React.ReactNode, searchParams = "") {
+ return renderToStaticMarkup(
+ <NuqsTestingAdapter searchParams={searchParams}>
+ <ThemeBuilderProvider>{node}</ThemeBuilderProvider>
+ </NuqsTestingAdapter>,
+ );
+}
+
+describe("ThemeBuilderProvider", () => {
+ it("starts from the default theme, unmodified", () => {
+ expect(render(<Probe />)).toBe(`<p>${THEMES.default.id}|false</p>`);
+ });
+
+ it("starts from the theme in the `t` search param", () => {
+ expect(render(<Probe />, "?t=dracula")).toBe("<p>dracula|false</p>");
+ });
+
+ it("falls back to the default theme for an unknown key", () => {
+ expect(render(<Probe />, "?t=nope")).toBe(
+ `<p>${THEMES.default.id}|false</p>`,
+ );
+ });
+
+ it("throws when used outside the provider", () => {
+ expect(() => renderToStaticMarkup(<Probe />)).toThrow(
+ "useThemeBuilder must be used within ThemeBuilderProvider",
+ );
+ });
+});
+
+describe("theme builder actions", () => {
+ it("renders the prompt and paste buttons", () => {
+ const html = render(
+ <>
+ <ThemePromptButton />
+ <ThemePasteDialog />
+ </>,
+ );
+ expect(html).toContain("Copy prompt");
+ expect(html).toContain("Paste");
+ expect(html).toContain('aria-haspopup="dialog"');
+ });
+});
diff --git a/apps/status-page/src/components/ui/data-table/data-table-pagination.test.tsx b/apps/status-page/src/components/ui/data-table/data-table-pagination.test.tsx
new file mode 100644
index 000000000..3c227689e
--- /dev/null
+++ b/apps/status-page/src/components/ui/data-table/data-table-pagination.test.tsx
@@ -0,0 +1,149 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+import {
+ type ColumnDef,
+ type SortingState,
+ getCoreRowModel,
+ getPaginationRowModel,
+ getSortedRowModel,
+ useReactTable,
+} from "@tanstack/react-table";
+import { renderToStaticMarkup } from "react-dom/server";
+
+import { DataTableColumnHeader } from "./data-table-column-header";
+import {
+ DataTablePagination,
+ DataTablePaginationSimple,
+} from "./data-table-pagination";
+
+type Row = { n: number };
+const rows: Row[] = Array.from({ length: 25 }, (_, n) => ({ n }));
+
+function Pagination({
+ pageIndex,
+ selected = {},
+ simple = false,
+}: {
+ pageIndex: number;
+ selected?: Record<string, boolean>;
+ simple?: boolean;
+}) {
+ const table = useReactTable({
+ data: rows,
+ columns: [{ accessorKey: "n" }],
+ getCoreRowModel: getCoreRowModel(),
+ getPaginationRowModel: getPaginationRowModel(),
+ initialState: {
+ pagination: { pageIndex, pageSize: 10 },
+ rowSelection: selected,
+ },
+ });
+ return simple ? (
+ <DataTablePaginationSimple table={table} />
+ ) : (
+ <DataTablePagination table={table} />
+ );
+}
+
+function render(props: Parameters<typeof Pagination>[0]) {
+ return renderToStaticMarkup(<Pagination {...props} />);
+}
+
+function disabledButtons(html: string) {
+ return [...html.matchAll(/<button([^>]*)>\s*<span[^>]*>([^<]+)<\/span>/g)]
+ .filter((m) => m[1].includes('disabled=""'))
+ .map((m) => m[2]);
+}
+
+describe("DataTablePagination", () => {
+ it("shows the current page and selection count", () => {
+ const html = render({ pageIndex: 1, selected: { "0": true, "3": true } });
+ expect(html).toContain("2 of 25 row(s) selected.");
+ expect(html).toContain("Page 2 of 3");
+ });
+
+ it("disables backwards navigation on the first page", () => {
+ expect(disabledButtons(render({ pageIndex: 0 }))).toEqual([
+ "Go to first page",
+ "Go to previous page",
+ ]);
+ });
+
+ it("disables forwards navigation on the last page", () => {
+ expect(disabledButtons(render({ pageIndex: 2 }))).toEqual([
+ "Go to next page",
+ "Go to last page",
+ ]);
+ });
+
+ it("enables everything on a middle page", () => {
+ expect(disabledButtons(render({ pageIndex: 1 }))).toEqual([]);
+ });
+});
+
+describe("DataTablePaginationSimple", () => {
+ it("shows the filtered row count", () => {
+ expect(render({ pageIndex: 0, simple: true })).toContain(
+ "25 of 25 row(s) filtered.",
+ );
+ });
+});
+
+describe("DataTableColumnHeader", () => {
+ function Header({
+ sorting,
+ enableSorting = true,
+ }: {
+ sorting: SortingState;
+ enableSorting?: boolean;
+ }) {
+ const columns: ColumnDef<Row>[] = [
+ {
+ accessorKey: "n",
+ enableSorting,
+ header: ({ column }) => (
+ <DataTableColumnHeader column={column} title="Number" />
+ ),
+ },
+ ];
+ const table = useReactTable({
+ data: rows,
+ columns,
+ getCoreRowModel: getCoreRowModel(),
+ getSortedRowModel: getSortedRowModel(),
+ state: { sorting },
+ });
+ const header = table.getHeaderGroups()[0].headers[0];
+ const render = header.column.columnDef.header;
+ return typeof render === "function" ? render(header.getContext()) : null;
+ }
+
+ function chevronClasses(html: string) {
+ return [...html.matchAll(/<svg[^>]*class="([^"]*)"/g)].map((m) =>
+ m[1].includes("text-accent-foreground") ? "active" : "idle",
+ );
+ }
+
+ it("renders plain text for a column that cannot sort", () => {
+ const html = renderToStaticMarkup(
+ <Header sorting={[]} enableSorting={false} />,
+ );
+ expect(html).toMatch(/^<div[^>]*>Number<\/div>$/);
+ });
+
+ it("highlights the active sort direction", () => {
+ expect(
+ chevronClasses(
+ renderToStaticMarkup(<Header sorting={[{ id: "n", desc: false }]} />),
+ ),
+ ).toEqual(["active", "idle"]);
+ expect(
+ chevronClasses(
+ renderToStaticMarkup(<Header sorting={[{ id: "n", desc: true }]} />),
+ ),
+ ).toEqual(["idle", "active"]);
+ expect(
+ chevronClasses(renderToStaticMarkup(<Header sorting={[]} />)),
+ ).toEqual(["idle", "idle"]);
+ });
+});
diff --git a/apps/status-page/src/content/markdown/helpers.test.ts b/apps/status-page/src/content/markdown/helpers.test.ts
new file mode 100644
index 000000000..9b5495769
--- /dev/null
+++ b/apps/status-page/src/content/markdown/helpers.test.ts
@@ -0,0 +1,290 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import {
+ canonicalUrl,
+ componentImpact,
+ componentImpactExplicit,
+ dominantDayStatus,
+ escapeCell,
+ escapeLinkLabel,
+ eventLog,
+ formatDate,
+ formatDay,
+ formatDayTime,
+ formatLogStamp,
+ formatMs,
+ formatPercent,
+ formatStamp,
+ frontmatter,
+ humanDuration,
+ mdUrl,
+ navLine,
+ relativeTime,
+ reportStatusGlyph,
+ statusGlyph,
+ statusLabel,
+ table,
+ uptimeBar,
+ withPoweredBy,
+ worstImpact,
+} from "./helpers";
+
+describe("statusLabel", () => {
+ test("labels component and report statuses", () => {
+ expect(statusLabel("error")).toBe("Outage");
+ expect(statusLabel("info")).toBe("Maintenance");
+ expect(statusLabel("identified")).toBe("Identified");
+ });
+
+ test("passes unknown statuses through", () => {
+ expect(statusLabel("custom")).toBe("custom");
+ });
+});
+
+describe("frontmatter", () => {
+ const base = {
+ title: "Acme",
+ description: "Status",
+ baseUrl: "https://status.acme.com",
+ canonical: "https://status.acme.com",
+ };
+
+ test("quotes and escapes YAML scalars", () => {
+ const out = frontmatter({
+ ...base,
+ title: 'Say "hi"\\\nnext\tline\u0001',
+ });
+ expect(out).toContain('title: "Say \\"hi\\"\\\\\\nnext\\tline\\x01"');
+ });
+
+ test("omits optional urls when absent", () => {
+ const out = frontmatter(base);
+ expect(out).not.toContain("homepage_url");
+ expect(out).not.toContain("contact_url");
+ expect(out.startsWith("---\n")).toBe(true);
+ expect(out.endsWith("---\n")).toBe(true);
+ });
+
+ test("includes live state and drops an invalid fetched_at", () => {
+ const out = frontmatter({
+ ...base,
+ live: {
+ status: "degraded",
+ fetchedAt: "not a date",
+ activeReports: 1,
+ activeMaintenance: 0,
+ componentsOperational: 3,
+ componentsTotal: 4,
+ worstComponent: "API",
+ },
+ });
+ expect(out).toContain('status: "degraded"');
+ expect(out).not.toContain("fetched_at");
+ expect(out).toContain("components_operational: 3");
+ expect(out).toContain('worst_component: "API"');
+ });
+
+ test("renders fetched_at as ISO", () => {
+ const out = frontmatter({
+ ...base,
+ live: {
+ status: "operational",
+ fetchedAt: Date.UTC(2026, 0, 2, 3, 4, 5),
+ activeReports: 0,
+ activeMaintenance: 0,
+ componentsOperational: 1,
+ componentsTotal: 1,
+ },
+ });
+ expect(out).toContain('fetched_at: "2026-01-02T03:04:05.000Z"');
+ });
+});
+
+describe("escapeCell / escapeLinkLabel / table", () => {
+ test("escapes pipes and backslashes and flattens newlines", () => {
+ expect(escapeCell(" a|b\\c\r\nd ")).toBe("a\\|b\\\\c d");
+ });
+
+ test("escapes brackets in link labels", () => {
+ expect(escapeLinkLabel("[beta] api\\")).toBe("\\[beta\\] api\\\\");
+ });
+
+ test("renders a header-only table when there are no rows", () => {
+ expect(table(["A", "B"], [])).toBe("| A | B |\n| --- | --- |");
+ });
+
+ test("renders escaped rows", () => {
+ expect(table(["A"], [["x|y"]])).toBe("| A |\n| --- |\n| x\\|y |");
+ });
+});
+
+describe("number and date formatting", () => {
+ test("formatDate returns ISO or a dash", () => {
+ expect(formatDate(null)).toBe("—");
+ expect(formatDate("nope")).toBe("—");
+ expect(formatDate(0)).toBe("1970-01-01T00:00:00.000Z");
+ });
+
+ test("formatMs rounds and handles missing values", () => {
+ expect(formatMs(12.6)).toBe("13ms");
+ expect(formatMs(undefined)).toBe("—");
+ expect(formatMs(Number.NaN)).toBe("—");
+ });
+
+ test("formatPercent keeps three decimals", () => {
+ expect(formatPercent(0.99987)).toBe("99.987%");
+ expect(formatPercent(1)).toBe("100.000%");
+ });
+
+ const instant = Date.UTC(2026, 5, 18, 14, 5);
+
+ test("formats in UTC", () => {
+ expect(formatDay(instant)).toBe("Jun 18, 2026");
+ expect(formatDayTime(instant)).toBe("Jun 18, 2:05 PM");
+ expect(formatLogStamp(instant)).toBe("2026-06-18 14:05");
+ expect(formatStamp(instant)).toBe("Jun 18, 2026 14:05 (GMT+0)");
+ });
+
+ test("formatDayTime uses 12 for midnight and noon", () => {
+ expect(formatDayTime(Date.UTC(2026, 0, 1, 0, 0))).toBe("Jan 1, 12:00 AM");
+ expect(formatDayTime(Date.UTC(2026, 0, 1, 12, 0))).toBe("Jan 1, 12:00 PM");
+ expect(formatDayTime("bad")).toBe("—");
+ });
+});
+
+describe("urls and navigation", () => {
+ test("canonicalUrl joins without a double slash", () => {
+ expect(canonicalUrl("https://x.dev", "/events")).toBe(
+ "https://x.dev/events",
+ );
+ expect(canonicalUrl("https://x.dev")).toBe("https://x.dev");
+ });
+
+ test("mdUrl maps the root to /.md", () => {
+ expect(mdUrl()).toBe("/.md");
+ expect(mdUrl("/events/1")).toBe("/events/1.md");
+ });
+
+ test("navLine links items with a url and escapes labels", () => {
+ expect(
+ navLine([{ label: "Home", url: "/.md" }, { label: "[Event]" }]),
+ ).toBe("[Home](/.md) › \\[Event\\]");
+ });
+});
+
+describe("status glyphs", () => {
+ test("falls back to the empty glyph", () => {
+ expect(statusGlyph("error")).toBe("x");
+ expect(statusGlyph("unknown")).toBe(".");
+ });
+
+ test("maps report statuses", () => {
+ expect(reportStatusGlyph("resolved")).toBe("+");
+ expect(reportStatusGlyph("maintenance")).toBe("=");
+ expect(reportStatusGlyph("investigating")).toBe("x");
+ });
+
+ test("dominantDayStatus picks the worst non-empty segment", () => {
+ expect(
+ dominantDayStatus([
+ { status: "success", height: 90 },
+ { status: "degraded", height: 10 },
+ { status: "error", height: 0 },
+ ]),
+ ).toBe("degraded");
+ expect(dominantDayStatus([])).toBe("empty");
+ });
+
+ test("uptimeBar renders one glyph per day in a code span", () => {
+ expect(uptimeBar([])).toBe("");
+ expect(
+ uptimeBar([
+ { bar: [{ status: "success", height: 1 }] },
+ { bar: [{ status: "error", height: 1 }] },
+ { bar: [] },
+ ]),
+ ).toBe("`+x.`");
+ });
+});
+
+describe("impacts", () => {
+ test("componentImpact hides operational", () => {
+ expect(componentImpact("API", "operational")).toBe("API");
+ expect(componentImpact("API", null)).toBe("API");
+ expect(componentImpact("API", "partial_outage")).toBe(
+ "API (partial outage)",
+ );
+ });
+
+ test("componentImpactExplicit keeps operational", () => {
+ expect(componentImpactExplicit("API", "operational")).toBe(
+ "API (operational)",
+ );
+ });
+
+ test("worstImpact returns the most severe", () => {
+ expect(worstImpact([])).toBeNull();
+ expect(
+ worstImpact(["degraded_performance", "major_outage", "operational"]),
+ ).toBe("major_outage");
+ });
+});
+
+describe("eventLog", () => {
+ test("is empty without rows", () => {
+ expect(eventLog([])).toBe("");
+ });
+
+ test("sorts newest first and strips newlines from titles", () => {
+ const out = eventLog([
+ {
+ timestamp: Date.UTC(2026, 0, 1, 9, 0),
+ label: "Investigating",
+ glyph: "x",
+ ref: "#1",
+ title: "first",
+ },
+ {
+ timestamp: Date.UTC(2026, 0, 2, 9, 0),
+ label: "Resolved",
+ glyph: "+",
+ ref: "#1",
+ title: "fixed\n```",
+ },
+ ]).split("\n");
+ expect(out[0]).toBe("```text");
+ expect(out[2]).toContain("2026-01-02 09:00");
+ expect(out[2]).toContain("fixed ```");
+ expect(out[3]).toContain("2026-01-01 09:00");
+ expect(out.at(-1)).toBe("```");
+ expect(out).toHaveLength(5);
+ });
+});
+
+describe("relativeTime / humanDuration", () => {
+ const now = Date.UTC(2026, 5, 1);
+
+ test("reports just now under a minute", () => {
+ expect(relativeTime(now - 30_000, now)).toBe("just now");
+ });
+
+ test("uses singular and plural units", () => {
+ expect(relativeTime(now - 60_000, now)).toBe("1 minute ago");
+ expect(relativeTime(now - 3 * 3_600_000, now)).toBe("3 hours ago");
+ expect(relativeTime(now - 86_400_000, now)).toBe("1 day ago");
+ expect(relativeTime(now - 400 * 86_400_000, now)).toBe("1 year ago");
+ });
+
+ test("humanDuration clamps negative spans", () => {
+ expect(humanDuration(now, now - 10_000)).toBe("1 minute");
+ expect(humanDuration(now, now + 9 * 86_400_000)).toBe("9 days");
+ });
+});
+
+describe("withPoweredBy", () => {
+ test("appends the footer unless white-labeled", () => {
+ expect(withPoweredBy("# Hi", true)).toBe("# Hi");
+ expect(withPoweredBy("# Hi", false)).toContain("openstatus.dev");
+ });
+});
diff --git a/apps/status-page/src/data/actions.client.test.ts b/apps/status-page/src/data/actions.client.test.ts
new file mode 100644
index 000000000..5a04c56a8
--- /dev/null
+++ b/apps/status-page/src/data/actions.client.test.ts
@@ -0,0 +1,63 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import * as incidents from "./incidents.client";
+import * as maintenances from "./maintenances.client";
+import * as monitors from "./monitors.client";
+import * as regionMetrics from "./region-metrics.client";
+import * as statusPages from "./status-pages.client";
+import * as statusReportUpdates from "./status-report-updates.client";
+import * as statusReports from "./status-reports.client";
+
+type ActionModule = {
+ actions: readonly { id: string; variant: string }[];
+ getActions: (
+ props: Record<string, () => void>,
+ ) => { id: string; onClick?: () => void }[];
+};
+
+// safe because every module exports the same actions/getActions shape, keyed by its own ids
+function asActionModule(mod: unknown): ActionModule {
+ return mod as ActionModule;
+}
+
+const modules = {
+ incidents,
+ maintenances,
+ monitors,
+ regionMetrics,
+ statusPages,
+ statusReportUpdates,
+ statusReports,
+};
+
+for (const [name, raw] of Object.entries(modules)) {
+ const mod = asActionModule(raw);
+
+ describe(`${name} actions`, () => {
+ it("has unique ids", () => {
+ const ids = mod.actions.map((a) => a.id);
+ expect(new Set(ids).size).toBe(ids.length);
+ });
+
+ it("keeps destructive actions last", () => {
+ const variants = mod.actions.map((a) => a.variant);
+ const firstDestructive = variants.indexOf("destructive");
+ if (firstDestructive === -1) return;
+ expect(
+ variants.slice(firstDestructive).every((v) => v === "destructive"),
+ ).toBe(true);
+ });
+
+ it("wires each handler to its action and leaves the rest unset", () => {
+ const [first, ...rest] = mod.actions;
+ const handler = () => {};
+ const result = mod.getActions({ [first.id]: handler });
+ expect(result.map((a) => a.id)).toEqual(mod.actions.map((a) => a.id));
+ expect(result[0].onClick).toBe(handler);
+ for (const action of result.slice(1, rest.length + 1)) {
+ expect(action.onClick).toBeUndefined();
+ }
+ });
+ });
+}
diff --git a/apps/status-page/src/data/metrics.client.test.ts b/apps/status-page/src/data/metrics.client.test.ts
new file mode 100644
index 000000000..b94027964
--- /dev/null
+++ b/apps/status-page/src/data/metrics.client.test.ts
@@ -0,0 +1,164 @@
+import type { RouterOutputs } from "@openstatus/api";
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import {
+ getMonitorListMetrics,
+ latencyByMonitorId,
+ mapMetrics,
+ mapRegionMetrics,
+} from "./metrics.client";
+
+type MetricsRegions = RouterOutputs["tinybird"]["metricsRegions"];
+type Monitors = RouterOutputs["monitor"]["list"];
+type PageMonitors = RouterOutputs["statusPage"]["getMonitors"];
+
+// safe because each helper reads only the fields these fixtures set
+function asType<T>(value: unknown): T {
+ return value as T;
+}
+
+describe("mapMetrics", () => {
+ test("counts degraded checks as up", () => {
+ const [row] = mapMetrics(
+ asType({
+ data: [
+ {
+ p50Latency: 1,
+ p75Latency: 2,
+ p90Latency: 3,
+ p95Latency: 4,
+ p99Latency: 5,
+ count: 10,
+ success: 7,
+ degraded: 1,
+ error: 2,
+ lastTimestamp: 0,
+ },
+ ],
+ }),
+ );
+ expect(row.uptime).toBe(0.8);
+ expect(row.total).toBe(10);
+ expect(row.p95).toBe(4);
+ });
+});
+
+describe("mapRegionMetrics", () => {
+ test("returns zeroed, sorted regions without a timeline", () => {
+ expect(mapRegionMetrics(undefined, ["fra", "ams"], "p50")).toEqual([
+ { region: "ams", p50: 0, p90: 0, p99: 0, trend: [] },
+ { region: "fra", p50: 0, p90: 0, p99: 0, trend: [] },
+ ]);
+ });
+
+ test("averages percentiles per region and keeps only requested regions", () => {
+ const timeline = asType<MetricsRegions>({
+ data: [
+ {
+ region: "fra",
+ timestamp: 2,
+ p50Latency: 100,
+ p90Latency: 200,
+ p99Latency: 300,
+ p75Latency: 150,
+ },
+ {
+ region: "fra",
+ timestamp: 1,
+ p50Latency: 201,
+ p90Latency: 400,
+ p99Latency: 600,
+ p75Latency: 250,
+ },
+ {
+ region: "ams",
+ timestamp: 1,
+ p50Latency: 50,
+ p90Latency: null,
+ p99Latency: 70,
+ p75Latency: 60,
+ },
+ {
+ region: "iad",
+ timestamp: 1,
+ p50Latency: 999,
+ p90Latency: 999,
+ p99Latency: 999,
+ p75Latency: 999,
+ },
+ ],
+ });
+ const result = mapRegionMetrics(timeline, ["ams", "fra"], "p75");
+ expect(result.map((r) => r.region)).toEqual(["ams", "fra"]);
+ expect(result[0]).toMatchObject({ p50: 50, p90: 0, p99: 70 });
+ expect(result[1]).toMatchObject({ p50: 151, p90: 300, p99: 450 });
+ expect(result[1].trend).toEqual([
+ { latency: 250, timestamp: 1, fra: 250 },
+ { latency: 150, timestamp: 2, fra: 150 },
+ ]);
+ });
+});
+
+describe("getMonitorListMetrics", () => {
+ const monitors = asType<Monitors>([
+ { status: "active", active: true },
+ { status: "active", active: false },
+ { status: "degraded", active: true },
+ { status: "error", active: true },
+ { status: "error", active: false },
+ ]);
+
+ test("counts active monitors by status and inactive ones separately", () => {
+ const values = Object.fromEntries(
+ getMonitorListMetrics(monitors).map((m) => [m.key, m.value]),
+ );
+ expect(values).toEqual({
+ active: 1,
+ degraded: 1,
+ error: 1,
+ inactive: 2,
+ p95: "N/A",
+ });
+ });
+
+ test("shows the slowest p95", () => {
+ const p95 = getMonitorListMetrics(monitors, [
+ { monitorId: "1", p95Latency: 120 },
+ { monitorId: "2", p95Latency: 1500 },
+ ]).find((m) => m.key === "p95");
+ expect(p95?.value).toBe("1.5 sec");
+ });
+});
+
+describe("latencyByMonitorId", () => {
+ test("averages the percentile and compacts the unit", () => {
+ const map = latencyByMonitorId(
+ asType<PageMonitors>([
+ {
+ id: 1,
+ data: [
+ { p75Latency: 100 },
+ { p75Latency: 133 },
+ { p75Latency: null },
+ ],
+ },
+ { id: 2, data: [] },
+ { id: 3, data: [{ p75Latency: 2500 }] },
+ ]),
+ );
+ expect(map.get("1")).toBe("117ms");
+ expect(map.has("2")).toBe(false);
+ expect(map.get("3")).toBe("2.5sec");
+ });
+
+ test("uses the requested percentile", () => {
+ const map = latencyByMonitorId(
+ asType<PageMonitors>([
+ { id: 1, data: [{ p75Latency: 1, p99Latency: 900 }] },
+ ]),
+ "p99",
+ );
+ expect(map.get("1")).toBe("900ms");
+ });
+});
diff --git a/apps/status-page/src/lib/base-url.test.ts b/apps/status-page/src/lib/base-url.test.ts
new file mode 100644
index 000000000..157d28dd6
--- /dev/null
+++ b/apps/status-page/src/lib/base-url.test.ts
@@ -0,0 +1,41 @@
+import { expect } from "@std/expect";
+import { afterEach, beforeEach, describe, it } from "@std/testing/bdd";
+
+import { getBaseUrl } from "./base-url";
+
+let originalEnv: string | undefined;
+
+beforeEach(() => {
+ originalEnv = process.env.NODE_ENV;
+});
+
+afterEach(() => {
+ Object.assign(process.env, { NODE_ENV: originalEnv });
+ if (originalEnv === undefined)
+ Reflect.deleteProperty(process.env, "NODE_ENV");
+});
+
+function setNodeEnv(value: string) {
+ Object.assign(process.env, { NODE_ENV: value });
+}
+
+describe("getBaseUrl", () => {
+ it("uses the openstatus subdomain by default", () => {
+ setNodeEnv("production");
+ expect(getBaseUrl({ slug: "acme" })).toBe("https://acme.openstatus.dev");
+ });
+
+ it("prefers the custom domain", () => {
+ setNodeEnv("production");
+ expect(getBaseUrl({ slug: "acme", customDomain: "status.acme.com" })).toBe(
+ "https://status.acme.com",
+ );
+ });
+
+ it("serves from localhost in development, ignoring the custom domain", () => {
+ setNodeEnv("development");
+ expect(getBaseUrl({ slug: "acme", customDomain: "status.acme.com" })).toBe(
+ "http://localhost:3000/acme",
+ );
+ });
+});
diff --git a/apps/status-page/src/lib/chart.test.ts b/apps/status-page/src/lib/chart.test.ts
new file mode 100644
index 000000000..28ec02780
--- /dev/null
+++ b/apps/status-page/src/lib/chart.test.ts
@@ -0,0 +1,56 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import { getPayloadConfigFromPayload } from "./chart";
+
+const config = {
+ latency: { label: "Latency" },
+ ams: { label: "Amsterdam" },
+};
+
+describe("getPayloadConfigFromPayload", () => {
+ test("returns undefined for a non-object payload", () => {
+ expect(
+ getPayloadConfigFromPayload(config, null, "latency"),
+ ).toBeUndefined();
+ expect(getPayloadConfigFromPayload(config, "x", "latency")).toBeUndefined();
+ });
+
+ test("uses the key directly when the payload has no string override", () => {
+ expect(
+ getPayloadConfigFromPayload(config, { latency: 12 }, "latency"),
+ ).toEqual({ label: "Latency" });
+ });
+
+ test("redirects through a string value on the payload", () => {
+ expect(
+ getPayloadConfigFromPayload(config, { name: "ams" }, "name"),
+ ).toEqual({ label: "Amsterdam" });
+ });
+
+ test("redirects through a string value on the nested payload", () => {
+ expect(
+ getPayloadConfigFromPayload(
+ config,
+ { payload: { region: "ams" } },
+ "region",
+ ),
+ ).toEqual({ label: "Amsterdam" });
+ });
+
+ test("prefers the top-level value over the nested one", () => {
+ expect(
+ getPayloadConfigFromPayload(
+ config,
+ { region: "latency", payload: { region: "ams" } },
+ "region",
+ ),
+ ).toEqual({ label: "Latency" });
+ });
+
+ test("falls back to the key when the redirect is not in the config", () => {
+ expect(
+ getPayloadConfigFromPayload(config, { latency: "fra" }, "latency"),
+ ).toEqual({ label: "Latency" });
+ });
+});
diff --git a/apps/status-page/src/lib/composition.test.ts b/apps/status-page/src/lib/composition.test.ts
new file mode 100644
index 000000000..a65777454
--- /dev/null
+++ b/apps/status-page/src/lib/composition.test.ts
@@ -0,0 +1,69 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import { composeEventHandlers, composeRefs } from "./composition";
+
+describe("composeEventHandlers", () => {
+ test("runs the original handler before ours", () => {
+ const calls: string[] = [];
+ const handler = composeEventHandlers(
+ () => calls.push("original"),
+ () => calls.push("ours"),
+ );
+ handler({ defaultPrevented: false });
+ expect(calls).toEqual(["original", "ours"]);
+ });
+
+ test("skips ours when the original prevents default", () => {
+ const calls: string[] = [];
+ const handler = composeEventHandlers<{ defaultPrevented: boolean }>(
+ (e) => {
+ e.defaultPrevented = true;
+ },
+ () => calls.push("ours"),
+ );
+ handler({ defaultPrevented: false });
+ expect(calls).toEqual([]);
+ });
+
+ test("runs ours anyway when the check is disabled", () => {
+ const calls: string[] = [];
+ const handler = composeEventHandlers(undefined, () => calls.push("ours"), {
+ checkForDefaultPrevented: false,
+ });
+ handler({ defaultPrevented: true });
+ expect(calls).toEqual(["ours"]);
+ });
+});
+
+describe("composeRefs", () => {
+ test("sets object refs and calls callback refs", () => {
+ const objectRef = { current: null as string | null };
+ let callbackValue: string | null = null;
+ composeRefs<string>(
+ objectRef,
+ (v) => {
+ callbackValue = v;
+ },
+ undefined,
+ )("node");
+ expect(objectRef.current).toBe("node");
+ expect(callbackValue).toBe("node");
+ });
+
+ test("returns no cleanup when no ref returns one", () => {
+ expect(composeRefs<string>({ current: null })("node")).toBeUndefined();
+ });
+
+ test("runs cleanups and nulls refs without one", () => {
+ const objectRef = { current: null as string | null };
+ let cleaned = false;
+ const cleanup = composeRefs<string>(objectRef, () => () => {
+ cleaned = true;
+ })("node");
+ expect(typeof cleanup).toBe("function");
+ (cleanup as () => void)();
+ expect(cleaned).toBe(true);
+ expect(objectRef.current).toBeNull();
+ });
+});
diff --git a/apps/status-page/src/lib/embed-params.test.ts b/apps/status-page/src/lib/embed-params.test.ts
new file mode 100644
index 000000000..560a9ee18
--- /dev/null
+++ b/apps/status-page/src/lib/embed-params.test.ts
@@ -0,0 +1,88 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import {
+ ALL_EMBED_SECTIONS,
+ embedParser,
+ embedThemeParser,
+} from "./embed-params";
+
+const all = [...ALL_EMBED_SECTIONS];
+
+describe("embedParser.parse", () => {
+ test("treats an empty value or 'all' as every section", () => {
+ expect(embedParser.parse("")).toEqual({ mode: true, sections: all });
+ expect(embedParser.parse("ALL")).toEqual({ mode: true, sections: all });
+ });
+
+ test("keeps known sections, normalized and deduplicated", () => {
+ expect(embedParser.parse(" Banner ,feed,banner,nope")).toEqual({
+ mode: true,
+ sections: ["banner", "feed"],
+ });
+ });
+
+ test("falls back to every section when nothing valid is given", () => {
+ expect(embedParser.parse(",")).toEqual({ mode: true, sections: all });
+ expect(embedParser.parse("unknown")).toEqual({ mode: true, sections: all });
+ });
+});
+
+describe("embedParser.serialize", () => {
+ test("is empty outside embed mode or with every section", () => {
+ expect(embedParser.serialize({ mode: false, sections: ["feed"] })).toBe("");
+ expect(embedParser.serialize({ mode: true, sections: all })).toBe("");
+ });
+
+ test("joins a narrowed section list", () => {
+ expect(
+ embedParser.serialize({ mode: true, sections: ["title", "feed"] }),
+ ).toBe("title,feed");
+ });
+
+ test("round-trips a narrowed list", () => {
+ const state = { mode: true, sections: ["components", "banner"] as const };
+ expect(
+ embedParser.parse(
+ embedParser.serialize({ ...state, sections: [...state.sections] }),
+ ),
+ ).toEqual({ mode: true, sections: ["components", "banner"] });
+ });
+});
+
+describe("embedParser.eq", () => {
+ test("ignores section order", () => {
+ expect(
+ embedParser.eq(
+ { mode: true, sections: ["title", "feed"] },
+ { mode: true, sections: ["feed", "title"] },
+ ),
+ ).toBe(true);
+ });
+
+ test("differs on mode or sections", () => {
+ expect(
+ embedParser.eq(
+ { mode: true, sections: all },
+ { mode: false, sections: all },
+ ),
+ ).toBe(false);
+ expect(
+ embedParser.eq(
+ { mode: true, sections: ["title"] },
+ { mode: true, sections: ["feed"] },
+ ),
+ ).toBe(false);
+ });
+
+ test("defaults to non-embed mode", () => {
+ expect(embedParser.defaultValue).toEqual({ mode: false, sections: all });
+ });
+});
+
+describe("embedThemeParser", () => {
+ test("accepts only light and dark", () => {
+ expect(embedThemeParser.parse("dark")).toBe("dark");
+ expect(embedThemeParser.parse("sepia")).toBeNull();
+ });
+});
diff --git a/apps/status-page/src/lib/report-impacts.test.ts b/apps/status-page/src/lib/report-impacts.test.ts
new file mode 100644
index 000000000..12d736683
--- /dev/null
+++ b/apps/status-page/src/lib/report-impacts.test.ts
@@ -0,0 +1,57 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import { updatesWithImpactChanges } from "./report-impacts";
+
+describe("updatesWithImpactChanges", () => {
+ test("resolves component names and keeps update fields", () => {
+ const result = updatesWithImpactChanges({
+ statusReportsToPageComponents: [
+ { pageComponent: { id: 1, name: "API" } },
+ { pageComponent: { id: 2, name: "Dashboard" } },
+ ],
+ statusReportUpdates: [
+ {
+ id: 10,
+ message: "Investigating",
+ statusReportUpdateToPageComponents: [
+ { pageComponentId: 2, impact: "major_outage" as const },
+ { pageComponentId: 1, impact: "operational" as const },
+ ],
+ },
+ ],
+ });
+ expect(result).toHaveLength(1);
+ expect(result[0].id).toBe(10);
+ expect(result[0].message).toBe("Investigating");
+ expect(result[0].impactChanges).toEqual([
+ { name: "Dashboard", impact: "major_outage" },
+ { name: "API", impact: "operational" },
+ ]);
+ });
+
+ test("falls back to the id for an unknown component", () => {
+ const [update] = updatesWithImpactChanges({
+ statusReportsToPageComponents: [],
+ statusReportUpdates: [
+ {
+ statusReportUpdateToPageComponents: [
+ { pageComponentId: 7, impact: "partial_outage" as const },
+ ],
+ },
+ ],
+ });
+ expect(update.impactChanges).toEqual([
+ { name: "#7", impact: "partial_outage" },
+ ]);
+ });
+
+ test("returns an empty list without updates", () => {
+ expect(
+ updatesWithImpactChanges({
+ statusReportsToPageComponents: [],
+ statusReportUpdates: [],
+ }),
+ ).toEqual([]);
+ });
+});
diff --git a/apps/status-page/src/lib/theme-draft.test.ts b/apps/status-page/src/lib/theme-draft.test.ts
new file mode 100644
index 000000000..f9e37ab1e
--- /dev/null
+++ b/apps/status-page/src/lib/theme-draft.test.ts
@@ -0,0 +1,65 @@
+import { THEMES } from "@openstatus/theme-store";
+import { expect } from "@std/expect";
+import { afterEach, describe, it } from "@std/testing/bdd";
+
+import {
+ THEME_DRAFT_STORAGE_KEY,
+ clearThemeDraft,
+ readThemeDraft,
+ saveThemeDraft,
+} from "./theme-draft";
+
+afterEach(() => sessionStorage.clear());
+
+const theme = Object.values(THEMES)[0];
+
+describe("theme draft storage", () => {
+ it("returns null when nothing is stored", () => {
+ expect(readThemeDraft()).toBeNull();
+ });
+
+ it("round-trips a saved theme", () => {
+ saveThemeDraft(theme);
+ expect(readThemeDraft()).toEqual(theme);
+ });
+
+ it("clears the draft", () => {
+ saveThemeDraft(theme);
+ clearThemeDraft();
+ expect(readThemeDraft()).toBeNull();
+ });
+
+ it("fills in id, name and author for bare CSS variables", () => {
+ sessionStorage.setItem(
+ THEME_DRAFT_STORAGE_KEY,
+ "--background: oklch(1 0 0);",
+ );
+ expect(readThemeDraft()).toEqual({
+ id: "draft",
+ name: "Draft",
+ author: { name: "", url: "" },
+ light: { "--background": "oklch(1 0 0)" },
+ dark: {},
+ });
+ });
+
+ it("rejects an entry without supported variables", () => {
+ sessionStorage.setItem(THEME_DRAFT_STORAGE_KEY, "garbage");
+ expect(readThemeDraft()).toBeNull();
+ });
+
+ it("does not let a hand-edited value break out of the declaration", () => {
+ sessionStorage.setItem(
+ THEME_DRAFT_STORAGE_KEY,
+ JSON.stringify({
+ light: { "--background": "red;}</style><script>alert(1)</script>" },
+ dark: {},
+ }),
+ );
+ const draft = readThemeDraft();
+ const values = draft
+ ? [...Object.values(draft.light), ...Object.values(draft.dark)]
+ : [];
+ expect(values.some((v) => /[;{}<>]/.test(String(v)))).toBe(false);
+ });
+});
diff --git a/apps/status-page/src/test/next-intl.mock.tsx b/apps/status-page/src/test/next-intl.mock.tsx
new file mode 100644
index 000000000..e0ca76879
--- /dev/null
+++ b/apps/status-page/src/test/next-intl.mock.tsx
@@ -0,0 +1,33 @@
+// Test double for next-intl, swapped in via --import-map: `useExtracted` only
+// works after the next-intl compiler rewrites call sites. Interpolates `{name}`
+// into the English source string, which is all the app's messages use.
+import type { ReactNode } from "react";
+
+export const intlState = { locale: "en" };
+
+function interpolate(message: string, values?: Record<string, unknown>) {
+ if (!values) return message;
+ return message.replace(/\{(\w+)\}/g, (match, key: string) =>
+ key in values ? String(values[key]) : match,
+ );
+}
+
+export function useExtracted() {
+ return (message: string, values?: Record<string, unknown>) =>
+ interpolate(message, values);
+}
+
+export function useLocale() {
+ return intlState.locale;
+}
+
+export function hasLocale<T extends string>(
+ locales: readonly T[],
+ locale: unknown,
+): locale is T {
+ return locales.includes(locale as T);
+}
+
+export function NextIntlClientProvider({ children }: { children: ReactNode }) {
+ return <>{children}</>;
+}
diff --git a/apps/status-page/src/test/next-link.mock.tsx b/apps/status-page/src/test/next-link.mock.tsx
new file mode 100644
index 000000000..03dcc1836
--- /dev/null
+++ b/apps/status-page/src/test/next-link.mock.tsx
@@ -0,0 +1,26 @@
+// Test double for next/link, swapped in via --import-map: Deno cannot resolve
+// Next's extensionless CJS entrypoints. Renders a plain anchor.
+import type * as React from "react";
+
+type LinkProps = Omit<React.ComponentProps<"a">, "href"> & {
+ href: string | { pathname?: string; query?: Record<string, string> };
+ prefetch?: boolean | null;
+ replace?: boolean;
+ scroll?: boolean;
+};
+
+function toHref(href: LinkProps["href"]) {
+ if (typeof href === "string") return href;
+ const query = new URLSearchParams(href.query).toString();
+ return `${href.pathname ?? ""}${query ? `?${query}` : ""}`;
+}
+
+export default function Link({
+ href,
+ prefetch: _prefetch,
+ replace: _replace,
+ scroll: _scroll,
+ ...props
+}: LinkProps) {
+ return <a href={toHref(href)} {...props} />;
+}
diff --git a/apps/status-page/src/test/next-navigation.mock.ts b/apps/status-page/src/test/next-navigation.mock.ts
new file mode 100644
index 000000000..d41c6efd7
--- /dev/null
+++ b/apps/status-page/src/test/next-navigation.mock.ts
@@ -0,0 +1,52 @@
+// Test double for next/navigation, swapped in via --import-map. Router calls
+// are recorded on `routerCalls`; reset it between tests.
+export const routerCalls: { method: string; args: unknown[] }[] = [];
+
+function record(method: string) {
+ return (...args: unknown[]) => {
+ routerCalls.push({ method, args });
+ };
+}
+
+const router = {
+ push: record("push"),
+ replace: record("replace"),
+ refresh: record("refresh"),
+ back: record("back"),
+ forward: record("forward"),
+ prefetch: record("prefetch"),
+};
+
+export const navigationState: {
+ pathname: string;
+ params: Record<string, string | string[]>;
+ searchParams: URLSearchParams;
+} = { pathname: "/", params: {}, searchParams: new URLSearchParams() };
+
+export function useRouter() {
+ return router;
+}
+
+export function usePathname() {
+ return navigationState.pathname;
+}
+
+export function useParams() {
+ return navigationState.params;
+}
+
+export function useSearchParams() {
+ return navigationState.searchParams;
+}
+
+export function unauthorized(): never {
+ throw new Error("NEXT_UNAUTHORIZED");
+}
+
+export function notFound(): never {
+ throw new Error("NEXT_NOT_FOUND");
+}
+
+export function redirect(url: string): never {
+ throw new Error(`NEXT_REDIRECT ${url}`);
+}
diff --git a/apps/status-page/src/test/use-pathname-prefix.mock.ts b/apps/status-page/src/test/use-pathname-prefix.mock.ts
new file mode 100644
index 000000000..1108056a2
--- /dev/null
+++ b/apps/status-page/src/test/use-pathname-prefix.mock.ts
@@ -0,0 +1,8 @@
+// Test double for the usePathnamePrefix hook, swapped in via --import-map: the
+// real hook needs a tRPC provider. Its prefix logic is covered by
+// resolve-pathname-prefix.test.ts.
+export const pathnamePrefix = { value: "" };
+
+export function usePathnamePrefix() {
+ return pathnamePrefix.value;
+}
diff --git a/apps/status-page/test.importmap.json b/apps/status-page/test.importmap.json
new file mode 100644
index 000000000..2ec601198
--- /dev/null
+++ b/apps/status-page/test.importmap.json
@@ -0,0 +1,10 @@
+{
+ "imports": {
+ "@/": "./src/",
+ "./src/hooks/use-pathname-prefix": "./src/test/use-pathname-prefix.mock.ts",
+ "./src/hooks/use-pathname-prefix.ts": "./src/test/use-pathname-prefix.mock.ts",
+ "next/link": "./src/test/next-link.mock.tsx",
+ "next/navigation": "./src/test/next-navigation.mock.ts",
+ "next-intl": "./src/test/next-intl.mock.tsx"
+ }
+}
diff --git a/apps/status-page/tsconfig.json b/apps/status-page/tsconfig.json
index 937cf3ad9..857d87f99 100644
--- a/apps/status-page/tsconfig.json
+++ b/apps/status-page/tsconfig.json
@@ -7,7 +7,8 @@
"plugins": [{ "name": "next" }],
"strictNullChecks": true,
"strict": true,
- "moduleResolution": "bundler"
+ "moduleResolution": "bundler",
+ "jsx": "react-jsx"
},
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
"exclude": ["node_modules", "env.ts"]
diff --git a/apps/web/src/lib/cdn-checker/schema.test.ts b/apps/web/src/lib/cdn-checker/schema.test.ts
new file mode 100644
index 000000000..ab8d72b7e
--- /dev/null
+++ b/apps/web/src/lib/cdn-checker/schema.test.ts
@@ -0,0 +1,77 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import { cdnRegionResponseSchema, cdnSummarySchema } from "./schema";
+
+const success = {
+ region: "ams",
+ cacheStatus: "HIT",
+ cacheStatusRaw: "cf-cache-status: HIT",
+ edgeIp: null,
+ edgePop: null,
+ edgePopLocation: null,
+ ttfbMs: 10,
+ totalMs: 20,
+ statusCode: 200,
+ responseSize: null,
+ age: null,
+ cacheControl: null,
+ etag: null,
+ cdn: null,
+};
+
+describe("cdnRegionResponseSchema", () => {
+ test("defaults a result without a state to success", () => {
+ expect(cdnRegionResponseSchema.parse(success).state).toBe("success");
+ });
+
+ test("parses a success result", () => {
+ expect(
+ cdnRegionResponseSchema.parse({ ...success, state: "success" }).state,
+ ).toBe("success");
+ });
+
+ test("parses an error result", () => {
+ expect(
+ cdnRegionResponseSchema.parse({
+ state: "error",
+ region: "syd",
+ message: "Timeout",
+ }),
+ ).toEqual({ state: "error", region: "syd", message: "Timeout" });
+ });
+
+ test("rejects an unknown cache status", () => {
+ expect(
+ cdnRegionResponseSchema.safeParse({
+ ...success,
+ state: "success",
+ cacheStatus: "WARM",
+ }).success,
+ ).toBe(false);
+ });
+});
+
+describe("cdnSummarySchema", () => {
+ const summary = {
+ totalRegions: 2,
+ respondedRegions: 2,
+ cachedRegions: 1,
+ uncachedRegions: ["ams"],
+ unreachableRegions: [],
+ cdn: null,
+ mixedCdn: false,
+ topology: "unknown",
+ topologyBasis: null,
+ };
+
+ test("defaults the type to summary", () => {
+ expect(cdnSummarySchema.parse(summary).type).toBe("summary");
+ });
+
+ test("rejects an unknown topology", () => {
+ expect(
+ cdnSummarySchema.safeParse({ ...summary, topology: "multicast" }).success,
+ ).toBe(false);
+ });
+});
diff --git a/apps/web/src/lib/checker/utils.test.ts b/apps/web/src/lib/checker/utils.test.ts
new file mode 100644
index 000000000..8cc03eb01
--- /dev/null
+++ b/apps/web/src/lib/checker/utils.test.ts
@@ -0,0 +1,121 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import {
+ type Timing,
+ getTimingPhases,
+ getTimingPhasesWidth,
+ getTotalLatency,
+ is32CharHex,
+ isTimeoutError,
+ latencyFormatter,
+ regionCheckerSchemaResponse,
+ regionFormatter,
+ timestampFormatter,
+} from "./utils";
+
+const timing: Timing = {
+ dnsStart: 0,
+ dnsDone: 10,
+ connectStart: 10,
+ connectDone: 30,
+ tlsHandshakeStart: 30,
+ tlsHandshakeDone: 60,
+ firstByteStart: 60,
+ firstByteDone: 90,
+ transferStart: 90,
+ transferDone: 100,
+};
+
+describe("getTimingPhases", () => {
+ test("computes each phase duration", () => {
+ expect(getTimingPhases(timing)).toEqual({
+ dns: 10,
+ connection: 20,
+ tls: 30,
+ ttfb: 30,
+ transfer: 10,
+ });
+ });
+
+ test("sums phases into the total latency", () => {
+ expect(getTotalLatency(timing)).toBe(100);
+ });
+});
+
+describe("getTimingPhasesWidth", () => {
+ test("lays phases end to end as percentages of the total", () => {
+ expect(getTimingPhasesWidth(timing)).toEqual({
+ dns: { preWidth: 0, width: 10 },
+ connection: { preWidth: 10, width: 20 },
+ tls: { preWidth: 30, width: 30 },
+ ttfb: { preWidth: 60, width: 30 },
+ transfer: { preWidth: 90, width: 10 },
+ });
+ });
+});
+
+describe("formatters", () => {
+ test("latencyFormatter groups thousands and appends ms", () => {
+ expect(latencyFormatter(1234)).toBe("1,234ms");
+ });
+
+ test("timestampFormatter renders GMT", () => {
+ expect(timestampFormatter(Date.UTC(2024, 0, 2, 3, 4, 5))).toBe(
+ "Tue, 02 Jan 2024 03:04:05 GMT",
+ );
+ });
+
+ test("regionFormatter renders short and long forms", () => {
+ expect(regionFormatter("ams")).toMatch(/^ams /);
+ expect(regionFormatter("ams", "long")).toMatch(/^Amsterdam, Netherlands /);
+ });
+});
+
+describe("is32CharHex", () => {
+ test("accepts a dashless uuid", () => {
+ expect(is32CharHex(crypto.randomUUID().replace(/-/g, ""))).toBe(true);
+ expect(is32CharHex("AEC4E0EC3C4F4557B8CE46E55078FC95")).toBe(true);
+ });
+
+ test("rejects anything else", () => {
+ expect(is32CharHex(crypto.randomUUID())).toBe(false);
+ expect(is32CharHex("aec4e0ec3c4f4557b8ce46e55078fc9")).toBe(false);
+ expect(is32CharHex("zec4e0ec3c4f4557b8ce46e55078fc95")).toBe(false);
+ });
+});
+
+describe("isTimeoutError", () => {
+ test("matches only errors named TimeoutError", () => {
+ expect(isTimeoutError(new DOMException("t", "TimeoutError"))).toBe(true);
+ expect(isTimeoutError(new DOMException("a", "AbortError"))).toBe(false);
+ expect(isTimeoutError({ name: "TimeoutError" })).toBe(false);
+ });
+});
+
+describe("regionCheckerSchemaResponse", () => {
+ test("parses a success with defaults", () => {
+ const parsed = regionCheckerSchemaResponse.parse({
+ region: "ams",
+ status: 200,
+ latency: 100,
+ headers: {},
+ timestamp: 0,
+ timing,
+ });
+ expect(parsed).toMatchObject({ state: "success", type: "http" });
+ });
+
+ test("parses an error response", () => {
+ expect(
+ regionCheckerSchemaResponse.parse({ region: "ams", message: "Timeout" }),
+ ).toEqual({ region: "ams", message: "Timeout", state: "error" });
+ });
+
+ test("rejects an unknown region", () => {
+ expect(
+ regionCheckerSchemaResponse.safeParse({ region: "xxx", message: "x" })
+ .success,
+ ).toBe(false);
+ });
+});
diff --git a/apps/web/src/lib/checker/utils.ts b/apps/web/src/lib/checker/utils.ts
index ffe605602..f649dcc80 100644
--- a/apps/web/src/lib/checker/utils.ts
+++ b/apps/web/src/lib/checker/utils.ts
@@ -18,7 +18,7 @@ const RAILWAY_CHECKER_URL =
// ============================================================================
export function latencyFormatter(value: number) {
- return `${new Intl.NumberFormat("us").format(value).toString()}ms`;
+ return `${new Intl.NumberFormat("en-US").format(value).toString()}ms`;
}
export function timestampFormatter(timestamp: number) {
diff --git a/apps/web/src/lib/metadata/shared-metadata.test.ts b/apps/web/src/lib/metadata/shared-metadata.test.ts
new file mode 100644
index 000000000..2c24a4dc9
--- /dev/null
+++ b/apps/web/src/lib/metadata/shared-metadata.test.ts
@@ -0,0 +1,138 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import type { MDXData } from "../../content/utils";
+import {
+ BASE_URL,
+ getHomeMetadata,
+ getPageMetadata,
+ getSocialMetadata,
+} from "./shared-metadata";
+
+type Seo = NonNullable<MDXData["metadata"]["seo"]>;
+
+// safe because the helpers only read slug and metadata
+function page(seo?: Seo, updatedAt?: Date): MDXData {
+ return {
+ slug: "my-post",
+ content: "",
+ metadata: {
+ title: "My Post",
+ description: "About my post",
+ category: "engineering",
+ publishedAt: new Date("2024-01-02T00:00:00Z"),
+ updatedAt,
+ seo,
+ },
+ } as unknown as MDXData;
+}
+
+function twitterImage(meta: ReturnType<typeof getSocialMetadata>) {
+ return (meta.twitter?.images as string[] | undefined)?.[0] ?? "";
+}
+
+describe("getSocialMetadata", () => {
+ test("builds an og image url from title, description and category", () => {
+ const meta = getSocialMetadata({
+ title: "A & B",
+ description: "desc",
+ url: "https://x.test",
+ category: "blog",
+ });
+ const image = twitterImage(meta);
+ const params = new URL(image).searchParams;
+ expect(image.startsWith(`${BASE_URL}/api/og?`)).toBe(true);
+ expect(Object.fromEntries(params)).toEqual({
+ title: "A & B",
+ description: "desc",
+ category: "blog",
+ });
+ expect(meta.openGraph).toMatchObject({
+ url: "https://x.test",
+ type: "website",
+ });
+ });
+
+ test("omits category when absent", () => {
+ const image = twitterImage(
+ getSocialMetadata({ title: "t", description: "d", url: "u" }),
+ );
+ expect(new URL(image).searchParams.has("category")).toBe(false);
+ });
+
+ test("uses an explicit og image as is", () => {
+ const { openGraph, twitter } = getSocialMetadata({
+ title: "t",
+ description: "d",
+ url: "u",
+ ogImage: "/custom.png",
+ });
+ expect(openGraph?.images).toEqual([{ url: "/custom.png" }]);
+ expect(twitter?.images).toEqual(["/custom.png"]);
+ });
+});
+
+describe("getPageMetadata", () => {
+ test("derives title, canonical and article dates", () => {
+ const meta = getPageMetadata(page(), "blog");
+ expect(meta.title).toBe("My Post");
+ expect(meta.description).toBe("About my post");
+ expect(meta.alternates?.canonical).toBe(`${BASE_URL}/blog/my-post`);
+ expect(meta.robots).toBeUndefined();
+ expect(meta.openGraph).toMatchObject({
+ type: "article",
+ publishedTime: "2024-01-02T00:00:00.000Z",
+ modifiedTime: "2024-01-02T00:00:00.000Z",
+ });
+ });
+
+ test("uses the slug at the root without a base path", () => {
+ expect(getPageMetadata(page()).alternates?.canonical).toBe(
+ `${BASE_URL}/my-post`,
+ );
+ });
+
+ test("uses updatedAt as the modified time", () => {
+ const meta = getPageMetadata(
+ page(undefined, new Date("2024-03-04T00:00:00Z")),
+ );
+ expect(meta.openGraph).toMatchObject({
+ modifiedTime: "2024-03-04T00:00:00.000Z",
+ });
+ });
+
+ test("applies seo overrides", () => {
+ const meta = getPageMetadata(
+ page({
+ title: "SEO Title",
+ description: "SEO desc",
+ canonical: "https://elsewhere.test/post",
+ noindex: true,
+ }),
+ );
+ expect(meta.title).toEqual({ absolute: "SEO Title" });
+ expect(meta.description).toBe("SEO desc");
+ expect(meta.alternates?.canonical).toBe("https://elsewhere.test/post");
+ expect(meta.robots).toEqual({ index: false });
+ expect(meta.openGraph?.title).toBe("SEO Title");
+ });
+});
+
+describe("getHomeMetadata", () => {
+ test("bypasses the title template and uses the static og image", () => {
+ const meta = getHomeMetadata(page());
+ expect(meta.title).toEqual({ absolute: "My Post" });
+ expect(meta.alternates?.canonical).toBe("/");
+ expect(meta.twitter?.images).toEqual([`${BASE_URL}/api/og`]);
+ expect(meta.openGraph?.url).toBe(BASE_URL);
+ });
+
+ test("applies seo overrides", () => {
+ const meta = getHomeMetadata(
+ page({ title: "Home SEO", canonical: "/home", noindex: true }),
+ );
+ expect(meta.title).toEqual({ absolute: "Home SEO" });
+ expect(meta.alternates?.canonical).toBe("/home");
+ expect(meta.robots).toEqual({ index: false });
+ });
+});
diff --git a/apps/web/src/lib/monitor/utils.test.ts b/apps/web/src/lib/monitor/utils.test.ts
new file mode 100644
index 000000000..63f24b517
--- /dev/null
+++ b/apps/web/src/lib/monitor/utils.test.ts
@@ -0,0 +1,79 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+import { FakeTime } from "@std/testing/time";
+
+import {
+ getDateByPeriod,
+ getHoursByPeriod,
+ getMinutesByInterval,
+ periodFormatter,
+ periods,
+} from "./utils";
+
+describe("getHoursByPeriod", () => {
+ test("maps each period to its hour count", () => {
+ expect(periods.map(getHoursByPeriod)).toEqual([24, 168, 336]);
+ });
+});
+
+describe("periodFormatter", () => {
+ test("labels each period", () => {
+ expect(periods.map(periodFormatter)).toEqual([
+ "Last day",
+ "Last 7 days",
+ "Last 14 days",
+ ]);
+ });
+});
+
+describe("getDateByPeriod", () => {
+ // mid-June, local time, so no DST transition falls inside any period
+ const now = new Date(2024, 5, 15, 13, 27, 45, 123);
+
+ function at<T>(fn: () => T) {
+ const time = new FakeTime(now);
+ try {
+ return fn();
+ } finally {
+ time.restore();
+ }
+ }
+
+ test("ends every period at the end of today", () => {
+ for (const period of periods) {
+ expect(at(() => getDateByPeriod(period)).to).toEqual(
+ new Date(2024, 5, 15, 23, 59, 59, 999),
+ );
+ }
+ });
+
+ test("starts 1d a day before the current hour", () => {
+ expect(at(() => getDateByPeriod("1d")).from).toEqual(
+ new Date(2024, 5, 14, 13, 0, 0, 0),
+ );
+ });
+
+ test("starts longer periods at midnight, n days back", () => {
+ expect(at(() => getDateByPeriod("7d")).from).toEqual(
+ new Date(2024, 5, 8, 0, 0, 0, 0),
+ );
+ expect(at(() => getDateByPeriod("14d")).from).toEqual(
+ new Date(2024, 5, 1, 0, 0, 0, 0),
+ );
+ });
+});
+
+describe("getMinutesByInterval", () => {
+ test("maps each periodicity to minutes", () => {
+ expect(getMinutesByInterval("1m")).toBe(1);
+ expect(getMinutesByInterval("5m")).toBe(5);
+ expect(getMinutesByInterval("10m")).toBe(10);
+ expect(getMinutesByInterval("30m")).toBe(30);
+ expect(getMinutesByInterval("1h")).toBe(60);
+ });
+
+ test("rounds sub-minute and custom intervals to supported buckets", () => {
+ expect(getMinutesByInterval("30s")).toBe(1);
+ expect(getMinutesByInterval("other")).toBe(60);
+ });
+});
diff --git a/apps/web/src/lib/utils.test.ts b/apps/web/src/lib/utils.test.ts
new file mode 100644
index 000000000..afc5c5ba6
--- /dev/null
+++ b/apps/web/src/lib/utils.test.ts
@@ -0,0 +1,153 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import {
+ cn,
+ formatDuration,
+ hashIP,
+ manipulateDate,
+ notEmpty,
+ numberFormatter,
+ slugify,
+ toCapitalize,
+} from "./utils";
+
+describe("cn", () => {
+ test("lets later tailwind classes win and drops falsy values", () => {
+ expect(cn("p-2", false, null, "p-4", "text-sm")).toBe("p-4 text-sm");
+ });
+});
+
+describe("formatDuration", () => {
+ test("lists every non-zero unit with plurals", () => {
+ expect(
+ formatDuration(2 * 86400000 + 3 * 3600000 + 4 * 60000 + 5000 + 6),
+ ).toBe("2 days, 3 hours, 4 mins, 5 secs, 6 ms");
+ });
+
+ test("uses singular units for a value of one", () => {
+ expect(formatDuration(86400000 + 3600000 + 60000 + 1000 + 1)).toBe(
+ "1 day, 1 hour, 1 min, 1 sec, 1 ms",
+ );
+ });
+
+ test("skips zero units", () => {
+ expect(formatDuration(3600000 + 500)).toBe("1 hour, 500 ms");
+ });
+
+ test("formats a negative duration by its magnitude", () => {
+ expect(formatDuration(-1500)).toBe("1 sec, 500 ms");
+ });
+});
+
+describe("notEmpty", () => {
+ test("filters out only null and undefined", () => {
+ expect([0, "", null, false, undefined, 1].filter(notEmpty)).toEqual([
+ 0,
+ "",
+ false,
+ 1,
+ ]);
+ });
+});
+
+describe("slugify", () => {
+ test("lowercases, hyphenates spaces and drops symbols", () => {
+ expect(slugify("Hello World! v2.0")).toBe("hello-world-v20");
+ });
+
+ test("keeps existing hyphens and underscores", () => {
+ expect(slugify("status_page-Setup")).toBe("status_page-setup");
+ });
+});
+
+describe("numberFormatter", () => {
+ test("uses compact notation", () => {
+ expect(numberFormatter(999)).toBe("999");
+ expect(numberFormatter(1234)).toBe("1.2K");
+ expect(numberFormatter(2_500_000)).toBe("2.5M");
+ });
+});
+
+describe("toCapitalize", () => {
+ test("joins words split on spaces and underscores in PascalCase", () => {
+ expect(toCapitalize("hello_world foo")).toBe("HelloWorldFoo");
+ expect(toCapitalize("SHOUTING")).toBe("Shouting");
+ });
+});
+
+describe("manipulateDate", () => {
+ test("returns nulls without a range", () => {
+ expect(manipulateDate(null)).toEqual({ fromDate: null, toDate: null });
+ expect(manipulateDate(undefined)).toEqual({ fromDate: null, toDate: null });
+ });
+
+ test("extends a midnight end date to the last millisecond of that day", () => {
+ const from = new Date(2024, 0, 1);
+ const to = new Date(2024, 0, 2);
+ const { fromDate, toDate } = manipulateDate({ from, to });
+ expect(fromDate).toBe(from.getTime());
+ expect(toDate).toBe(new Date(2024, 0, 2, 23, 59, 59, 999).getTime());
+ });
+
+ test("keeps a non-midnight end date as is", () => {
+ const to = new Date(2024, 0, 2, 13, 37, 1);
+ expect(manipulateDate({ from: undefined, to }).toDate).toBe(to.getTime());
+ });
+
+ // midnight is detected by the timestamp ending in "00000", which also
+ // matches any time on a 100-second boundary, e.g. 10:00:00
+ test.ignore("keeps a whole-hour end date as is", () => {
+ const to = new Date(2024, 0, 2, 10);
+ expect(manipulateDate({ from: undefined, to }).toDate).toBe(to.getTime());
+ });
+});
+
+describe("hashIP", () => {
+ function withSalt(salt: string | undefined, fn: () => Promise<void>) {
+ return async () => {
+ const prev = process.env.FEEDBACK_IP_SALT;
+ if (salt === undefined) delete process.env.FEEDBACK_IP_SALT;
+ else process.env.FEEDBACK_IP_SALT = salt;
+ try {
+ await fn();
+ } finally {
+ if (prev === undefined) delete process.env.FEEDBACK_IP_SALT;
+ else process.env.FEEDBACK_IP_SALT = prev;
+ }
+ };
+ }
+
+ test(
+ "returns a stable 32-char hex digest",
+ withSalt("salt", async () => {
+ const a = await hashIP("203.0.113.7");
+ expect(a).toMatch(/^[0-9a-f]{32}$/);
+ expect(await hashIP("203.0.113.7")).toBe(a);
+ }),
+ );
+
+ test(
+ "differs per input and per salt",
+ withSalt("salt", async () => {
+ const a = await hashIP("203.0.113.7");
+ expect(await hashIP("203.0.113.8")).not.toBe(a);
+ process.env.FEEDBACK_IP_SALT = "other";
+ expect(await hashIP("203.0.113.7")).not.toBe(a);
+ }),
+ );
+
+ // the `?? ""` fallback feeds a zero-length key to importKey, which throws
+ test.ignore(
+ "hashes without a configured secret",
+ withSalt(undefined, async () => {
+ const prev = process.env.CRON_SECRET;
+ delete process.env.CRON_SECRET;
+ try {
+ expect(await hashIP("203.0.113.7")).toMatch(/^[0-9a-f]{32}$/);
+ } finally {
+ if (prev !== undefined) process.env.CRON_SECRET = prev;
+ }
+ }),
+ );
+});
diff --git a/packages/assertions/package.json b/packages/assertions/package.json
index 79323a62c..55d553bca 100644
--- a/packages/assertions/package.json
+++ b/packages/assertions/package.json
@@ -7,7 +7,8 @@
"author": "",
"main": "src/index.ts",
"scripts": {
- "check": "deno check --sloppy-imports ."
+ "check": "deno check --sloppy-imports .",
+ "test": "deno test --parallel -A --no-check --sloppy-imports"
},
"dependencies": {
"jsonpath-plus": "catalog:",
@@ -15,6 +16,8 @@
},
"devDependencies": {
"@openstatus/tsconfig": "workspace:*",
+ "@std/expect": "jsr:^1.0.19",
+ "@std/testing": "jsr:^1.0.19",
"typescript": "catalog:"
}
}
diff --git a/packages/assertions/src/serializing.test.ts b/packages/assertions/src/serializing.test.ts
new file mode 100644
index 000000000..5ae7c405f
--- /dev/null
+++ b/packages/assertions/src/serializing.test.ts
@@ -0,0 +1,82 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { deserialize, serialize } from "./serializing";
+import {
+ DnsRecordAssertion,
+ HeaderAssertion,
+ JsonBodyAssertion,
+ StatusAssertion,
+ TextBodyAssertion,
+} from "./v1";
+
+const raw = [
+ { version: "v1", type: "status", compare: "eq", target: 200 },
+ {
+ version: "v1",
+ type: "header",
+ compare: "contains",
+ key: "Content-Type",
+ target: "json",
+ },
+ { version: "v1", type: "textBody", compare: "not_empty", target: "" },
+ {
+ version: "v1",
+ type: "jsonBody",
+ path: "$.status",
+ compare: "contains",
+ target: "ok",
+ },
+ {
+ version: "v1",
+ type: "dnsRecord",
+ key: "A",
+ compare: "eq",
+ target: "1.1.1.1",
+ },
+];
+
+describe("deserialize", () => {
+ it("builds the matching class for each type", () => {
+ const assertions = deserialize(JSON.stringify(raw));
+ expect(assertions.map((a) => a.constructor)).toEqual([
+ StatusAssertion,
+ HeaderAssertion,
+ TextBodyAssertion,
+ JsonBodyAssertion,
+ DnsRecordAssertion,
+ ]);
+ });
+
+ it("fills in a missing version", () => {
+ const [a] = deserialize('[{"type":"status","compare":"eq","target":200}]');
+ expect(a.schema.version).toBe("v1");
+ });
+
+ it("returns nothing for an empty list", () => {
+ expect(deserialize("[]")).toEqual([]);
+ });
+
+ it("throws on an unknown type", () => {
+ expect(() => deserialize('[{"type":"latency"}]')).toThrow(
+ "unknown assertion type: latency",
+ );
+ });
+
+ it("throws when a known type has invalid fields", () => {
+ expect(() =>
+ deserialize('[{"type":"status","compare":"contains","target":200}]'),
+ ).toThrow();
+ });
+
+ it("throws on malformed JSON", () => {
+ expect(() => deserialize("not json")).toThrow();
+ });
+});
+
+describe("serialize", () => {
+ it("round-trips through deserialize", () => {
+ const json = JSON.stringify(raw);
+ expect(JSON.parse(serialize(deserialize(json)))).toEqual(raw);
+ });
+});
diff --git a/packages/assertions/src/v1.test.ts b/packages/assertions/src/v1.test.ts
new file mode 100644
index 000000000..f9f060c17
--- /dev/null
+++ b/packages/assertions/src/v1.test.ts
@@ -0,0 +1,309 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import type { HttpAssertionRequest } from "./types";
+import {
+ DnsRecordAssertion,
+ HeaderAssertion,
+ JsonBodyAssertion,
+ StatusAssertion,
+ TextBodyAssertion,
+ assertion,
+} from "./v1";
+
+function http(req: Partial<HttpAssertionRequest> = {}): HttpAssertionRequest {
+ return { status: 200, header: {}, body: "", ...req };
+}
+
+describe("StatusAssertion", () => {
+ const cases = [
+ ["eq", 200, 200, true],
+ ["eq", 500, 200, false],
+ ["not_eq", 500, 200, true],
+ ["not_eq", 200, 200, false],
+ ["gt", 201, 200, true],
+ ["gt", 200, 200, false],
+ ["gte", 200, 200, true],
+ ["gte", 199, 200, false],
+ ["lt", 199, 200, true],
+ ["lt", 200, 200, false],
+ ["lte", 200, 200, true],
+ ["lte", 201, 200, false],
+ ] as const;
+
+ for (const [compare, status, target, expected] of cases) {
+ it(`${status} ${compare} ${target} -> ${expected}`, () => {
+ const a = new StatusAssertion({
+ version: "v1",
+ type: "status",
+ compare,
+ target,
+ });
+ expect(a.assert(http({ status })).success).toBe(expected);
+ });
+ }
+
+ it("prefixes the failure message", () => {
+ const a = new StatusAssertion({
+ version: "v1",
+ type: "status",
+ compare: "eq",
+ target: 200,
+ });
+ expect(a.assert(http({ status: 404 }))).toEqual({
+ success: false,
+ message: "Status: Expected 404 to be equal to 200",
+ });
+ });
+
+ it("rejects a DNS request", () => {
+ const a = new StatusAssertion({
+ version: "v1",
+ type: "status",
+ compare: "eq",
+ target: 200,
+ });
+ expect(a.assert({ records: {} })).toEqual({
+ success: false,
+ message: "Invalid request type for status assertion",
+ });
+ });
+});
+
+describe("HeaderAssertion", () => {
+ function header(
+ compare: "contains" | "eq" | "empty" | "not_empty",
+ target = "",
+ ) {
+ return new HeaderAssertion({
+ version: "v1",
+ type: "header",
+ key: "Content-Type",
+ compare,
+ target,
+ });
+ }
+
+ it("matches the header key case-insensitively", () => {
+ const req = http({ header: { "content-type": "application/json" } });
+ expect(header("eq", "application/json").assert(req).success).toBe(true);
+ });
+
+ it("treats a missing header as an empty string", () => {
+ expect(header("empty").assert(http()).success).toBe(true);
+ expect(header("not_empty").assert(http())).toEqual({
+ success: false,
+ message: "Header Content-Type: Expected to not be empty",
+ });
+ });
+
+ it("supports substring matching", () => {
+ const req = http({
+ header: { "Content-Type": "text/html; charset=utf-8" },
+ });
+ expect(header("contains", "charset").assert(req).success).toBe(true);
+ expect(header("contains", "json").assert(req).success).toBe(false);
+ });
+
+ it("rejects a DNS request", () => {
+ expect(header("eq", "x").assert({ records: {} }).success).toBe(false);
+ });
+});
+
+describe("TextBodyAssertion", () => {
+ const body = "hello world";
+ const cases = [
+ ["contains", "world", true],
+ ["contains", "mars", false],
+ ["not_contains", "mars", true],
+ ["not_contains", "world", false],
+ ["eq", "hello world", true],
+ ["eq", "hello", false],
+ ["not_eq", "hello", true],
+ ["not_eq", "hello world", false],
+ ["not_empty", "", true],
+ ["empty", "", false],
+ // string comparisons are lexicographic
+ ["gt", "hello", true],
+ ["lt", "z", true],
+ ["gte", "hello world", true],
+ ["lte", "a", false],
+ ] as const;
+
+ for (const [compare, target, expected] of cases) {
+ it(`"${body}" ${compare} "${target}" -> ${expected}`, () => {
+ const a = new TextBodyAssertion({
+ version: "v1",
+ type: "textBody",
+ compare,
+ target,
+ });
+ expect(a.assert(http({ body })).success).toBe(expected);
+ });
+ }
+
+ it("prefixes the failure message", () => {
+ const a = new TextBodyAssertion({
+ version: "v1",
+ type: "textBody",
+ compare: "contains",
+ target: "ok",
+ });
+ expect(a.assert(http({ body: "nope" }))).toEqual({
+ success: false,
+ message: "Body: Expected nope to contain ok",
+ });
+ });
+});
+
+describe("JsonBodyAssertion", () => {
+ function json(
+ path: string,
+ compare: "contains" | "not_contains" | "eq" | "not_eq" | "empty",
+ target: string,
+ ) {
+ return new JsonBodyAssertion({
+ version: "v1",
+ type: "jsonBody",
+ path,
+ compare,
+ target,
+ });
+ }
+ const body = JSON.stringify({ status: "ok", tags: ["a", "b"] });
+
+ it("finds a value with contains", () => {
+ expect(
+ json("$.status", "contains", "ok").assert(http({ body })).success,
+ ).toBe(true);
+ });
+
+ it("fails not_contains when the value is present", () => {
+ expect(
+ json("$.status", "not_contains", "ok").assert(http({ body })).success,
+ ).toBe(false);
+ });
+
+ it("fails on an invalid JSON body", () => {
+ expect(
+ json("$.status", "eq", "ok").assert(http({ body: "<html>" })),
+ ).toEqual({ success: false, message: "Unable to parse json" });
+ });
+
+ it("rejects a DNS request", () => {
+ expect(json("$.status", "eq", "ok").assert({ records: {} }).success).toBe(
+ false,
+ );
+ });
+
+ // JSONPath returns an array, which is compared to the target as-is, so
+ // these fail today. Un-ignore once the matched value is unwrapped.
+ it.ignore("passes eq when the matched value equals the target", () => {
+ expect(json("$.status", "eq", "ok").assert(http({ body })).success).toBe(
+ true,
+ );
+ });
+
+ it.ignore("fails not_eq when the matched value equals the target", () => {
+ expect(
+ json("$.status", "not_eq", "ok").assert(http({ body })).success,
+ ).toBe(false);
+ });
+
+ it.ignore("matches substrings with contains", () => {
+ expect(
+ json("$.status", "contains", "o").assert(http({ body })).success,
+ ).toBe(true);
+ });
+});
+
+describe("DnsRecordAssertion", () => {
+ function dns(
+ compare: "contains" | "not_contains" | "eq" | "not_eq",
+ target: string,
+ ) {
+ return new DnsRecordAssertion({
+ version: "v1",
+ type: "dnsRecord",
+ key: "A",
+ compare,
+ target,
+ });
+ }
+ const req = { records: { A: ["1.1.1.1", "8.8.8.8"] } };
+
+ const cases = [
+ ["eq", "1.1.1.1", true],
+ ["eq", "1.1.1", false],
+ ["not_eq", "9.9.9.9", true],
+ ["not_eq", "8.8.8.8", false],
+ ["contains", "8.8", true],
+ ["contains", "9.9", false],
+ ["not_contains", "9.9", true],
+ ["not_contains", "1.1", false],
+ ] as const;
+
+ for (const [compare, target, expected] of cases) {
+ it(`A ${compare} ${target} -> ${expected}`, () => {
+ expect(dns(compare, target).assert(req).success).toBe(expected);
+ });
+ }
+
+ it("treats a missing record type as no records", () => {
+ expect(dns("not_contains", "1.1").assert({ records: {} }).success).toBe(
+ true,
+ );
+ expect(dns("eq", "1.1.1.1").assert({ records: {} })).toEqual({
+ success: false,
+ message: "DNS Record A: Expected DNS records [] to equal 1.1.1.1",
+ });
+ });
+
+ it("lists all records in the failure message", () => {
+ expect(dns("eq", "9.9.9.9").assert(req).message).toBe(
+ "DNS Record A: Expected DNS records [1.1.1.1, 8.8.8.8] to equal 9.9.9.9",
+ );
+ });
+
+ it("rejects an HTTP request", () => {
+ expect(dns("eq", "1.1.1.1").assert(http())).toEqual({
+ success: false,
+ message: "Invalid request type for DNS record assertion",
+ });
+ });
+});
+
+describe("assertion schema", () => {
+ it("defaults version to v1", () => {
+ const parsed = assertion.parse({
+ type: "status",
+ compare: "eq",
+ target: 200,
+ });
+ expect(parsed.version).toBe("v1");
+ });
+
+ it("rejects a non-positive status target", () => {
+ expect(
+ assertion.safeParse({ type: "status", compare: "eq", target: 0 }).success,
+ ).toBe(false);
+ });
+
+ it("rejects a string compare on a status assertion", () => {
+ expect(
+ assertion.safeParse({ type: "status", compare: "contains", target: 200 })
+ .success,
+ ).toBe(false);
+ });
+
+ it("rejects an unknown DNS record type", () => {
+ expect(
+ assertion.safeParse({
+ type: "dnsRecord",
+ key: "SRV",
+ compare: "eq",
+ target: "x",
+ }).success,
+ ).toBe(false);
+ });
+});
diff --git a/packages/tracker/src/utils.test.ts b/packages/tracker/src/utils.test.ts
new file mode 100644
index 000000000..6615cc76f
--- /dev/null
+++ b/packages/tracker/src/utils.test.ts
@@ -0,0 +1,68 @@
+import { expect } from "@std/expect";
+import { describe, test } from "@std/testing/bdd";
+
+import { isInBlacklist } from "./blacklist";
+import { endOfDay, isSameDay, startOfDay } from "./utils";
+
+describe("startOfDay", () => {
+ test("truncates to UTC midnight", () => {
+ expect(startOfDay(new Date("2024-03-10T17:45:12.345Z")).toISOString()).toBe(
+ "2024-03-10T00:00:00.000Z",
+ );
+ });
+
+ test("does not mutate its input", () => {
+ const input = new Date("2024-03-10T17:45:12.345Z");
+ startOfDay(input);
+ expect(input.toISOString()).toBe("2024-03-10T17:45:12.345Z");
+ });
+});
+
+describe("endOfDay", () => {
+ test("extends to the last UTC millisecond", () => {
+ expect(endOfDay(new Date("2024-03-10T00:00:00.000Z")).toISOString()).toBe(
+ "2024-03-10T23:59:59.999Z",
+ );
+ });
+
+ test("handles a leap day", () => {
+ expect(endOfDay(new Date("2024-02-29T12:00:00Z")).toISOString()).toBe(
+ "2024-02-29T23:59:59.999Z",
+ );
+ });
+});
+
+describe("isSameDay", () => {
+ test("matches the first and last millisecond of a UTC day", () => {
+ expect(
+ isSameDay(
+ new Date("2024-03-10T00:00:00.000Z"),
+ new Date("2024-03-10T23:59:59.999Z"),
+ ),
+ ).toBe(true);
+ });
+
+ test("splits across UTC midnight", () => {
+ expect(
+ isSameDay(
+ new Date("2024-03-10T23:59:59.999Z"),
+ new Date("2024-03-11T00:00:00.000Z"),
+ ),
+ ).toBe(false);
+ });
+
+ test("compares in UTC regardless of the input offset", () => {
+ expect(
+ isSameDay(
+ new Date("2024-03-10T20:00:00-05:00"),
+ new Date("2024-03-11T23:30:00Z"),
+ ),
+ ).toBe(true);
+ });
+});
+
+describe("isInBlacklist", () => {
+ test("returns undefined for a normal day", () => {
+ expect(isInBlacklist(new Date("2024-01-01T12:00:00Z"))).toBeUndefined();
+ });
+});
diff --git a/packages/utils/src/payloads.test.ts b/packages/utils/src/payloads.test.ts
new file mode 100644
index 000000000..13a5fb124
--- /dev/null
+++ b/packages/utils/src/payloads.test.ts
@@ -0,0 +1,103 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import {
+ DNSPayloadSchema,
+ grpcPayloadSchema,
+ httpPayloadSchema,
+ icmpPayloadSchema,
+ tpcPayloadSchema,
+} from "./payloads";
+
+const common = {
+ workspaceId: "1",
+ monitorId: "2",
+ status: "active",
+ cronTimestamp: 1_700_000_000_000,
+ degradedAfter: null,
+};
+
+describe("httpPayloadSchema", () => {
+ const minimal = {
+ ...common,
+ method: "GET",
+ url: "https://openstatus.dev",
+ assertions: null,
+ };
+
+ it("applies defaults", () => {
+ const parsed = httpPayloadSchema.parse(minimal);
+ expect(parsed.timeout).toBe(45000);
+ expect(parsed.retry).toBe(3);
+ expect(parsed.trigger).toBe("cron");
+ expect(parsed.followRedirects).toBe(true);
+ });
+
+ it("keeps explicit values over defaults", () => {
+ const parsed = httpPayloadSchema.parse({
+ ...minimal,
+ timeout: 1000,
+ retry: 0,
+ trigger: "api",
+ followRedirects: false,
+ });
+ expect(parsed).toMatchObject({
+ timeout: 1000,
+ retry: 0,
+ trigger: "api",
+ followRedirects: false,
+ });
+ });
+
+ it("rejects an unknown method", () => {
+ expect(
+ httpPayloadSchema.safeParse({ ...minimal, method: "FETCH" }).success,
+ ).toBe(false);
+ });
+
+ it("rejects an unknown status", () => {
+ expect(
+ httpPayloadSchema.safeParse({ ...minimal, status: "paused" }).success,
+ ).toBe(false);
+ });
+
+ it("keeps unknown assertion fields so later schemas can parse them", () => {
+ const parsed = httpPayloadSchema.parse({
+ ...minimal,
+ assertions: [{ type: "status", compare: "eq", target: 200 }],
+ });
+ expect(parsed.assertions).toEqual([
+ { version: "v1", type: "status", compare: "eq", target: 200 },
+ ]);
+ });
+});
+
+describe("non-HTTP payload schemas", () => {
+ const withUri = { ...common, uri: "openstatus.dev:443" };
+
+ for (const [name, schema, extra] of [
+ ["tcp", tpcPayloadSchema, { assertions: null }],
+ ["dns", DNSPayloadSchema, { assertions: null }],
+ ["icmp", icmpPayloadSchema, {}],
+ ["grpc", grpcPayloadSchema, {}],
+ ] as const) {
+ it(`${name} applies timeout, retry and trigger defaults`, () => {
+ const parsed = schema.parse({ ...withUri, ...extra });
+ expect(parsed).toMatchObject({
+ timeout: 45000,
+ retry: 3,
+ trigger: "cron",
+ });
+ });
+ }
+
+ it("grpc defaults to tls", () => {
+ expect(grpcPayloadSchema.parse(withUri).tls).toBe("tls");
+ });
+
+ it("grpc rejects an unknown tls mode", () => {
+ expect(
+ grpcPayloadSchema.safeParse({ ...withUri, tls: "mtls" }).success,
+ ).toBe(false);
+ });
+});
diff --git a/packages/utils/src/person-name.test.ts b/packages/utils/src/person-name.test.ts
new file mode 100644
index 000000000..fed7a4402
--- /dev/null
+++ b/packages/utils/src/person-name.test.ts
@@ -0,0 +1,53 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { personName } from "./person-name";
+
+const empty = { name: null, firstName: null, lastName: null, email: null };
+
+describe("personName", () => {
+ it("returns null for a missing person", () => {
+ expect(personName(null)).toBeNull();
+ });
+
+ it("prefers name over everything else", () => {
+ expect(
+ personName({
+ name: "Max",
+ firstName: "Maximilian",
+ lastName: "Kaske",
+ email: "[email protected]",
+ }),
+ ).toBe("Max");
+ });
+
+ it("joins first and last name when name is missing", () => {
+ expect(
+ personName({ ...empty, firstName: "Ada", lastName: "Lovelace" }),
+ ).toBe("Ada Lovelace");
+ });
+
+ it("uses a lone first or last name without stray spaces", () => {
+ expect(personName({ ...empty, firstName: "Ada" })).toBe("Ada");
+ expect(personName({ ...empty, lastName: "Lovelace" })).toBe("Lovelace");
+ });
+
+ it("falls back to email", () => {
+ expect(personName({ ...empty, email: "[email protected]" })).toBe(
+ );
+ });
+
+ it("treats empty strings as missing", () => {
+ expect(
+ personName({ name: "", firstName: "", lastName: "", email: "[email protected]" }),
+ ).toBe("[email protected]");
+ });
+
+ it("returns null when every field is empty", () => {
+ expect(personName(empty)).toBeNull();
+ expect(
+ personName({ name: "", firstName: "", lastName: "", email: "" }),
+ ).toBeNull();
+ });
+});
diff --git a/packages/utils/src/stream.test.ts b/packages/utils/src/stream.test.ts
new file mode 100644
index 000000000..687964064
--- /dev/null
+++ b/packages/utils/src/stream.test.ts
@@ -0,0 +1,90 @@
+import { expect } from "@std/expect";
+import { describe, it } from "@std/testing/bdd";
+
+import { iteratorToStream, yieldMany } from "./stream";
+
+function delay<T>(ms: number, value: T) {
+ return new Promise<T>((resolve) => setTimeout(() => resolve(value), ms));
+}
+
+async function collect<T>(gen: AsyncGenerator<T>) {
+ const out: T[] = [];
+ for await (const v of gen) out.push(v);
+ return out;
+}
+
+describe("yieldMany", () => {
+ it("yields values in settle order, not input order", async () => {
+ const out = await collect(
+ yieldMany([delay(30, "slow"), delay(0, "fast"), delay(15, "mid")]),
+ );
+ expect(out).toEqual(["fast", "mid", "slow"]);
+ });
+
+ it("keeps every value that settles in the same microtask batch", async () => {
+ const out = await collect(
+ yieldMany([1, 2, 3, 4, 5].map((n) => Promise.resolve(n))),
+ );
+ expect(out.sort()).toEqual([1, 2, 3, 4, 5]);
+ });
+
+ it("completes immediately for an empty list", async () => {
+ expect(await collect(yieldMany([]))).toEqual([]);
+ });
+
+ it("returns 'done' when exhausted", async () => {
+ const gen = yieldMany([Promise.resolve(1)]);
+ expect(await gen.next()).toEqual({ value: 1, done: false });
+ expect(await gen.next()).toEqual({ value: "done", done: true });
+ });
+
+ it("yields values settled before a rejection, then throws it", async () => {
+ const out: string[] = [];
+ const run = async () => {
+ for await (const v of yieldMany([
+ delay(0, "a"),
+ delay(10, "unused").then(() => Promise.reject(new Error("boom"))),
+ ])) {
+ out.push(v);
+ }
+ };
+ await expect(run()).rejects.toThrow("boom");
+ expect(out).toEqual(["a"]);
+ });
+
+ it("surfaces only the first of simultaneous rejections", async () => {
+ const gen = yieldMany([
+ Promise.reject(new Error("first")),
+ Promise.reject(new Error("second")),
+ ]);
+ await expect(gen.next()).rejects.toThrow("first");
+ });
+});
+
+describe("iteratorToStream", () => {
+ it("enqueues every yielded value then closes", async () => {
+ async function* gen() {
+ yield "a";
+ yield "b";
+ }
+ const chunks: unknown[] = [];
+ for await (const chunk of iteratorToStream(gen())) chunks.push(chunk);
+ expect(chunks).toEqual(["a", "b"]);
+ });
+
+ it("errors the stream when the iterator throws", async () => {
+ async function* gen() {
+ yield "a";
+ throw new Error("broken");
+ }
+ const reader = iteratorToStream(gen()).getReader();
+ const originalError = console.error;
+ console.error = () => {};
+ try {
+ expect(await reader.read()).toEqual({ value: "a", done: false });
+ await expect(reader.read()).rejects.toThrow("broken");
+ } finally {
+ console.error = originalError;
+ }
+ });
+});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f370ecea5..659d33364 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2159,6 +2159,12 @@ importers:
'@openstatus/tsconfig':
specifier: workspace:*
version: link:../tsconfig
+ '@std/expect':
+ specifier: jsr:^1.0.19
+ version: '@jsr/[email protected]'
+ '@std/testing':
+ specifier: jsr:^1.0.19
+ version: '@jsr/[email protected]'
typescript:
specifier: 'catalog:'
version: 7.0.2