Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.jsonindex 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.jsonindex 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.jsonnew file mode 100644index 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.jsonindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.jsonindex 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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(+ "[email protected]",+ );+ });++ 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.tsnew file mode 100644index 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.yamlindex 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