Notification routing rules, per-browser push wishes, escalation of unacknowledged alerts
- Routing: rules pick channels by kind, severity and server tags (first match wins, none = nobody); mixed batches split per route; recoveries follow their alert; quiet-hours digest keeps each notification's audience - Push: each subscribed browser can ask for a minimum severity and some kinds - Escalation: up to three timed steps re-notify alerts nobody has acknowledged, through chosen channels and an optional extra email; an acknowledgement stops them - Fix ntfy: titles with an em dash made every ntfy send fail (header not Latin-1); now RFC 2047 encoded Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
9caa414829
commit
43fc5e0272
21 files changed
+4769
-55
No files matched your search
@@ -0,0 +1,450 @@
|
||||
/**
|
||||
* Who hears what (routing rules and browsers' wishes) and escalation of alerts nobody has acknowledged.
|
||||
*
|
||||
* Run with: npm test --workspace server
|
||||
*/
|
||||
import { test, describe, before, after } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
import { createServer, type Server } from "node:http";
|
||||
import { mkdtempSync, rmSync } from "node:fs";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
import type { AddressInfo } from "node:net";
|
||||
|
||||
const dir = mkdtempSync(join(tmpdir(), "hm-routing-"));
|
||||
process.env.DATABASE_PATH = join(dir, "test.sqlite");
|
||||
process.env.SESSION_DIR = join(dir, "sessions");
|
||||
process.env.CREDENTIALS_ENCRYPTION_KEY = "ab".repeat(32);
|
||||
process.env.HEALTH_STARTUP_GRACE_MS = "0";
|
||||
|
||||
const express = (await import("express")).default;
|
||||
const { db } = await import("../src/db/client.js");
|
||||
const { users, servers, pushSubscriptions, alertIncidents, auditLog, notificationQueue } = await import("../src/db/schema.js");
|
||||
const { runMigrations } = await import("../src/db/migrate.js");
|
||||
const { ruleMatches, firstMatchingRule, pushAccepts, metaOfConditionKey } = await import("../src/services/notifyRouting.js");
|
||||
const { dueEscalations, runEscalation } = await import("../src/services/escalation.js");
|
||||
const { audienceFor, notifyHealthIssues, notifyHealthRecovered, flushQuietHoursQueue, notify } = await import("../src/services/notify.js");
|
||||
const { updateSettings } = await import("../src/services/settingsStore.js");
|
||||
const { diffConditions } = await import("../src/services/healthMonitor.js");
|
||||
const { getAlerts, invalidateAlertsCache } = await import("../src/services/alerts.js");
|
||||
const { setAck } = await import("../src/services/alertAcks.js");
|
||||
const { settingsRouter } = await import("../src/routes/settings.js");
|
||||
const { eq } = await import("drizzle-orm");
|
||||
|
||||
await runMigrations();
|
||||
|
||||
type Rule = import("../src/services/notifyRouting.js").RoutingRule;
|
||||
const rule = (extra: Partial<Rule>): Rule => ({ id: "r", name: "rule", enabled: true, categories: [], minSeverity: null, tags: [], channels: [], ...extra });
|
||||
|
||||
describe("routing rules", () => {
|
||||
test("a rule matches on kind, severity and the server's tags; asking about something the notification doesn't say never matches", () => {
|
||||
assert.equal(ruleMatches(rule({}), {}), true, "a rule that asks nothing matches everything");
|
||||
assert.equal(ruleMatches(rule({ categories: ["disk"] }), { category: "disk" }), true);
|
||||
assert.equal(ruleMatches(rule({ categories: ["disk"] }), { category: "offline" }), false);
|
||||
assert.equal(ruleMatches(rule({ categories: ["disk"] }), {}), false, "no kind to compare");
|
||||
assert.equal(ruleMatches(rule({ minSeverity: "critical" }), { severity: "warning" }), false);
|
||||
assert.equal(ruleMatches(rule({ minSeverity: "critical" }), { severity: "critical" }), true);
|
||||
assert.equal(ruleMatches(rule({ minSeverity: "warning" }), { severity: "critical" }), true);
|
||||
assert.equal(ruleMatches(rule({ tags: ["prod"] }), { tags: ["Prod", "db"] }), true, "tags compare without regard to case");
|
||||
assert.equal(ruleMatches(rule({ tags: ["prod"] }), { tags: ["lab"] }), false);
|
||||
assert.equal(ruleMatches(rule({ tags: ["prod"] }), {}), false);
|
||||
assert.equal(ruleMatches(rule({ enabled: false }), {}), false);
|
||||
});
|
||||
|
||||
test("the first rule that matches decides; none matching is no decision", () => {
|
||||
const rules = [rule({ id: "a", categories: ["disk"], channels: ["ntfy"] }), rule({ id: "b", minSeverity: "critical", channels: ["gotify", "webPush"] }), rule({ id: "c", channels: [] })];
|
||||
assert.equal(firstMatchingRule(rules, { category: "disk", severity: "critical" })!.id, "a", "order matters");
|
||||
assert.equal(firstMatchingRule(rules, { category: "offline", severity: "critical" })!.id, "b");
|
||||
assert.equal(firstMatchingRule(rules, { category: "offline", severity: "warning" })!.id, "c");
|
||||
assert.equal(firstMatchingRule([rules[0]], { category: "offline" }), null);
|
||||
});
|
||||
|
||||
test("a problem's key says what kind it is and which server", () => {
|
||||
assert.deepEqual(metaOfConditionKey("offline:server:7", "critical"), { category: "offline", severity: "critical", serverId: 7 });
|
||||
assert.deepEqual(metaOfConditionKey("disk:server:7:/data"), { category: "disk", severity: "warning", serverId: 7 });
|
||||
assert.deepEqual(metaOfConditionKey("failed-units:server:2"), { category: "services", severity: "warning", serverId: 2 });
|
||||
assert.deepEqual(metaOfConditionKey("disk:proxmox:3:local"), { category: "disk", severity: "warning", serverId: null });
|
||||
assert.deepEqual(metaOfConditionKey("automation:semaphore:1:5"), { category: "automation", severity: "warning", serverId: null });
|
||||
});
|
||||
|
||||
test("a browser's wishes: a floor on severity and a list of kinds; what a notification doesn't say can't exclude it", () => {
|
||||
assert.equal(pushAccepts({ minSeverity: null, categories: null }, { category: "disk", severity: "warning" }), true);
|
||||
assert.equal(pushAccepts({ minSeverity: "critical", categories: null }, { severity: "warning" }), false);
|
||||
assert.equal(pushAccepts({ minSeverity: "critical", categories: null }, { severity: "critical" }), true);
|
||||
assert.equal(pushAccepts({ minSeverity: null, categories: JSON.stringify(["offline", "disk"]) }, { category: "backup" }), false);
|
||||
assert.equal(pushAccepts({ minSeverity: null, categories: JSON.stringify(["offline", "disk"]) }, { category: "disk" }), true);
|
||||
assert.equal(pushAccepts({ minSeverity: "critical", categories: JSON.stringify(["disk"]) }, undefined), true, "no meta, no judgement");
|
||||
assert.equal(pushAccepts({ minSeverity: null, categories: JSON.stringify(["disk"]) }, { severity: "warning" }), true, "no kind, no judgement");
|
||||
assert.equal(pushAccepts({ minSeverity: null, categories: "garbage" }, { category: "backup" }), true, "unreadable wishes are no wishes");
|
||||
});
|
||||
});
|
||||
|
||||
describe("what the health monitor remembers", () => {
|
||||
test("a recovery carries how bad the problem was, so it is routed like the alert was", () => {
|
||||
const first = diffConditions({}, [
|
||||
{ key: "offline:server:1", source: "server", message: "a is down", severity: "critical" },
|
||||
{ key: "disk:server:1:/", source: "server", message: "a disk" },
|
||||
]);
|
||||
assert.equal(first.next["offline:server:1"].severity, "critical");
|
||||
assert.equal(first.next["disk:server:1:/"].severity, undefined);
|
||||
const gone = diffConditions(first.next, []);
|
||||
assert.deepEqual(gone.resolved.map((r) => [r.key, r.severity]).sort(), [["disk:server:1:/", undefined], ["offline:server:1", "critical"]]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("escalation: what is due", () => {
|
||||
const steps = [
|
||||
{ afterMinutes: 30, minSeverity: "warning" as const, channels: ["webPush" as const], extraEmail: "", evenInQuietHours: false },
|
||||
{ afterMinutes: 120, minSeverity: "critical" as const, channels: ["smtp" as const], extraEmail: "neighbour@example.com", evenInQuietHours: true },
|
||||
];
|
||||
const now = new Date("2026-10-18T12:00:00Z");
|
||||
const ago = (min: number) => new Date(now.getTime() - min * 60_000).toISOString();
|
||||
const alert = (id: string, severity: "critical" | "warning" | "info", extra: Record<string, unknown> = {}) => ({ id, severity, silenced: false, message: id, source: "Server", ...extra });
|
||||
const run = (alerts: ReturnType<typeof alert>[], incidents: Record<string, { openedAt: string; escalatedStep?: number }>, acknowledged: string[] = []) =>
|
||||
dueEscalations({
|
||||
alerts,
|
||||
acknowledged: new Set(acknowledged),
|
||||
incidents: new Map(Object.entries(incidents).map(([k, v], i) => [k, { id: i + 1, openedAt: v.openedAt, escalatedStep: v.escalatedStep ?? 0 }])),
|
||||
steps,
|
||||
now,
|
||||
}).map((d) => [d.alert.id, d.step]);
|
||||
|
||||
test("a step is due once the alert has been up that long; nothing before", () => {
|
||||
assert.deepEqual(run([alert("a", "warning")], { a: { openedAt: ago(29) } }), []);
|
||||
assert.deepEqual(run([alert("a", "warning")], { a: { openedAt: ago(31) } }), [["a", 1]]);
|
||||
});
|
||||
|
||||
test("a step is sent once, and a neglected alert is told about one step at a time", () => {
|
||||
assert.deepEqual(run([alert("a", "critical")], { a: { openedAt: ago(200), escalatedStep: 0 } }), [["a", 1]], "step 1 first, though step 2 is due too");
|
||||
assert.deepEqual(run([alert("a", "critical")], { a: { openedAt: ago(200), escalatedStep: 1 } }), [["a", 2]]);
|
||||
assert.deepEqual(run([alert("a", "critical")], { a: { openedAt: ago(200), escalatedStep: 2 } }), []);
|
||||
});
|
||||
|
||||
test("a step that asks for a worse severity is passed over, and later ones still apply", () => {
|
||||
// a warning is never bad enough for step 2, so it ends after step 1
|
||||
assert.deepEqual(run([alert("w", "warning")], { w: { openedAt: ago(500), escalatedStep: 1 } }), []);
|
||||
const critOnlyFirst = [{ ...steps[0], minSeverity: "critical" as const }, { ...steps[1], minSeverity: "warning" as const }];
|
||||
const due = dueEscalations({ alerts: [alert("w", "warning")], acknowledged: new Set(), incidents: new Map([["w", { id: 1, openedAt: ago(500), escalatedStep: 0 }]]), steps: critOnlyFirst, now });
|
||||
assert.deepEqual(due.map((d) => d.step), [2], "step 1 wasn't for it, step 2 was");
|
||||
});
|
||||
|
||||
test("an acknowledgement stops it; so do maintenance, being held back by another alert, and info", () => {
|
||||
assert.deepEqual(run([alert("a", "critical")], { a: { openedAt: ago(200) } }, ["a"]), []);
|
||||
assert.deepEqual(run([alert("a", "critical", { silenced: true })], { a: { openedAt: ago(200) } }), []);
|
||||
assert.deepEqual(run([alert("a", "info")], { a: { openedAt: ago(200) } }), []);
|
||||
assert.deepEqual(run([alert("a", "critical")], {}), [], "no incident recorded yet, nothing to measure from");
|
||||
});
|
||||
});
|
||||
|
||||
describe("through the channels", () => {
|
||||
type Hit = { path: string; body: string };
|
||||
const hits: Record<"gotify" | "ntfy" | "webhook", Hit[]> = { gotify: [], ntfy: [], webhook: [] };
|
||||
const fake: Server[] = [];
|
||||
const base: Record<string, string> = {};
|
||||
let proddy = 0;
|
||||
|
||||
const text = (h: Hit) => {
|
||||
try {
|
||||
const j = JSON.parse(h.body);
|
||||
return String(j.message ?? j.content ?? h.body);
|
||||
} catch {
|
||||
return h.body;
|
||||
}
|
||||
};
|
||||
const clear = () => {
|
||||
for (const k of Object.keys(hits) as (keyof typeof hits)[]) hits[k].length = 0;
|
||||
};
|
||||
|
||||
before(async () => {
|
||||
for (const name of ["gotify", "ntfy", "webhook"] as const) {
|
||||
const s = createServer((req, res) => {
|
||||
const chunks: Buffer[] = [];
|
||||
req.on("data", (c) => chunks.push(c));
|
||||
req.on("end", () => {
|
||||
hits[name].push({ path: req.url ?? "", body: Buffer.concat(chunks).toString() });
|
||||
res.statusCode = 200;
|
||||
res.end("{}");
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => s.listen(0, "127.0.0.1", r));
|
||||
fake.push(s);
|
||||
base[name] = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
|
||||
}
|
||||
await updateSettings({
|
||||
gotify: { enabled: true, url: base.gotify, token: "g" },
|
||||
ntfy: { enabled: true, url: base.ntfy, topic: "lab" },
|
||||
webhook: { enabled: true, url: base.webhook },
|
||||
});
|
||||
proddy = (await db.insert(servers).values({ name: "prod-db", apiTokenHash: "p", apiTokenPrefix: "p", tags: JSON.stringify(["prod"]) }).returning({ id: servers.id }))[0].id;
|
||||
});
|
||||
|
||||
after(() => {
|
||||
for (const s of fake) s.close();
|
||||
try {
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
} catch {
|
||||
// Windows keeps the database file locked until the process exits.
|
||||
}
|
||||
});
|
||||
|
||||
const offline = (id: number) => ({ key: `offline:server:${id}`, message: `server ${id} is offline`, severity: "critical" });
|
||||
const disk = (id: number) => ({ key: `disk:server:${id}:/`, message: `disk on ${id} is full`, severity: "warning" });
|
||||
|
||||
test("with no rules everything goes everywhere, in one message, as it always did", async () => {
|
||||
clear();
|
||||
await notifyHealthIssues([offline(proddy), disk(proddy)]);
|
||||
for (const k of ["gotify", "ntfy", "webhook"] as const) {
|
||||
assert.equal(hits[k].length, 1, k);
|
||||
assert.match(text(hits[k][0]), /2 new issues/);
|
||||
}
|
||||
});
|
||||
|
||||
test("a rule sends one kind to one channel; the rest still goes everywhere, as a message of its own", async () => {
|
||||
await updateSettings({ routing: { rules: [rule({ id: "d", name: "Disks to ntfy", categories: ["disk"], channels: ["ntfy"] })] } });
|
||||
clear();
|
||||
await notifyHealthIssues([offline(proddy), disk(proddy)]);
|
||||
assert.equal(hits.gotify.length, 1);
|
||||
assert.match(text(hits.gotify[0]), /1 new issue:[\s\S]*is offline/);
|
||||
assert.doesNotMatch(text(hits.gotify[0]), /disk/);
|
||||
assert.equal(hits.webhook.length, 1);
|
||||
assert.equal(hits.ntfy.length, 2, "its own message for the disk, and the offline one with the rest");
|
||||
assert.ok(hits.ntfy.some((h) => /disk on/.test(text(h)) && !/offline/.test(text(h))));
|
||||
});
|
||||
|
||||
test("a rule can mute: nobody is told, and nothing is queued", async () => {
|
||||
await updateSettings({ routing: { rules: [rule({ id: "m", name: "Prod disks: nobody", categories: ["disk"], tags: ["prod"], channels: [] })] } });
|
||||
clear();
|
||||
await notifyHealthIssues([disk(proddy)]);
|
||||
assert.deepEqual([hits.gotify.length, hits.ntfy.length, hits.webhook.length], [0, 0, 0]);
|
||||
// the same disk problem on a server without the tag is not muted
|
||||
const plain = (await db.insert(servers).values({ name: "plain", apiTokenHash: "q", apiTokenPrefix: "q" }).returning({ id: servers.id }))[0].id;
|
||||
await notifyHealthIssues([disk(plain)]);
|
||||
assert.equal(hits.gotify.length, 1);
|
||||
});
|
||||
|
||||
test("a recovery follows the route its alert took", async () => {
|
||||
await updateSettings({ routing: { rules: [rule({ id: "c", name: "Critical to webhook", minSeverity: "critical", channels: ["webhook"] })] } });
|
||||
clear();
|
||||
await notifyHealthRecovered([{ key: `offline:server:${proddy}`, message: "back", severity: "critical" }]);
|
||||
assert.deepEqual([hits.gotify.length, hits.ntfy.length, hits.webhook.length], [0, 0, 1]);
|
||||
clear();
|
||||
await notifyHealthRecovered([{ key: `disk:server:${proddy}:/`, message: "ok", severity: "warning" }]);
|
||||
assert.deepEqual([hits.gotify.length, hits.ntfy.length, hits.webhook.length], [1, 1, 1], "a warning isn't covered by that rule, so it goes everywhere");
|
||||
});
|
||||
|
||||
test("a rule that is switched off does nothing", async () => {
|
||||
await updateSettings({ routing: { rules: [rule({ id: "x", enabled: false, channels: [] })] } });
|
||||
clear();
|
||||
await notifyHealthIssues([offline(proddy)]);
|
||||
assert.equal(hits.webhook.length, 1);
|
||||
});
|
||||
|
||||
test("held for quiet hours, a notification is still only for the channels its rule picked", async () => {
|
||||
await updateSettings({ routing: { rules: [rule({ id: "q", categories: ["backup"], channels: ["ntfy"] })] }, quietHours: { enabled: true, start: "00:00", end: "23:59" } });
|
||||
clear();
|
||||
await notify("Backups", "a backup is stale", { category: "backup", severity: "warning" });
|
||||
assert.deepEqual([hits.gotify.length, hits.ntfy.length, hits.webhook.length], [0, 0, 0], "held");
|
||||
const queued = await db.select().from(notificationQueue);
|
||||
assert.equal(queued.length, 1);
|
||||
assert.ok(queued[0].audience, "who it was for is kept");
|
||||
await updateSettings({ quietHours: { enabled: false } });
|
||||
assert.equal(await flushQuietHoursQueue(), 1);
|
||||
assert.deepEqual([hits.gotify.length, hits.ntfy.length, hits.webhook.length], [0, 1, 0]);
|
||||
assert.equal((await db.select().from(notificationQueue)).length, 0);
|
||||
});
|
||||
|
||||
test("browsers' wishes narrow who a push goes to, and only when somebody has stated any", async () => {
|
||||
await updateSettings({ routing: { rules: [] } });
|
||||
const [u] = await db.insert(users).values({ oidcSub: "u1", name: "U", role: "operator" }).returning({ id: users.id });
|
||||
const sub = (n: string, extra: Partial<typeof pushSubscriptions.$inferInsert>) => db.insert(pushSubscriptions).values({ userId: u.id, endpoint: `https://push.example/${n}`, p256dh: "k", auth: "a", ...extra }).returning({ id: pushSubscriptions.id });
|
||||
const [all] = await sub("all", {});
|
||||
assert.equal((await audienceFor({ category: "disk", severity: "warning" })).pushIds, null, "nobody asked for less");
|
||||
const [critical] = await sub("critical", { minSeverity: "critical" });
|
||||
const [disks] = await sub("disks", { categories: JSON.stringify(["disk"]) });
|
||||
const a = await audienceFor({ category: "disk", severity: "warning" });
|
||||
assert.deepEqual([...a.pushIds!].sort(), [all.id, disks.id].sort(), "the one wanting only critical stays out");
|
||||
const b = await audienceFor({ category: "backup", severity: "critical" });
|
||||
assert.deepEqual([...b.pushIds!].sort(), [all.id, critical.id].sort(), "and the one wanting only disks stays out of backups");
|
||||
assert.equal((await audienceFor()).pushIds, null, "a notification that says nothing about itself goes to all");
|
||||
});
|
||||
});
|
||||
|
||||
describe("escalation, end to end", () => {
|
||||
const hits: { path: string; body: string }[] = [];
|
||||
let fakeHook: Server;
|
||||
|
||||
before(async () => {
|
||||
fakeHook = createServer((req, res) => {
|
||||
const chunks: Buffer[] = [];
|
||||
req.on("data", (c) => chunks.push(c));
|
||||
req.on("end", () => {
|
||||
hits.push({ path: req.url ?? "", body: Buffer.concat(chunks).toString() });
|
||||
res.end("{}");
|
||||
});
|
||||
});
|
||||
await new Promise<void>((r) => fakeHook.listen(0, "127.0.0.1", r));
|
||||
await db.delete(servers);
|
||||
await db.insert(servers).values({ name: "late", apiTokenHash: "l", apiTokenPrefix: "l", lastSeenAt: new Date(Date.now() - 5 * 3600_000).toISOString() });
|
||||
await updateSettings({
|
||||
gotify: { enabled: false },
|
||||
ntfy: { enabled: false },
|
||||
webhook: { enabled: true, url: `http://127.0.0.1:${(fakeHook.address() as AddressInfo).port}/hook` },
|
||||
routing: { rules: [] },
|
||||
quietHours: { enabled: false },
|
||||
escalation: {
|
||||
enabled: true,
|
||||
steps: [
|
||||
{ afterMinutes: 30, minSeverity: "warning", channels: ["webhook"], extraEmail: "", evenInQuietHours: false },
|
||||
{ afterMinutes: 90, minSeverity: "critical", channels: ["webhook"], extraEmail: "", evenInQuietHours: true },
|
||||
],
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
after(() => fakeHook.close());
|
||||
|
||||
const setAge = async (minutes: number) => {
|
||||
await db.update(alertIncidents).set({ openedAt: new Date(Date.now() - minutes * 60_000).toISOString() });
|
||||
};
|
||||
const text = () => hits.map((h) => JSON.parse(h.body).content as string);
|
||||
|
||||
test("nothing happens until the alert has been up long enough; then the steps go out one by one, each once", async () => {
|
||||
invalidateAlertsCache();
|
||||
await getAlerts(true);
|
||||
await new Promise((r) => setTimeout(r, 300)); // the incident is recorded in the background
|
||||
assert.equal(await runEscalation(), 0, "just raised");
|
||||
assert.equal(hits.length, 0);
|
||||
|
||||
await setAge(40);
|
||||
assert.equal(await runEscalation(), 1);
|
||||
assert.equal(hits.length, 1);
|
||||
assert.match(text()[0], /Still not acknowledged/);
|
||||
assert.match(text()[0], /late hasn't reported/);
|
||||
assert.match(text()[0], /after 30 minutes/);
|
||||
assert.equal(await runEscalation(), 0, "step 1 is not repeated");
|
||||
|
||||
await setAge(100);
|
||||
assert.equal(await runEscalation(), 1);
|
||||
assert.match(text()[1], /after 90 minutes/);
|
||||
assert.equal(await runEscalation(), 0, "and that was the last step");
|
||||
const [inc] = await db.select().from(alertIncidents);
|
||||
assert.equal(inc.escalatedStep, 2);
|
||||
assert.equal((await db.select().from(auditLog)).filter((e) => e.action === "escalate").length, 2);
|
||||
});
|
||||
|
||||
test("an acknowledgement stops it, and so does switching it off", async () => {
|
||||
await db.update(alertIncidents).set({ escalatedStep: 0, escalatedAt: null });
|
||||
await setAge(500);
|
||||
const before = hits.length;
|
||||
const alert = (await getAlerts(false)).alerts.find((a) => a.category === "offline")!;
|
||||
await setAck({ alertId: alert.id, note: "on it", assigneeId: null, hours: null, actor: "Ada" });
|
||||
assert.equal(await runEscalation(), 0);
|
||||
await db.delete((await import("../src/db/schema.js")).alertAcks);
|
||||
await updateSettings({ escalation: { enabled: false } });
|
||||
assert.equal(await runEscalation(), 0);
|
||||
assert.equal(hits.length, before);
|
||||
await updateSettings({ escalation: { enabled: true } });
|
||||
assert.equal(await runEscalation(), 1, "and it carries on once it is on and nobody is on it");
|
||||
});
|
||||
});
|
||||
|
||||
describe("saving the settings", () => {
|
||||
let app: Server;
|
||||
let base = "";
|
||||
|
||||
before(async () => {
|
||||
await db.insert(users).values({ oidcSub: "admin", name: "Ada", role: "admin" }).onConflictDoNothing();
|
||||
const a = express();
|
||||
a.use(express.json());
|
||||
a.use((req, _res, next) => {
|
||||
(req as unknown as { session: unknown }).session = { user: { sub: "admin" } };
|
||||
next();
|
||||
});
|
||||
a.use("/api/settings", settingsRouter);
|
||||
app = await new Promise<Server>((resolve) => {
|
||||
const s = a.listen(0, "127.0.0.1", () => resolve(s));
|
||||
});
|
||||
base = `http://127.0.0.1:${(app.address() as AddressInfo).port}/api/settings`;
|
||||
});
|
||||
after(() => app.close());
|
||||
|
||||
const put = (body: unknown) => fetch(base, { method: "PUT", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
|
||||
const step = (afterMinutes: number, extra: Record<string, unknown> = {}) => ({ afterMinutes, minSeverity: "critical", channels: ["webPush"], extraEmail: "", evenInQuietHours: false, ...extra });
|
||||
|
||||
test("rules are kept, with their tags written the way server tags are", async () => {
|
||||
const res = await put({ routing: { rules: [{ id: "a1", name: "Prod", enabled: true, categories: ["disk"], minSeverity: "critical", tags: [" Prod ", "Db Servers"], channels: ["ntfy"] }] } });
|
||||
assert.equal(res.status, 200);
|
||||
const saved = (await (await fetch(base)).json()).settings.routing.rules[0];
|
||||
assert.deepEqual(saved.tags, ["db-servers", "prod"]);
|
||||
});
|
||||
|
||||
test("a rule that isn't one is refused", async () => {
|
||||
assert.equal((await put({ routing: { rules: [{ id: "a", name: "x", enabled: true, categories: ["toast"], minSeverity: null, tags: [], channels: [] }] } })).status, 400);
|
||||
assert.equal((await put({ routing: { rules: [{ id: "a", name: "x", enabled: true, categories: [], minSeverity: null, tags: [], channels: ["carrier-pigeon"] }] } })).status, 400);
|
||||
assert.equal((await put({ routing: { rules: [{ id: "a", name: "x", enabled: true, categories: [], minSeverity: null, tags: ["not a tag!"], channels: [] }] } })).status, 400);
|
||||
});
|
||||
|
||||
test("escalation steps must be in time order, say who to tell, and be few", async () => {
|
||||
assert.equal((await put({ escalation: { enabled: true, steps: [step(30), step(120, { extraEmail: "x@example.com", channels: [] })] } })).status, 200);
|
||||
assert.equal((await put({ escalation: { enabled: true, steps: [step(60), step(30)] } })).status, 400, "out of order");
|
||||
assert.equal((await put({ escalation: { enabled: true, steps: [step(30, { channels: [], extraEmail: "" })] } })).status, 400, "nobody to tell");
|
||||
assert.equal((await put({ escalation: { enabled: true, steps: [step(30, { extraEmail: "not an address" })] } })).status, 400);
|
||||
assert.equal((await put({ escalation: { enabled: true, steps: [step(10), step(20), step(30), step(40)] } })).status, 400, "at most three");
|
||||
assert.equal((await put({ escalation: { enabled: true, steps: [step(2)] } })).status, 400, "not sooner than five minutes");
|
||||
});
|
||||
});
|
||||
|
||||
describe("ntfy titles", () => {
|
||||
test("a title with an em dash can be sent as a header; plain ones are left as they are", async () => {
|
||||
const { headerSafe } = await import("../src/services/notify.js");
|
||||
assert.equal(headerSafe("Plain title"), "Plain title");
|
||||
const encoded = headerSafe("Homelab Manager — Health Alert");
|
||||
assert.match(encoded, /^=\?UTF-8\?B\?[A-Za-z0-9+/=]+\?=$/);
|
||||
assert.equal(Buffer.from(encoded.slice(10, -2), "base64").toString("utf8"), "Homelab Manager — Health Alert");
|
||||
assert.doesNotThrow(() => new Headers({ Title: encoded }), "and the runtime takes it");
|
||||
assert.throws(() => new Headers({ Title: "Homelab Manager — Health Alert" }), "which it would not take as it was");
|
||||
});
|
||||
});
|
||||
|
||||
describe("a browser's preferences, over the routes", () => {
|
||||
let app: Server;
|
||||
let base = "";
|
||||
let who = "p1";
|
||||
let mine = 0;
|
||||
|
||||
before(async () => {
|
||||
const { pushRouter } = await import("../src/routes/push.js");
|
||||
const made = await db.insert(users).values([{ oidcSub: "p1", name: "P1", role: "viewer" }, { oidcSub: "p2", name: "P2", role: "viewer" }]).returning({ id: users.id });
|
||||
mine = (await db.insert(pushSubscriptions).values({ userId: made[0].id, endpoint: "https://push.example/mine", p256dh: "k", auth: "a" }).returning({ id: pushSubscriptions.id }))[0].id;
|
||||
const a = express();
|
||||
a.use(express.json());
|
||||
a.use((req, _res, next) => {
|
||||
(req as unknown as { session: unknown }).session = { user: { sub: who } };
|
||||
next();
|
||||
});
|
||||
a.use("/api/push", pushRouter);
|
||||
app = await new Promise<Server>((resolve) => {
|
||||
const s = a.listen(0, "127.0.0.1", () => resolve(s));
|
||||
});
|
||||
base = `http://127.0.0.1:${(app.address() as AddressInfo).port}/api/push`;
|
||||
});
|
||||
after(() => app.close());
|
||||
|
||||
const patch = (id: number, body: unknown) => fetch(`${base}/${id}`, { method: "PATCH", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
|
||||
|
||||
test("a person sets what reaches a browser and reads it back; someone else's browser is not theirs to set", async () => {
|
||||
const first = await patch(mine, { minSeverity: "critical", categories: ["offline", "disk"] });
|
||||
assert.equal(first.status, 200, JSON.stringify(await first.clone().json()));
|
||||
const list = (await (await fetch(`${base}/mine`)).json()).subscriptions[0];
|
||||
assert.equal(list.minSeverity, "critical");
|
||||
assert.deepEqual(list.categories, ["offline", "disk"]);
|
||||
assert.equal((await patch(mine, { minSeverity: null, categories: [] })).status, 200, "an empty list is every kind");
|
||||
const cleared = (await (await fetch(`${base}/mine`)).json()).subscriptions[0];
|
||||
assert.deepEqual([cleared.minSeverity, cleared.categories], [null, null]);
|
||||
who = "p2";
|
||||
assert.equal((await patch(mine, { minSeverity: "critical", categories: null })).status, 404);
|
||||
who = "p1";
|
||||
assert.equal((await patch(mine, { minSeverity: "info", categories: null })).status, 400, "info never notifies, so it isn't a floor");
|
||||
assert.equal((await patch(mine, { minSeverity: null, categories: ["toast"] })).status, 400);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user