Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
Add more tests vibe coding ftw (#1699)
Copilota4060e89e2c6
diff --git a/apps/server/.env.test b/apps/server/.env.testindex a9ab6f167..4e7111d5a 100644--- a/apps/server/.env.test+++ b/apps/server/.env.test@@ -12,4 +12,4 @@ RESEND_API_KEY=testSQLD_HTTP_AUTH=basic:tokenSCREENSHOT_SERVICE_URL=http://your.endpointNEXT_PUBLIC_OPENPANEL_CLIENT_ID=test-OPENPANEL_CLIENT_SECRET=test\ No newline at end of file+OPENPANEL_CLIENT_SECRET=testdiff --git a/apps/server/package.json b/apps/server/package.jsonindex 93ded7050..000a00db3 100644--- a/apps/server/package.json+++ b/apps/server/package.json@@ -14,7 +14,7 @@"dependencies": {"@hono/sentry": "1.2.2","@hono/zod-openapi": "1.1.5",- "@hono/zod-validator": "0.2.2",+ "@hono/zod-validator": "0.7.6","@logtape/logtape": "1.1.2","@logtape/sentry": "1.1.2","@openstatus/analytics": "workspace:*",@@ -31,7 +31,7 @@"@t3-oss/env-core": "0.13.10","@unkey/api": "2.2.0","@upstash/qstash": "2.6.2",- "hono": "4.5.3",+ "hono": "4.11.3","nanoid": "5.0.7","percentile": "1.6.0","validator": "13.12.0",diff --git a/apps/server/src/routes/v1/check/http/post.test.ts b/apps/server/src/routes/v1/check/http/post.test.tsindex b386bf2f3..4d1f8880e 100644--- a/apps/server/src/routes/v1/check/http/post.test.ts+++ b/apps/server/src/routes/v1/check/http/post.test.ts@@ -81,7 +81,7 @@ test("Create a single check ", async () => {});});-test.todo("Create a multiple check ", async () => {+test("Create a multiple check", async () => {const data = {url: "https://www.openstatus.dev",regions: ["ams", "gru"],@@ -89,16 +89,64 @@ test.todo("Create a multiple check ", async () => {body: '{"hello":"world"}',headers: [{ key: "key", value: "value" }],};- mockFetch.mockReturnValue(- Promise.resolve(- new Response(- '{"status":200,"latency":100,"body":"Hello World","headers":{"Content-Type":"application/json"},"timestamp":1234567890,"timing":{"dnsStart":1,"dnsDone":2,"connectStart":3,"connectDone":4,"tlsHandshakeStart":5,"tlsHandshakeDone":6,"firstByteStart":7,"firstByteDone":8,"transferStart":9,"transferDone":10},"region":"ams"}',- { status: 200, headers: { "content-type": "application/json" } },- ),- ),- );- const res = await app.request("/v1/check", {+ const amsResponse = {+ status: 200,+ latency: 100,+ body: "Hello from ams",+ headers: { "Content-Type": "application/json" },+ timestamp: 1234567890,+ timing: {+ dnsStart: 1,+ dnsDone: 2,+ connectStart: 3,+ connectDone: 4,+ tlsHandshakeStart: 5,+ tlsHandshakeDone: 6,+ firstByteStart: 7,+ firstByteDone: 8,+ transferStart: 9,+ transferDone: 10,+ },+ region: "ams",+ };++ const gruResponse = {+ status: 200,+ latency: 150,+ body: "Hello from gru",+ headers: { "Content-Type": "application/json" },+ timestamp: 1234567891,+ timing: {+ dnsStart: 11,+ dnsDone: 12,+ connectStart: 13,+ connectDone: 14,+ tlsHandshakeStart: 15,+ tlsHandshakeDone: 16,+ firstByteStart: 17,+ firstByteDone: 18,+ transferStart: 19,+ transferDone: 20,+ },+ region: "gru",+ };++ mockFetch+ .mockResolvedValueOnce(+ new Response(JSON.stringify(amsResponse), {+ status: 200,+ headers: { "content-type": "application/json" },+ }),+ )+ .mockResolvedValueOnce(+ new Response(JSON.stringify(gruResponse), {+ status: 200,+ headers: { "content-type": "application/json" },+ }),+ );++ const res = await app.request("/v1/check/http", {method: "POST",headers: {"x-openstatus-key": "1",@@ -124,27 +172,39 @@ test.todo("Create a multiple check ", async () => {transferDone: 10,transferStart: 9,},+ {+ connectDone: 14,+ connectStart: 13,+ dnsDone: 12,+ dnsStart: 11,+ firstByteDone: 18,+ firstByteStart: 17,+ tlsHandshakeDone: 16,+ tlsHandshakeStart: 15,+ transferDone: 20,+ transferStart: 19,+ },],response: {- body: "Hello World",+ body: "Hello from gru",headers: {"Content-Type": "application/json",},- latency: 100,- region: "ams",+ latency: 150,+ region: "gru",status: 200,- timestamp: 1234567890,+ timestamp: 1234567891,timing: {- connectDone: 4,- connectStart: 3,- dnsDone: 2,- dnsStart: 1,- firstByteDone: 8,- firstByteStart: 7,- tlsHandshakeDone: 6,- tlsHandshakeStart: 5,- transferDone: 10,- transferStart: 9,+ connectDone: 14,+ connectStart: 13,+ dnsDone: 12,+ dnsStart: 11,+ firstByteDone: 18,+ firstByteStart: 17,+ tlsHandshakeDone: 16,+ tlsHandshakeStart: 15,+ transferDone: 20,+ transferStart: 19,},},});diff --git a/apps/server/src/routes/v1/incidents/get.test.ts b/apps/server/src/routes/v1/incidents/get.test.tsindex ddd2ead6e..62d068595 100644--- a/apps/server/src/routes/v1/incidents/get.test.ts+++ b/apps/server/src/routes/v1/incidents/get.test.ts@@ -21,6 +21,16 @@ test("no auth key should return 401", async () => {expect(res.status).toBe(401);});+test("invalid incident id should return 400", async () => {+ const res = await app.request("/v1/incident/invalid-id", {+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(400);+});+test("invalid incident id should return 404", async () => {const res = await app.request("/v1/incident/2", {headers: {diff --git a/apps/server/src/routes/v1/incidents/put.test.ts b/apps/server/src/routes/v1/incidents/put.test.tsindex 9fe37cdb0..536134b10 100644--- a/apps/server/src/routes/v1/incidents/put.test.ts+++ b/apps/server/src/routes/v1/incidents/put.test.ts@@ -60,13 +60,40 @@ test("invalid payload should return 400", async () => {});const result = (await res.json()) as Record<string, unknown>;- // expect(result.message).toBe("invalid_date in 'acknowledgedAt': Invalid date");expect(result.message).toBe("invalid_type in 'acknowledgedAt': Invalid input: expected date, received Date",);expect(res.status).toBe(400);});+test("invalid incident id should return 400", async () => {+ const res = await app.request("/v1/incident/invalid-id", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ acknowledgedAt: new Date().toISOString(),+ }),+ });++ expect(res.status).toBe(400);+});++test("empty body should return 400", async () => {+ const res = await app.request("/v1/incident/2", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({}),+ });++ expect(res.status).toBe(400);+});+test("invalid incident id should return 404", async () => {const res = await app.request("/v1/incident/404", {method: "PUT",diff --git a/apps/server/src/routes/v1/incidents/put.ts b/apps/server/src/routes/v1/incidents/put.tsindex bf4be5ffe..4035dceec 100644--- a/apps/server/src/routes/v1/incidents/put.ts+++ b/apps/server/src/routes/v1/incidents/put.ts@@ -25,7 +25,14 @@ const putRoute = createRoute({schema: IncidentSchema.pick({acknowledgedAt: true,resolvedAt: true,- }).partial(),+ })+ .partial()+ .refine(+ (data) =>+ data.acknowledgedAt !== undefined ||+ data.resolvedAt !== undefined,+ "Either acknowledgedAt or resolvedAt must be provided",+ ),},},},diff --git a/apps/server/src/routes/v1/incidents/schema.ts b/apps/server/src/routes/v1/incidents/schema.tsindex d8a2a4776..285b14251 100644--- a/apps/server/src/routes/v1/incidents/schema.ts+++ b/apps/server/src/routes/v1/incidents/schema.ts@@ -4,6 +4,7 @@ export const ParamsSchema = z.object({id: z.string().min(1)+ .regex(/^\d+$/, "ID must be a numeric string").openapi({param: {name: "id",diff --git a/apps/server/src/routes/v1/maintenances/get.test.ts b/apps/server/src/routes/v1/maintenances/get.test.tsindex 1222a1f01..fed0d509a 100644--- a/apps/server/src/routes/v1/maintenances/get.test.ts+++ b/apps/server/src/routes/v1/maintenances/get.test.ts@@ -20,6 +20,16 @@ test("no auth key should return 401", async () => {expect(res.status).toBe(401);});+test("invalid maintenance id should return 400", async () => {+ const res = await app.request("/v1/maintenance/invalid-id", {+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(400);+});+test("invalid maintenance id should return 404", async () => {const res = await app.request("/v1/maintenance/999", {headers: {diff --git a/apps/server/src/routes/v1/maintenances/post.test.ts b/apps/server/src/routes/v1/maintenances/post.test.tsindex 677bd446a..4d08bcd82 100644--- a/apps/server/src/routes/v1/maintenances/post.test.ts+++ b/apps/server/src/routes/v1/maintenances/post.test.ts@@ -2,6 +2,113 @@ import { expect, test } from "bun:test";import { app } from "@/index";import { MaintenanceSchema } from "./schema";+test("create a valid maintenance without monitorIds", async () => {+ const from = new Date();+ const to = new Date(from.getTime() + 3600000); // 1 hour later++ const res = await app.request("/v1/maintenance", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ title: "Another Maintenance",+ message: "Scheduled maintenance without monitors",+ from: from.toISOString(),+ to: to.toISOString(),+ pageId: 1,+ }),+ });++ const result = MaintenanceSchema.safeParse(await res.json());++ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+ expect(result.data?.monitorIds?.length).toBe(0);+});++test("create a maintenance with `from` date after `to` date should return 400", async () => {+ const to = new Date();+ const from = new Date(to.getTime() + 3600000); // from is 1 hour after to++ const res = await app.request("/v1/maintenance", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ title: "Invalid Dates",+ message: "Test message",+ from: from.toISOString(),+ to: to.toISOString(),+ pageId: 1,+ }),+ });++ expect(res.status).toBe(400);+});++test("create a maintenance with non-existent monitorIds should return 400", async () => {+ const from = new Date();+ const to = new Date(from.getTime() + 3600000);++ const res = await app.request("/v1/maintenance", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ title: "Invalid Monitors",+ message: "Test message",+ from: from.toISOString(),+ to: to.toISOString(),+ monitorIds: [9999], // Non-existent monitor ID+ pageId: 1,+ }),+ });++ expect(res.status).toBe(400);+});++test("create a maintenance with non-existent pageId should return 400", async () => {+ const from = new Date();+ const to = new Date(from.getTime() + 3600000);++ const res = await app.request("/v1/maintenance", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ title: "Invalid Page",+ message: "Test message",+ from: from.toISOString(),+ to: to.toISOString(),+ monitorIds: [1],+ pageId: 9999, // Non-existent page ID+ }),+ });++ expect(res.status).toBe(400);+});++test("create a maintenance with empty body should return 400", async () => {+ const res = await app.request("/v1/maintenance", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({}),+ });++ expect(res.status).toBe(400);+});+test("create a valid maintenance", async () => {const from = new Date();const to = new Date(from.getTime() + 3600000); // 1 hour later@@ -21,7 +128,6 @@ test("create a valid maintenance", async () => {pageId: 1,}),});-const result = MaintenanceSchema.safeParse(await res.json());expect(res.status).toBe(200);diff --git a/apps/server/src/routes/v1/maintenances/post.ts b/apps/server/src/routes/v1/maintenances/post.tsindex 09b5c3f54..e4787ac5d 100644--- a/apps/server/src/routes/v1/maintenances/post.ts+++ b/apps/server/src/routes/v1/maintenances/post.ts@@ -70,6 +70,13 @@ export function registerPostMaintenance(api: typeof maintenancesApi) {});}+ if (input.from > input.to) {+ throw new OpenStatusApiError({+ code: "BAD_REQUEST",+ message: "`date.from` cannot be after `date.to`",+ });+ }+const _page = await db.select().from(page)diff --git a/apps/server/src/routes/v1/maintenances/put.test.ts b/apps/server/src/routes/v1/maintenances/put.test.tsindex b6bdce7a3..0d2541ca1 100644--- a/apps/server/src/routes/v1/maintenances/put.test.ts+++ b/apps/server/src/routes/v1/maintenances/put.test.ts@@ -41,6 +41,137 @@ test("update maintenance monitors", async () => {expect(result.data?.monitorIds?.length).toBe(2);});+test("invalid maintenance id should return 400", async () => {+ const res = await app.request("/v1/maintenance/invalid-id", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ title: "Not Found",+ }),+ });++ expect(res.status).toBe(400);+});++test("update only the title", async () => {+ const res = await app.request("/v1/maintenance/1", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ title: "Only Title Updated",+ }),+ });++ const result = MaintenanceSchema.safeParse(await res.json());++ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+ expect(result.data?.title).toBe("Only Title Updated");+});++test("update only the message", async () => {+ const res = await app.request("/v1/maintenance/1", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ message: "Only Message Updated",+ }),+ });++ const result = MaintenanceSchema.safeParse(await res.json());++ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+ expect(result.data?.message).toBe("Only Message Updated");+});++test.todo("update only the dates", async () => {+ const from = new Date();+ const to = new Date(from.getTime() + 7200000); // 2 hours later++ const res = await app.request("/v1/maintenance/1", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ from: from.toISOString(),+ to: to.toISOString(),+ }),+ });++ const result = MaintenanceSchema.safeParse(await res.json());++ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+ expect(result.data?.from).toEqual(from);+ expect(result.data?.to).toEqual(to);+});++test.todo(+ "update maintenance with `from` date after `to` date should return 400",+ async () => {+ const to = new Date();+ const from = new Date(to.getTime() + 3600000); // from is 1 hour after to++ const res = await app.request("/v1/maintenance/1", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ from: from.toISOString(),+ to: to.toISOString(),+ }),+ });++ expect(res.status).toBe(400);+ },+);++test("remove all maintenance monitors", async () => {+ const res = await app.request("/v1/maintenance/1", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({+ monitorIds: [],+ }),+ });++ const result = MaintenanceSchema.safeParse(await res.json());++ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+ expect(result.data?.monitorIds?.length).toBe(0);+});++test.todo("empty body should return 400", async () => {+ const res = await app.request("/v1/maintenance/1", {+ method: "PUT",+ headers: {+ "x-openstatus-key": "1",+ "Content-Type": "application/json",+ },+ body: JSON.stringify({}),+ });++ expect(res.status).toBe(400);+});+test("invalid maintenance id should return 404", async () => {const res = await app.request("/v1/maintenance/999", {method: "PUT",diff --git a/apps/server/src/routes/v1/maintenances/put.ts b/apps/server/src/routes/v1/maintenances/put.tsindex 4018756e5..9c4ea7246 100644--- a/apps/server/src/routes/v1/maintenances/put.ts+++ b/apps/server/src/routes/v1/maintenances/put.ts@@ -101,6 +101,16 @@ export function registerPutMaintenance(api: typeof maintenancesApi) {}}+ const inputFrom = input?.from ?? _maintenance.from;+ const inputTo = input?.to ?? _maintenance?.to;++ if (inputFrom && inputTo && new Date(inputFrom) > new Date(inputTo)) {+ throw new OpenStatusApiError({+ code: "BAD_REQUEST",+ message: "`date.from` cannot be after `date.to`",+ });+ }+const updatedMaintenance = await db.transaction(async (tx) => {const updated = await tx.update(maintenance)diff --git a/apps/server/src/routes/v1/maintenances/schema.ts b/apps/server/src/routes/v1/maintenances/schema.tsindex 6b30a7746..b5a5b30fa 100644--- a/apps/server/src/routes/v1/maintenances/schema.ts+++ b/apps/server/src/routes/v1/maintenances/schema.ts@@ -4,6 +4,7 @@ export const ParamsSchema = z.object({id: z.string().min(1)+ .regex(/^\d+$/, "ID must be a numeric string").openapi({param: {name: "id",@@ -43,6 +44,9 @@ export const MaintenanceSchema = zdescription: "The id of the status page this maintenance belongs to",}),})+ .refine((maintenance) => maintenance.from <= maintenance.to, {+ error: "'from' date must be before 'to' date",+ }).openapi("Maintenance");export type MaintenanceSchema = z.infer<typeof MaintenanceSchema>;diff --git a/apps/server/src/routes/v1/monitors/post.test.ts b/apps/server/src/routes/v1/monitors/post.test.tsindex f3aefcf44..cb3c1a45d 100644--- a/apps/server/src/routes/v1/monitors/post.test.ts+++ b/apps/server/src/routes/v1/monitors/post.test.ts@@ -33,13 +33,12 @@ test("create a valid monitor", async () => {}),});- const result = MonitorSchema.safeParse(await res.json());-expect(res.status).toBe(200);+ const result = MonitorSchema.safeParse(await res.json());expect(result.success).toBe(true);});-test("create a status report with invalid payload should return 400", async () => {+test("create a monitor with invalid payload should return 400", async () => {const res = await app.request("/v1/monitor", {method: "POST",headers: {diff --git a/apps/server/src/routes/v1/monitors/post_http.test.ts b/apps/server/src/routes/v1/monitors/post_http.test.tsindex 107c8ed52..47c030c1a 100644--- a/apps/server/src/routes/v1/monitors/post_http.test.ts+++ b/apps/server/src/routes/v1/monitors/post_http.test.ts@@ -11,18 +11,18 @@ test("create a valid monitor", async () => {"content-type": "application/json",},body: JSON.stringify({+ active: true,+ degradedAfter: 60,+ description: "This is a test",frequency: "10m",- name: "OpenStatus",- description: "OpenStatus website",- regions: ["ams", "gru"],+ name: "Test2",+ regions: ["iad"],request: {- url: "https://www.openstatus.dev",+ url: "https://api.openstatus.dev/health",method: "POST",body: '{"hello":"world"}',headers: { "content-type": "application/json" },},- active: true,- public: true,assertions: [{kind: "statusCode",@@ -31,6 +31,7 @@ test("create a valid monitor", async () => {},{ kind: "header", compare: "not_eq", key: "key", target: "value" },],+ retry: 3,}),});@@ -84,3 +85,368 @@ test("no auth key should return 401", async () => {expect(res.status).toBe(401);});++test("create HTTP monitor with GET method should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "5m",+ name: "GET Monitor",+ description: "Monitor with GET method",+ regions: ["ams"],+ request: {+ url: "https://api.openstatus.dev/health",+ method: "GET",+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with PUT method should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "PUT Monitor",+ description: "Monitor with PUT method",+ regions: ["gru"],+ request: {+ url: "https://api.example.com/resource",+ method: "PUT",+ body: '{"data":"updated"}',+ headers: { authorization: "Bearer token123" },+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with textBody assertion should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Text Body Assertion Monitor",+ description: "Monitor with text body assertion",+ regions: ["ams"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ assertions: [+ {+ kind: "textBody",+ compare: "contains",+ target: "OpenStatus",+ },+ ],+ active: true,+ public: true,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with multiple assertions should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Multi Assertion Monitor",+ description: "Monitor with multiple assertions",+ regions: ["ams", "gru"],+ request: {+ url: "https://api.openstatus.dev",+ method: "GET",+ },+ assertions: [+ {+ kind: "statusCode",+ compare: "eq",+ target: 200,+ },+ {+ kind: "header",+ compare: "contains",+ key: "content-type",+ target: "json",+ },+ {+ kind: "textBody",+ compare: "contains",+ target: "success",+ },+ ],+ active: true,+ public: true,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with timeout and retry configuration should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "HTTP with custom config",+ description: "HTTP monitor with timeout and retry",+ regions: ["ams"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ timeout: 60000,+ retry: 5,+ degradedAfter: 20000,+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with OpenTelemetry configuration should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "HTTP with OTEL",+ description: "HTTP monitor with OpenTelemetry",+ regions: ["ams"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ openTelemetry: {+ endpoint: "https://otel.example.com/v1/traces",+ headers: {+ "x-api-key": "otel-key-123",+ "x-tenant-id": "tenant-456",+ },+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with 30s frequency should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "30s",+ name: "Fast HTTP Check",+ description: "HTTP monitor with 30s frequency",+ regions: ["ams"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with 1h frequency should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "1h",+ name: "Hourly HTTP Check",+ description: "HTTP monitor with 1h frequency",+ regions: ["gru"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor without optional fields should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Minimal HTTP Monitor",+ regions: ["ams"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with PATCH method should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "PATCH Monitor",+ description: "Monitor with PATCH method",+ regions: ["ams"],+ request: {+ url: "https://api.example.com/resource",+ method: "PATCH",+ body: '{"field":"value"}',+ headers: { "content-type": "application/json" },+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with DELETE method should return 200", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "DELETE Monitor",+ description: "Monitor with DELETE method",+ regions: ["ams"],+ request: {+ url: "https://api.example.com/resource/123",+ method: "DELETE",+ headers: { authorization: "Bearer token" },+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create HTTP monitor with invalid URL should return 400", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Invalid URL Monitor",+ regions: ["ams"],+ request: {+ url: "not-a-valid-url",+ method: "GET",+ },+ }),+ });++ expect(res.status).toBe(400);+});++test("create HTTP monitor with deprecated regions should return 400", async () => {+ const res = await app.request("/v1/monitor/http", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Deprecated Regions HTTP",+ regions: ["ams", "hkg", "waw"],+ request: {+ url: "https://www.openstatus.dev",+ method: "GET",+ },+ }),+ });++ expect(res.status).toBe(400);+});diff --git a/apps/server/src/routes/v1/monitors/post_tcp.test.ts b/apps/server/src/routes/v1/monitors/post_tcp.test.tsindex 101d3a3e7..92bf2ba35 100644--- a/apps/server/src/routes/v1/monitors/post_tcp.test.ts+++ b/apps/server/src/routes/v1/monitors/post_tcp.test.ts@@ -68,3 +68,280 @@ test("no auth key should return 401", async () => {expect(res.status).toBe(401);});++test("create TCP monitor with port 80 should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "5m",+ name: "HTTP Port Monitor",+ description: "Monitor port 80",+ regions: ["ams"],+ request: {+ host: "example.com",+ port: 80,+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with custom port should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "1m",+ name: "Custom Port Monitor",+ description: "Monitor custom port 8080",+ regions: ["gru"],+ request: {+ host: "localhost",+ port: 8080,+ },+ active: false,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with timeout and retry configuration should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "TCP with custom config",+ description: "TCP monitor with timeout and retry",+ regions: ["ams"],+ request: {+ host: "openstatus.dev",+ port: 443,+ },+ timeout: 30000,+ retry: 5,+ degradedAfter: 10000,+ active: true,+ public: true,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with OpenTelemetry configuration should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "TCP with OTEL",+ description: "TCP monitor with OpenTelemetry",+ regions: ["ams"],+ request: {+ host: "openstatus.dev",+ port: 443,+ },+ openTelemetry: {+ endpoint: "https://otel.example.com",+ headers: {+ "x-api-key": "test-key",+ },+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with multiple regions should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "30m",+ name: "Multi-region TCP",+ description: "TCP monitor across multiple regions",+ regions: ["ams", "gru", "syd"],+ request: {+ host: "openstatus.dev",+ port: 443,+ },+ active: true,+ public: true,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with 30s frequency should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "30s",+ name: "Fast TCP Check",+ description: "TCP monitor with 30s frequency",+ regions: ["ams"],+ request: {+ host: "openstatus.dev",+ port: 443,+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with 1h frequency should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "1h",+ name: "Hourly TCP Check",+ description: "TCP monitor with 1h frequency",+ regions: ["gru"],+ request: {+ host: "example.com",+ port: 443,+ },+ active: true,+ public: false,+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor without optional fields should return 200", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Minimal TCP Monitor",+ regions: ["ams"],+ request: {+ host: "openstatus.dev",+ port: 443,+ },+ }),+ });++ const result = MonitorSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create TCP monitor with invalid host should return 400", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Invalid TCP Monitor",+ regions: ["ams"],+ request: {+ host: "",+ port: 443,+ },+ }),+ });++ expect(res.status).toBe(400);+});++test("create TCP monitor with invalid port should return 400", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Invalid Port Monitor",+ regions: ["ams"],+ request: {+ host: "openstatus.dev",+ port: "not-a-number",+ },+ }),+ });++ expect(res.status).toBe(400);+});++test("create TCP monitor with deprecated regions should return 400", async () => {+ const res = await app.request("/v1/monitor/tcp", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ frequency: "10m",+ name: "Deprecated Regions TCP",+ regions: ["ams", "hkg", "waw"],+ request: {+ host: "openstatus.dev",+ port: 443,+ },+ }),+ });++ expect(res.status).toBe(400);+});diff --git a/apps/server/src/routes/v1/monitors/results/get.test.ts b/apps/server/src/routes/v1/monitors/results/get.test.tsnew file mode 100644index 000000000..ebe4940b9--- /dev/null+++ b/apps/server/src/routes/v1/monitors/results/get.test.ts@@ -0,0 +1,89 @@+import { expect, test } from "bun:test";++import { app } from "@/index";+import { ResultRun } from "../schema";++test.todo("get monitor result with valid id should return 200", async () => {+ const res = await app.request("/v1/monitor/1/result/1", {+ method: "GET",+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = ResultRun.array().safeParse(json);+ expect(result.success).toBe(true);+});++test("get monitor result with invalid monitor id should return 404", async () => {+ const res = await app.request("/v1/monitor/999999/result/1", {+ method: "GET",+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(404);+});++test("get monitor result with invalid result id should return 404", async () => {+ const res = await app.request("/v1/monitor/1/result/999999", {+ method: "GET",+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(404);+});++test("get monitor result without auth key should return 401", async () => {+ const res = await app.request("/v1/monitor/1/result/1", {+ method: "GET",+ });++ expect(res.status).toBe(401);+});++test("get monitor result from different workspace should return 404", async () => {+ const res = await app.request("/v1/monitor/2/result/1", {+ method: "GET",+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(404);+});++test.todo(+ "get monitor result with valid TCP monitor should return 200",+ async () => {+ const res = await app.request("/v1/monitor/4/result/2", {+ method: "GET",+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = ResultRun.array().safeParse(json);+ expect(result.success).toBe(true);+ },+);++test("get monitor result with non-matching result id should return 404", async () => {+ const res = await app.request("/v1/monitor/1/result/2", {+ method: "GET",+ headers: {+ "x-openstatus-key": "1",+ },+ });++ expect(res.status).toBe(404);+});diff --git a/apps/server/src/routes/v1/monitors/run/post.test.ts b/apps/server/src/routes/v1/monitors/run/post.test.tsnew file mode 100644index 000000000..0f68ed0a9--- /dev/null+++ b/apps/server/src/routes/v1/monitors/run/post.test.ts@@ -0,0 +1,189 @@+import { expect, test } from "bun:test";++import { afterEach, mock } from "bun:test";+import { app } from "@/index";+import { TriggerResult } from "../schema";++const mockFetch = mock();++global.fetch = mockFetch as unknown as typeof fetch;+mock.module("node-fetch", () => mockFetch);++afterEach(() => {+ mockFetch.mockReset();+});++test("run monitor with valid id should return 200", async () => {+ mockFetch.mockReturnValue(+ Promise.resolve(+ new Response(+ JSON.stringify({+ jobType: "http",+ status: 200,+ latency: 100,+ region: "ams",+ timestamp: 1234567890,+ timing: {+ dnsStart: 1,+ dnsDone: 2,+ connectStart: 3,+ connectDone: 4,+ tlsHandshakeStart: 5,+ tlsHandshakeDone: 6,+ firstByteStart: 7,+ firstByteDone: 8,+ transferStart: 9,+ transferDone: 10,+ },+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ ),+ ),+ );++ const res = await app.request("/v1/monitor/1/run", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = TriggerResult.array().safeParse(json);+ expect(result.success).toBe(true);+});++test("run monitor with no-wait parameter should return empty array", async () => {+ const res = await app.request("/v1/monitor/1/run?no-wait=true", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ expect(json).toEqual([]);+});++test("run monitor with invalid id should return 404", async () => {+ const res = await app.request("/v1/monitor/999999/run", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(404);+});++test("run monitor without auth key should return 401", async () => {+ const res = await app.request("/v1/monitor/1/run", {+ method: "POST",+ headers: {+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(401);+});++test("run monitor from different workspace should return 404", async () => {+ const res = await app.request("/v1/monitor/55555/run", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(404);+});++test("run TCP monitor with valid id should return 200", async () => {+ mockFetch.mockReturnValue(+ Promise.resolve(+ new Response(+ JSON.stringify({+ jobType: "tcp",+ latency: 50,+ region: "ams",+ timestamp: 1234567890,+ timing: {+ tcpStart: 1,+ tcpDone: 2,+ },+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ ),+ ),+ );++ const res = await app.request("/v1/monitor/4/run", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = TriggerResult.array().safeParse(json);+ expect(result.success).toBe(true);+ if (result.success && result.data[0]) {+ expect(result.data[0].jobType).toBe("tcp");+ }+});++test.todo(+ "run monitor with multiple regions should return array of results",+ async () => {+ mockFetch.mockReturnValue(+ Promise.resolve(+ new Response(+ JSON.stringify({+ jobType: "http",+ status: 200,+ latency: 100,+ region: "ams",+ timestamp: 1234567890,+ timing: {+ dnsStart: 1,+ dnsDone: 2,+ connectStart: 3,+ connectDone: 4,+ tlsHandshakeStart: 5,+ tlsHandshakeDone: 6,+ firstByteStart: 7,+ firstByteDone: 8,+ transferStart: 9,+ transferDone: 10,+ },+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ ),+ ),+ );++ const res = await app.request("/v1/monitor/5/run", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ expect(Array.isArray(json)).toBe(true);+ },+);diff --git a/apps/server/src/routes/v1/monitors/schema.ts b/apps/server/src/routes/v1/monitors/schema.tsindex 31c35f0b3..86efbeee9 100644--- a/apps/server/src/routes/v1/monitors/schema.ts+++ b/apps/server/src/routes/v1/monitors/schema.ts@@ -375,38 +375,34 @@ const baseRequest = z.object({regions: z.preprocess((val) => {- let regions: Array<unknown> = [];- if (!val) return regions;-+ let parsedRegions: Array<unknown> = [];+ if (!val) return parsedRegions;if (Array.isArray(val)) {- regions = val;+ parsedRegions = val;}if (String(val).length > 0) {- regions = String(val).split(",");+ parsedRegions = String(val).split(",");}-- const deprecatedRegions = regions.filter((r) => {- return !AVAILABLE_REGIONS.includes(- r as (typeof AVAILABLE_REGIONS)[number],- );- });-- if (deprecatedRegions.length > 0) {- throw new ZodError([- {- code: "custom",- path: ["regions"],- message: `Deprecated regions are not allowed: ${deprecatedRegions.join(- ", ",- )}`,- },- ]);- }-- return regions;+ return parsedRegions;},z.array(z.enum(monitorRegions)),)+ .superRefine((regions, ctx) => {+ const deprecatedRegions = regions.filter((r) => {+ return !AVAILABLE_REGIONS.includes(+ r as (typeof AVAILABLE_REGIONS)[number],+ );+ });+ if (deprecatedRegions.length > 0) {+ ctx.addIssue({+ code: "custom",+ path: ["regions"],+ message: `Deprecated regions are not allowed: ${deprecatedRegions.join(+ ", ",+ )}`,+ });+ }+ }).prefault([]).openapi({example: ["ams"],@@ -455,10 +451,13 @@ const httpRequestSchema = z.object({});const tcpRequestSchema = z.object({- host: z.string().openapi({- examples: ["example.com", "localhost"],- description: "Host to connect to",- }),+ host: z+ .string()+ .min(1)+ .openapi({+ examples: ["example.com", "localhost"],+ description: "Host to connect to",+ }),port: z.number().openapi({description: "Port to connect to",examples: [80, 443, 1337],diff --git a/apps/server/src/routes/v1/monitors/trigger/post.test.ts b/apps/server/src/routes/v1/monitors/trigger/post.test.tsnew file mode 100644index 000000000..881e46148--- /dev/null+++ b/apps/server/src/routes/v1/monitors/trigger/post.test.ts@@ -0,0 +1,185 @@+import { expect, test } from "bun:test";++import { afterEach, mock } from "bun:test";+import { app } from "@/index";+import { TriggerSchema } from "./schema";++const mockFetch = mock();++global.fetch = mockFetch as unknown as typeof fetch;+mock.module("node-fetch", () => mockFetch);++afterEach(() => {+ mockFetch.mockReset();+});++test("trigger monitor with valid id should return 200", async () => {+ mockFetch.mockReturnValue(+ Promise.resolve(+ new Response(+ JSON.stringify({+ jobType: "http",+ status: 200,+ latency: 100,+ region: "ams",+ timestamp: 1234567890,+ timing: {+ dnsStart: 1,+ dnsDone: 2,+ connectStart: 3,+ connectDone: 4,+ tlsHandshakeStart: 5,+ tlsHandshakeDone: 6,+ firstByteStart: 7,+ firstByteDone: 8,+ transferStart: 9,+ transferDone: 10,+ },+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ ),+ ),+ );++ const res = await app.request("/v1/monitor/1/trigger", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = TriggerSchema.safeParse(json);+ expect(result.success).toBe(true);+ expect(json.resultId).toBeDefined();+ expect(typeof json.resultId).toBe("number");+});++test("trigger monitor with invalid id should return 404", async () => {+ const res = await app.request("/v1/monitor/999999/trigger", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(404);+});++test("trigger monitor without auth key should return 401", async () => {+ const res = await app.request("/v1/monitor/1/trigger", {+ method: "POST",+ headers: {+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(401);+});++test("trigger monitor from different workspace should return 404", async () => {+ const res = await app.request("/v1/monitor/99/trigger", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });+ expect(res.status).toBe(404);+});++test("trigger deleted monitor should return 404", async () => {+ const res = await app.request("/v1/monitor/3/trigger", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(404);+});++test("trigger TCP monitor with valid id should return 200", async () => {+ mockFetch.mockReturnValue(+ Promise.resolve(+ new Response(+ JSON.stringify({+ jobType: "tcp",+ latency: 50,+ region: "ams",+ timestamp: 1234567890,+ timing: {+ tcpStart: 1,+ tcpDone: 2,+ },+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ ),+ ),+ );++ const res = await app.request("/v1/monitor/4/trigger", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = TriggerSchema.safeParse(json);+ expect(result.success).toBe(true);+ expect(json.resultId).toBeDefined();+ expect(typeof json.resultId).toBe("number");+});++test("trigger monitor with multiple regions should return result id", async () => {+ mockFetch.mockReturnValue(+ Promise.resolve(+ new Response(+ JSON.stringify({+ jobType: "http",+ status: 200,+ latency: 100,+ region: "ams",+ timestamp: 1234567890,+ timing: {+ dnsStart: 1,+ dnsDone: 2,+ connectStart: 3,+ connectDone: 4,+ tlsHandshakeStart: 5,+ tlsHandshakeDone: 6,+ firstByteStart: 7,+ firstByteDone: 8,+ transferStart: 9,+ transferDone: 10,+ },+ }),+ { status: 200, headers: { "content-type": "application/json" } },+ ),+ ),+ );++ const res = await app.request("/v1/monitor/1/trigger", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = TriggerSchema.safeParse(json);+ expect(result.success).toBe(true);+ expect(json.resultId).toBeDefined();+});diff --git a/apps/server/src/routes/v1/statusReportUpdates/post.test.ts b/apps/server/src/routes/v1/statusReportUpdates/post.test.tsindex 693f2b911..233dc48dc 100644--- a/apps/server/src/routes/v1/statusReportUpdates/post.test.ts+++ b/apps/server/src/routes/v1/statusReportUpdates/post.test.ts@@ -50,3 +50,218 @@ test("no auth key should return 401", async () => {expect(res.status).toBe(401);});++test("create status report update with identified status should return 200", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "identified",+ date: new Date().toISOString(),+ message: "We have identified the root cause",+ statusReportId: 1,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update with monitoring status should return 200", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ date: new Date().toISOString(),+ message: "The fix has been deployed and we are monitoring",+ statusReportId: 1,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update with resolved status should return 200", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "resolved",+ date: new Date().toISOString(),+ message: "Issue has been fully resolved",+ statusReportId: 1,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update without date should use default", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "investigating",+ message: "Update without explicit date",+ statusReportId: 1,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update with past date should return 200", async () => {+ const pastDate = new Date();+ pastDate.setTime(pastDate.getTime() - 24 * 60 * 60 * 1000);++ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "investigating",+ date: pastDate.toISOString(),+ message: "Update with past date",+ statusReportId: 1,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update with long message should return 200", async () => {+ const longMessage =+ "This is a very detailed status update message that provides comprehensive information about the incident, including what happened, what is being done to resolve it, and what measures are being taken to prevent similar issues in the future. We apologize for any inconvenience this may have caused.";++ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ date: new Date().toISOString(),+ message: longMessage,+ statusReportId: 1,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update with different status report ID should return 200", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "investigating",+ date: new Date().toISOString(),+ message: "Update for different report",+ statusReportId: 2,+ }),+ });++ const result = StatusReportUpdateSchema.safeParse(await res.json());+ expect(res.status).toBe(200);+ expect(result.success).toBe(true);+});++test("create status report update with invalid status should return 400", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "invalid_status",+ date: new Date().toISOString(),+ message: "Test message",+ statusReportId: 1,+ }),+ });++ expect(res.status).toBe(400);+});++test("create status report update without message should return 400", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "investigating",+ date: new Date().toISOString(),+ statusReportId: 1,+ }),+ });++ expect(res.status).toBe(400);+});++test("create status report update without statusReportId should return 400", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "investigating",+ date: new Date().toISOString(),+ message: "Test message",+ }),+ });++ expect(res.status).toBe(400);+});++test("create status report update with empty message should return 400", async () => {+ const res = await app.request("/v1/status_report_update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "investigating",+ date: new Date().toISOString(),+ message: "",+ statusReportId: 1,+ }),+ });++ expect(res.status).toBe(400);+});diff --git a/apps/server/src/routes/v1/statusReportUpdates/schema.ts b/apps/server/src/routes/v1/statusReportUpdates/schema.tsindex 8b012bbbe..47c75b2d4 100644--- a/apps/server/src/routes/v1/statusReportUpdates/schema.ts+++ b/apps/server/src/routes/v1/statusReportUpdates/schema.ts@@ -25,7 +25,7 @@ export const StatusReportUpdateSchema = zdate: z.coerce.date().prefault(new Date()).openapi({description: "The date of the update in ISO8601 format",}),- message: z.string().openapi({+ message: z.string().min(1).openapi({description: "The message of the update",}),statusReportId: z.number().openapi({diff --git a/apps/server/src/routes/v1/statusReports/update/post.test.ts b/apps/server/src/routes/v1/statusReports/update/post.test.tsnew file mode 100644index 000000000..17ad4bb8f--- /dev/null+++ b/apps/server/src/routes/v1/statusReports/update/post.test.ts@@ -0,0 +1,194 @@+import { expect, test } from "bun:test";++import { app } from "@/index";+import { StatusReportSchema } from "../schema";++test("create status report update with valid data should return 200", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ message: "The issue has been resolved and we are monitoring",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = StatusReportSchema.safeParse(json);+ expect(result.success).toBe(true);+});++test("create status report update with different status should return 200", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "identified",+ message: "We have identified the issue",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = StatusReportSchema.safeParse(json);+ expect(result.success).toBe(true);+});++test("create status report update with invalid status report id should return 404", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/999999/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ message: "The issue has been resolved and we are monitoring",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(404);+});++test("create status report update with invalid status should return 400", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "invalid_status",+ message: "Test message",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(400);+});++test("create status report update without auth key should return 401", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ message: "Test message",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(401);+});++test("create status report update from different workspace should return 404", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "2",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ message: "Test message",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(404);+});++test("create status report update without message should return 400", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(400);+});++test("create status report update with resolved status should return 200", async () => {+ const date = new Date();+ date.setMilliseconds(0);++ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "resolved",+ message: "Issue has been fully resolved",+ date: date.toISOString(),+ }),+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = StatusReportSchema.safeParse(json);+ expect(result.success).toBe(true);+});++test("create status report update without date should use default", async () => {+ const res = await app.request("/v1/status_report/1/update", {+ method: "POST",+ headers: {+ "x-openstatus-key": "1",+ "content-type": "application/json",+ },+ body: JSON.stringify({+ status: "monitoring",+ message: "Test message without explicit date",+ }),+ });++ expect(res.status).toBe(200);++ const json = await res.json();+ const result = StatusReportSchema.safeParse(json);+ expect(result.success).toBe(true);+});diff --git a/apps/server/src/routes/v1/statusReports/update/post.ts b/apps/server/src/routes/v1/statusReports/update/post.tsindex 7f95c8b29..7c7813f76 100644--- a/apps/server/src/routes/v1/statusReports/update/post.ts+++ b/apps/server/src/routes/v1/statusReports/update/post.ts@@ -28,7 +28,10 @@ const postRouteUpdate = createRoute({description: "the status report update",content: {"application/json": {- schema: StatusReportUpdateSchema.omit({ id: true }),+ schema: StatusReportUpdateSchema.omit({+ id: true,+ statusReportId: true,+ }),},},},@@ -55,7 +58,7 @@ export function registerStatusReportUpdateRoutes(api: typeof statusReportsApi) {const _statusReport = await db.update(statusReport)- .set({ status: input.status })+ .set({ status: input.status, updatedAt: new Date() }).where(and(eq(statusReport.id, Number(id)),@@ -83,14 +86,6 @@ export function registerStatusReportUpdateRoutes(api: typeof statusReportsApi) {.returning().get();- await db- .update(statusReport)- .set({- status: input.status,- updatedAt: new Date(),- })- .where(eq(statusReport.id, _statusReport.id));-if (limits.notifications && _statusReport.pageId) {const _statusReportWithRelations = await db.query.statusReport.findFirst({where: eq(statusReport.id, Number(id)),@@ -130,7 +125,31 @@ export function registerStatusReportUpdateRoutes(api: typeof statusReportsApi) {}}- const data = StatusReportSchema.parse(_statusReportUpdate);+ // Query the full status report with all its relationships+ const fullStatusReport = await db.query.statusReport.findFirst({+ where: eq(statusReport.id, Number(id)),+ with: {+ statusReportUpdates: true,+ monitorsToStatusReports: true,+ },+ });++ if (!fullStatusReport) {+ throw new OpenStatusApiError({+ code: "NOT_FOUND",+ message: `Status Report ${id} not found`,+ });+ }++ const data = StatusReportSchema.parse({+ ...fullStatusReport,+ statusReportUpdateIds: fullStatusReport.statusReportUpdates.map(+ (u) => u.id,+ ),+ monitorIds: fullStatusReport.monitorsToStatusReports.map(+ (m) => m.monitorId,+ ),+ });return c.json(data, 200);});diff --git a/apps/server/src/routes/v1/utils.ts b/apps/server/src/routes/v1/utils.tsindex 6872eb5b9..81d4c2353 100644--- a/apps/server/src/routes/v1/utils.ts+++ b/apps/server/src/routes/v1/utils.ts@@ -9,7 +9,12 @@ export const isoDate = z.preprocess((val) => {return new Date().toISOString();} catch (_e) {throw new ZodError([- { code: "invalid_date", message: "Invalid date", path: [] },+ {+ code: "invalid_type",+ message: "Invalid date",+ expected: "string",+ path: [],+ },]);}}, z.string());diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 5af7669d1..e4e7c2aba 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -448,13 +448,13 @@ importers:dependencies:'@hono/sentry':specifier: 1.2.2- version: 1.2.2([email protected])+ version: 1.2.2([email protected])'@hono/zod-openapi':specifier: 1.1.5- version: 1.1.5([email protected])([email protected])+ version: 1.1.5([email protected])([email protected])'@hono/zod-validator':- specifier: 0.2.2- version: 0.2.2([email protected])([email protected])+ specifier: 0.7.6+ version: 0.7.6([email protected])([email protected])'@logtape/logtape':specifier: 1.1.2version: 1.1.2@@ -493,7 +493,7 @@ importers:version: link:../../packages/utils'@scalar/hono-api-reference':specifier: 0.8.5- version: 0.8.5([email protected])+ version: 0.8.5([email protected])'@t3-oss/env-core':specifier: 0.13.10version: 0.13.10([email protected])([email protected])@@ -504,8 +504,8 @@ importers:specifier: 2.6.2version: 2.6.2hono:- specifier: 4.5.3- version: 4.5.3+ specifier: 4.11.3+ version: 4.11.3nanoid:specifier: 5.0.7version: 5.0.7@@ -8205,6 +8205,10 @@ packages:resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==}+ resolution: {integrity: sha512-PmQi306+M/ct/m5s66Hrg+adPnkD5jiO6IjA7WhWw0gSBSo1EcRegwuI1deZ+wd5pzCGynCcn2DprnE4/yEV4w==}+ engines: {node: '>=16.9.0'}+resolution: {integrity: sha512-r26WwwbKD3BAYdfB294knNnegNda7VfV1tVn66D9Kvl9WQTdrR+5eKdoeaQNHQcC3Gr0KBikzAtjd6VsRGVSaw==}engines: {node: '>=16.0.0'}@@ -12798,16 +12802,21 @@ snapshots:protobufjs: 7.5.4yargs: 17.7.2+ '@hono/[email protected]([email protected])':+ dependencies:+ hono: 4.11.3+ toucan-js: 4.1.1+'@hono/[email protected]([email protected])':dependencies:hono: 4.5.3toucan-js: 4.1.1dependencies:'@asteasolutions/zod-to-openapi': 8.2.0([email protected])- '@hono/zod-validator': 0.7.6([email protected])([email protected])- hono: 4.5.3+ '@hono/zod-validator': 0.7.6([email protected])([email protected])+ hono: 4.11.3openapi3-ts: 4.5.0zod: 4.1.13@@ -12816,9 +12825,9 @@ snapshots:hono: 4.5.3zod: 4.1.13dependencies:- hono: 4.5.3+ hono: 4.11.3zod: 4.1.13'@hookform/[email protected](@types/[email protected])([email protected]([email protected]))([email protected])':@@ -15142,10 +15151,10 @@ snapshots:dependencies:'@scalar/types': 0.1.11- '@scalar/[email protected]([email protected])':+ '@scalar/[email protected]([email protected])':dependencies:'@scalar/core': 0.2.11- hono: 4.5.3+ hono: 4.11.3'@scalar/[email protected]':dependencies:@@ -18263,6 +18272,8 @@ snapshots:dependencies:react-is: 16.13.1+ [email protected]: {}+