Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import crypto from "node:crypto";
import { and, db, eq, or, sql } from "@openstatus/db";
import {
auditLog,
incident,
incidentEvent,
selectWorkspaceSchema,
type Workspace,
workspace as workspaceTable,
} from "@openstatus/db/src/schema";
import { declareIncident } from "@openstatus/services/incident";
import { Hono } from "hono";
import { beforeEach, describe, expect, test } from "vitest";
import { slackTestState } from "@/libs/test/doubles/slack-test-state";
import {
TEST_SIGNING_SECRET as SIGNING_SECRET,
withSlackConfig,
} from "@/libs/test/slack-config";
import { handleSlackCommand } from "./commands";
import type { SlackEnv } from "./config";
import { verifySlackSignature } from "./verify";
function createTestApp() {
const app = withSlackConfig(new Hono<SlackEnv>());
app.post("/slack/commands", verifySlackSignature, handleSlackCommand);
return app;
}
function post(
app: ReturnType<typeof createTestApp>,
text: string,
user: string,
channelId = "C1",
extra: Record<string, string> = {},
) {
const body = new URLSearchParams({
text,
team_id: "T_KNOWN",
user_id: user,
channel_id: channelId,
...extra,
}).toString();
const timestamp = Math.floor(Date.now() / 1000);
const sig = crypto
.createHmac("sha256", SIGNING_SECRET)
.update(`v0:${timestamp}:${body}`)
.digest("hex");
return app.request("/slack/commands", {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
"x-slack-request-timestamp": String(timestamp),
"x-slack-signature": `v0=${sig}`,
},
body,
});
}
describe("handleSlackCommand (members only)", () => {
const app = createTestApp();
beforeEach(() => {
slackTestState.calls = [];
slackTestState.resolveWorkspace = (teamId: string) =>
teamId === "T_KNOWN"
? Promise.resolve({
workspace: { id: 1, limits: { "slack-agent": true } },
botToken: "xoxb-test",
botUserId: "UBOT",
})
: Promise.resolve(null);
});
test("`incident declare` without a title opens the form", async () => {
slackTestState.usersInfoImpl = () =>
Promise.resolve({
ok: true,
user: { profile: { email: "[email protected]" } },
});
const res = await post(app, "incident declare", "U_OWNER", "C_HERE", {
trigger_id: "trig-cmd",
});
expect(res.status).toBe(200);
const open = slackTestState.calls.find((c) => c.method === "views.open");
expect(open?.args.trigger_id).toBe("trig-cmd");
const view = open?.args.view as Record<string, unknown>;
expect(view.callback_id).toBe("declare_incident");
expect(view.private_metadata).toBe(JSON.stringify({ channelId: "C_HERE" }));
});
test("`incident declare` in an unconnected workspace says so", async () => {
const res = await post(app, "incident declare", "U_OWNER", "C_HERE", {
trigger_id: "trig-cmd",
team_id: "T_UNKNOWN",
});
const json = (await res.json()) as { text: string };
expect(json.text).toContain("isn't connected");
expect(slackTestState.calls.some((c) => c.method === "views.open")).toBe(
false,
);
});
test("help needs no link", async () => {
const res = await post(app, "help", `U_${crypto.randomUUID()}`);
const json = (await res.json()) as { text: string };
expect(json.text).toContain("/openstatus subscribe");
});
test("no argument shows help", async () => {
const res = await post(app, "", `U_${crypto.randomUUID()}`);
const json = (await res.json()) as { text: string };
expect(json.text).toContain("/openstatus subscribe");
});
test("an unlinked user gets the link card instead of running the command", async () => {
slackTestState.usersInfoImpl = () =>
Promise.resolve({ ok: true, user: { profile: {} } });
const res = await post(app, "subscriptions", `U_${crypto.randomUUID()}`);
const json = (await res.json()) as {
text: string;
blocks?: { type: string }[];
};
expect(json.text).toContain("Link your openstatus account");
expect(json.blocks?.some((b) => b.type === "actions")).toBe(true);
});
test("a linked member runs the command", async () => {
slackTestState.usersInfoImpl = () =>
Promise.resolve({
ok: true,
user: { profile: { email: "[email protected]" } },
});
const res = await post(app, "subscriptions", `U_${crypto.randomUUID()}`);
const json = (await res.json()) as { text: string; blocks?: unknown };
// The `subscriptions` reply itself, not the link card or the error text.
expect(json.text).toContain("subscribed to");
expect(json.blocks).toBeUndefined();
});
});
describe("/openstatus incident", () => {
const app = createTestApp();
const redisStore = (globalThis as Record<string, unknown>)
.__testRedisStore as Map<string, string>;
let workspace: Workspace;
beforeEach(async () => {
slackTestState.calls = [];
slackTestState.usersInfoImpl = () =>
Promise.resolve({
ok: true,
user: { profile: { email: "[email protected]" } },
});
workspace = selectWorkspaceSchema.parse(
await db.query.workspace.findFirst({ where: eq(workspaceTable.id, 1) }),
);
slackTestState.resolveWorkspace = (teamId: string) =>
teamId === "T_KNOWN"
? Promise.resolve({
workspace: {
...workspace,
limits: { ...workspace.limits, "slack-agent": true },
},
botToken: "xoxb-test",
botUserId: "UBOT",
})
: Promise.resolve(null);
});
test("declare posts an approval card instead of declaring", async () => {
redisStore.clear();
const res = await post(
app,
"incident declare Checkout down --sev critical",
`U_${crypto.randomUUID()}`,
);
const json = (await res.json()) as { text: string };
expect(json.text).toContain("approval card");
const card = slackTestState.calls.find(
(c) => c.method === "update" && Array.isArray(c.args.blocks),
);
expect(card).toBeDefined();
const pending = [...redisStore.entries()].find(([key]) =>
key.startsWith("slack:action:"),
);
expect(pending?.[1]).toContain("declare_incident");
expect(pending?.[1]).toContain("critical");
});
test("note in a bound channel lands on the timeline", async () => {
const channelId = `C_INC_${crypto.randomUUID()}`;
const created = await declareIncident({
ctx: { workspace, actor: { type: "system", job: "test" } },
input: { title: "Bound", severity: "minor" },
});
await db
.update(incident)
.set({ slackTeamId: "T_KNOWN", slackChannelId: channelId })
.where(eq(incident.id, created.id));
try {
const res = await post(
app,
"incident note rolled back the deploy",
`U_${crypto.randomUUID()}`,
channelId,
);
const json = (await res.json()) as { text: string };
expect(json.text).toContain("Added to the timeline");
const events = await db
.select()
.from(incidentEvent)
.where(eq(incidentEvent.incidentId, created.id))
.all();
const note = events.find((e) => e.message === "rolled back the deploy");
expect(note?.source).toBe("slack");
expect(note?.sourceRef).toBeNull();
} finally {
await db
.delete(auditLog)
.where(
and(
eq(auditLog.workspaceId, workspace.id),
or(
and(
eq(auditLog.entityType, "incident"),
eq(auditLog.entityId, String(created.id)),
),
and(
eq(auditLog.action, "incident_event.create"),
sql`json_extract(${auditLog.metadata}, '$.incidentId') = ${created.id}`,
),
),
),
);
await db
.delete(incidentEvent)
.where(eq(incidentEvent.incidentId, created.id));
await db.delete(incident).where(eq(incident.id, created.id));
}
});
test("note outside an incident channel explains where to run it", async () => {
const res = await post(
app,
"incident note hello",
`U_${crypto.randomUUID()}`,
);
const json = (await res.json()) as { text: string };
expect(json.text).toContain("incident's channel");
});
});