refactor out rebuilding of status response

This commit is contained in:
Alex Holliday committed 2026-09-23 13:38:02 -07:00
1 parent 849ea26cf9
commit 0d75629dcb
18 files changed
+436 -786

No files matched your search

@@ -1,7 +1,8 @@
import { describe, expect, it, beforeEach } from "@jest/globals";
import { NotificationMessageBuilder } from "../../../src/domain/notifications/notification.message-builder.ts";
import type { Monitor } from "../../../src/domain/monitors/monitor.type.ts";
import type { MonitorStatusResponse, HardwareStatusPayload, DockerStatusPayload } from "../../../src/types/network.ts";
import type { Check } from "../../../src/domain/checks/check.type.ts";
import type { DockerContainerInfo } from "../../../src/domain/docker/docker.type.ts";
import type { MonitorActionDecision } from "../../../src/worker/worker.interface.ts";
// ── Helpers ──────────────────────────────────────────────────────────────────
@@ -30,29 +31,20 @@ const makeDecision = (overrides?: Partial<MonitorActionDecision>): MonitorAction
...overrides,
});
const makeStatusResponse = (overrides?: Partial<MonitorStatusResponse>): MonitorStatusResponse =>
({
monitorId: "mon-1",
teamId: "team-1",
type: "http",
status: false,
code: 500,
message: "Internal Server Error",
...overrides,
}) as MonitorStatusResponse;
const makeCheck = (overrides?: Partial<Check>): Check => ({
id: "check-1",
metadata: { monitorId: "mon-1", teamId: "team-1", type: "http" },
status: false,
responseTime: 100,
statusCode: 500,
message: "Internal Server Error",
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
...overrides,
});
const makeHardwarePayload = (overrides?: Partial<HardwareStatusPayload["data"]>): HardwareStatusPayload =>
({
data: {
cpu: { usage_percent: 0.5, temperature: [45] },
memory: { usage_percent: 0.6 },
disk: [{ usage_percent: 0.7 }],
...overrides,
},
}) as HardwareStatusPayload;
const makeDockerPayload = (containers: Partial<DockerStatusPayload["containers"][number]>[]): DockerStatusPayload => ({
containers: containers.map((container, index) => ({
const makeContainers = (containers: Partial<DockerContainerInfo>[]): DockerContainerInfo[] =>
containers.map((container, index) => ({
id: `container-${index}`,
name: `container-${index}`,
image: "nginx:latest",
@@ -60,9 +52,7 @@ const makeDockerPayload = (containers: Partial<DockerStatusPayload["containers"]
status: "Up 3 hours",
health: "none",
...container,
})),
summary: { total: containers.length, running: 0, stopped: 0, unhealthy: 0 },
});
}));
const makeDockerMonitor = (overrides?: Partial<Monitor>): Monitor =>
makeMonitor({
@@ -95,9 +85,9 @@ describe("NotificationMessageBuilder", () => {
it("builds a monitor_down message", () => {
const monitor = makeMonitor({ status: "down" });
const decision = makeDecision();
const response = makeStatusResponse();
const check = makeCheck();
const msg = builder.buildMessage(monitor, response, decision, "https://app.example.com");
const msg = builder.buildMessage(monitor, check, decision, "https://app.example.com");
expect(msg.type).toBe("monitor_down");
expect(msg.severity).toBe("critical");
@@ -120,7 +110,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "up", type: "http" });
const decision = makeDecision({ notificationReason: "status_change" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "https://app.example.com");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "https://app.example.com");
expect(msg.type).toBe("monitor_up");
expect(msg.severity).toBe("success");
@@ -130,12 +120,9 @@ describe("NotificationMessageBuilder", () => {
it("builds a threshold_breach message", () => {
const monitor = makeMonitor({ status: "up", type: "hardware", cpuAlertThreshold: 80 });
const decision = makeDecision({ notificationReason: "threshold_breach" });
const response = makeStatusResponse({
type: "hardware",
payload: makeHardwarePayload({ cpu: { usage_percent: 0.9, temperature: [50] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.9, temperature: [50] } });
const msg = builder.buildMessage(monitor, response, decision, "https://app.example.com");
const msg = builder.buildMessage(monitor, check, decision, "https://app.example.com");
expect(msg.type).toBe("threshold_breach");
expect(msg.severity).toBe("warning");
@@ -148,7 +135,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "up", type: "hardware" });
const decision = makeDecision({ notificationReason: "threshold_resolved" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "https://app.example.com");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "https://app.example.com");
expect(msg.type).toBe("threshold_resolved");
expect(msg.severity).toBe("success");
@@ -159,7 +146,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "down" });
const decision = makeDecision({ notificationReason: null });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "https://app.example.com");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "https://app.example.com");
expect(msg.metadata.notificationReason).toBe("status_change");
});
@@ -172,7 +159,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "down" });
const decision = makeDecision({ notificationReason: "threshold_breach" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "");
expect(msg.type).toBe("monitor_down");
});
@@ -181,7 +168,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "up", type: "hardware" });
const decision = makeDecision({ notificationReason: "threshold_breach" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "");
expect(msg.type).toBe("threshold_breach");
});
@@ -190,7 +177,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "up", type: "hardware" });
const decision = makeDecision({ notificationReason: "threshold_resolved" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "");
expect(msg.type).toBe("threshold_resolved");
});
@@ -199,7 +186,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "up", type: "hardware" });
const decision = makeDecision({ notificationReason: "status_change" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "");
expect(msg.type).toBe("monitor_up");
});
@@ -207,7 +194,7 @@ describe("NotificationMessageBuilder", () => {
it("returns container_breach for docker monitor with threshold_breach reason", () => {
const decision = makeDecision({ notificationReason: "threshold_breach" });
const msg = builder.buildMessage(makeDockerMonitor(), makeStatusResponse(), decision, "");
const msg = builder.buildMessage(makeDockerMonitor(), makeCheck(), decision, "");
expect(msg.type).toBe("container_breach");
});
@@ -215,7 +202,7 @@ describe("NotificationMessageBuilder", () => {
it("returns container_resolved for docker monitor with threshold_resolved reason", () => {
const decision = makeDecision({ notificationReason: "threshold_resolved" });
const msg = builder.buildMessage(makeDockerMonitor({ status: "up" }), makeStatusResponse(), decision, "");
const msg = builder.buildMessage(makeDockerMonitor({ status: "up" }), makeCheck(), decision, "");
expect(msg.type).toBe("container_resolved");
});
@@ -223,7 +210,7 @@ describe("NotificationMessageBuilder", () => {
it("returns monitor_down for docker monitor that is down regardless of reason", () => {
const decision = makeDecision({ notificationReason: "threshold_breach" });
const msg = builder.buildMessage(makeDockerMonitor({ status: "down" }), makeStatusResponse(), decision, "");
const msg = builder.buildMessage(makeDockerMonitor({ status: "down" }), makeCheck(), decision, "");
expect(msg.type).toBe("monitor_down");
});
@@ -232,7 +219,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "up", type: "http" });
const decision = makeDecision({ notificationReason: "status_change" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "");
expect(msg.type).toBe("monitor_up");
});
@@ -241,7 +228,7 @@ describe("NotificationMessageBuilder", () => {
const monitor = makeMonitor({ status: "unknown" as any });
const decision = makeDecision({ notificationReason: null });
const msg = builder.buildMessage(monitor, makeStatusResponse(), decision, "");
const msg = builder.buildMessage(monitor, makeCheck(), decision, "");
expect(msg.type).toBe("monitor_up");
});
@@ -251,14 +238,14 @@ describe("NotificationMessageBuilder", () => {
describe("determineSeverity", () => {
it("returns critical for monitor_down", () => {
const msg = builder.buildMessage(makeMonitor({ status: "down" }), makeStatusResponse(), makeDecision(), "");
const msg = builder.buildMessage(makeMonitor({ status: "down" }), makeCheck(), makeDecision(), "");
expect(msg.severity).toBe("critical");
});
it("returns warning for threshold_breach", () => {
const msg = builder.buildMessage(
makeMonitor({ status: "up", type: "hardware" }),
makeStatusResponse(),
makeCheck(),
makeDecision({ notificationReason: "threshold_breach" }),
""
);
@@ -268,7 +255,7 @@ describe("NotificationMessageBuilder", () => {
it("returns success for monitor_up", () => {
const msg = builder.buildMessage(
makeMonitor({ status: "up", type: "http" }),
makeStatusResponse(),
makeCheck(),
makeDecision({ notificationReason: "status_change" }),
""
);
@@ -278,7 +265,7 @@ describe("NotificationMessageBuilder", () => {
it("returns success for threshold_resolved", () => {
const msg = builder.buildMessage(
makeMonitor({ status: "up", type: "hardware" }),
makeStatusResponse(),
makeCheck(),
makeDecision({ notificationReason: "threshold_resolved" }),
""
);
@@ -286,14 +273,14 @@ describe("NotificationMessageBuilder", () => {
});
it("returns warning for container_breach", () => {
const msg = builder.buildMessage(makeDockerMonitor(), makeStatusResponse(), makeDecision({ notificationReason: "threshold_breach" }), "");
const msg = builder.buildMessage(makeDockerMonitor(), makeCheck(), makeDecision({ notificationReason: "threshold_breach" }), "");
expect(msg.severity).toBe("warning");
});
it("returns success for container_resolved", () => {
const msg = builder.buildMessage(
makeDockerMonitor({ status: "up" }),
makeStatusResponse(),
makeCheck(),
makeDecision({ notificationReason: "threshold_resolved" }),
""
);
@@ -307,9 +294,9 @@ describe("NotificationMessageBuilder", () => {
describe("monitor_down", () => {
it("includes response code and error message when present", () => {
const monitor = makeMonitor({ status: "down" });
const response = makeStatusResponse({ code: 503, message: "Service Unavailable" });
const check = makeCheck({ statusCode: 503, message: "Service Unavailable" });
const msg = builder.buildMessage(monitor, response, makeDecision(), "");
const msg = builder.buildMessage(monitor, check, makeDecision(), "");
expect(msg.content.details).toContain("Response Code: 503");
expect(msg.content.details).toContain("Error: Service Unavailable");
@@ -317,9 +304,9 @@ describe("NotificationMessageBuilder", () => {
it("omits response code when falsy", () => {
const monitor = makeMonitor({ status: "down" });
const response = makeStatusResponse({ code: 0, message: "" });
const check = makeCheck({ statusCode: 0, message: "" });
const msg = builder.buildMessage(monitor, response, makeDecision(), "");
const msg = builder.buildMessage(monitor, check, makeDecision(), "");
expect(msg.content.details).not.toContainEqual(expect.stringContaining("Response Code:"));
expect(msg.content.details).not.toContainEqual(expect.stringContaining("Error:"));
@@ -327,7 +314,7 @@ describe("NotificationMessageBuilder", () => {
it("includes URL, Status, and Type in details", () => {
const monitor = makeMonitor({ status: "down" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), makeDecision(), "");
const msg = builder.buildMessage(monitor, makeCheck(), makeDecision(), "");
expect(msg.content.details).toContain("URL: https://example.com");
expect(msg.content.details).toContain("Status: Down");
@@ -336,13 +323,13 @@ describe("NotificationMessageBuilder", () => {
it("sets summary text", () => {
const monitor = makeMonitor({ status: "down" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), makeDecision(), "");
const msg = builder.buildMessage(monitor, makeCheck(), makeDecision(), "");
expect(msg.content.summary).toBe('Monitor "Test Monitor" is currently down and unreachable.');
});
it("sets timestamp", () => {
const monitor = makeMonitor({ status: "down" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), makeDecision(), "");
const msg = builder.buildMessage(monitor, makeCheck(), makeDecision(), "");
expect(msg.content.timestamp).toBeInstanceOf(Date);
});
});
@@ -350,7 +337,7 @@ describe("NotificationMessageBuilder", () => {
describe("monitor_up", () => {
it("includes recovery details", () => {
const monitor = makeMonitor({ status: "up", type: "http" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), makeDecision(), "");
const msg = builder.buildMessage(monitor, makeCheck(), makeDecision(), "");
expect(msg.content.title).toBe("Monitor Recovered: Test Monitor");
expect(msg.content.summary).toBe('Monitor "Test Monitor" is back up and operational.');
@@ -361,11 +348,9 @@ describe("NotificationMessageBuilder", () => {
describe("threshold_breach", () => {
it("includes threshold breaches in content", () => {
const monitor = makeMonitor({ status: "up", type: "hardware", cpuAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.9, temperature: [50] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.9, temperature: [50] } });
const msg = builder.buildMessage(monitor, response, makeDecision({ notificationReason: "threshold_breach" }), "");
const msg = builder.buildMessage(monitor, check, makeDecision({ notificationReason: "threshold_breach" }), "");
expect(msg.content.thresholds).toEqual(
expect.arrayContaining([
@@ -382,7 +367,7 @@ describe("NotificationMessageBuilder", () => {
describe("threshold_resolved", () => {
it("includes resolved details", () => {
const monitor = makeMonitor({ status: "up", type: "hardware" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), makeDecision({ notificationReason: "threshold_resolved" }), "");
const msg = builder.buildMessage(monitor, makeCheck(), makeDecision({ notificationReason: "threshold_resolved" }), "");
expect(msg.content.title).toBe("Thresholds Resolved: Test Monitor");
expect(msg.content.summary).toBe('Monitor "Test Monitor" thresholds have returned to normal.');
@@ -392,13 +377,12 @@ describe("NotificationMessageBuilder", () => {
describe("container_breach", () => {
it("lists one detail line per breaching container", () => {
const response = makeStatusResponse({
type: "docker",
const check = makeCheck({
status: true,
payload: makeDockerPayload([{ name: "db", state: "exited", exitCode: 1 }, { name: "api", health: "unhealthy" }, { name: "web" }]),
} as any);
containers: makeContainers([{ name: "db", state: "exited", exitCode: 1 }, { name: "api", health: "unhealthy" }, { name: "web" }]),
});
const msg = builder.buildMessage(makeDockerMonitor(), response, makeDecision({ notificationReason: "threshold_breach" }), "");
const msg = builder.buildMessage(makeDockerMonitor(), check, makeDecision({ notificationReason: "threshold_breach" }), "");
expect(msg.content.title).toBe("Container Alert: Test Monitor");
expect(msg.content.summary).toBe('2 container(s) on "Test Monitor" need attention.');
@@ -407,25 +391,24 @@ describe("NotificationMessageBuilder", () => {
});
it("only lists containers matching an enabled switch", () => {
const response = makeStatusResponse({
type: "docker",
const check = makeCheck({
status: true,
payload: makeDockerPayload([
containers: makeContainers([
{ name: "db", state: "exited", exitCode: 1 },
{ name: "api", health: "unhealthy" },
]),
} as any);
});
const monitor = makeDockerMonitor({ dockerAlertOnStopped: false });
const msg = builder.buildMessage(monitor, response, makeDecision({ notificationReason: "threshold_breach" }), "");
const msg = builder.buildMessage(monitor, check, makeDecision({ notificationReason: "threshold_breach" }), "");
expect(msg.content.details).toEqual(["URL: unix:///var/run/docker.sock", "Type: docker", "api: unhealthy"]);
});
it("lists no containers when the payload is an error string", () => {
const response = makeStatusResponse({ type: "docker", status: false, payload: "connect ECONNREFUSED" } as any);
it("lists no containers when the check carries no container data", () => {
const check = makeCheck({ status: false, message: "connect ECONNREFUSED" });
const msg = builder.buildMessage(makeDockerMonitor(), response, makeDecision({ notificationReason: "threshold_breach" }), "");
const msg = builder.buildMessage(makeDockerMonitor(), check, makeDecision({ notificationReason: "threshold_breach" }), "");
expect(msg.content.summary).toBe('0 container(s) on "Test Monitor" need attention.');
expect(msg.content.details).toEqual(["URL: unix:///var/run/docker.sock", "Type: docker"]);
@@ -436,7 +419,7 @@ describe("NotificationMessageBuilder", () => {
it("includes recovered details", () => {
const msg = builder.buildMessage(
makeDockerMonitor({ status: "up" }),
makeStatusResponse(),
makeCheck(),
makeDecision({ notificationReason: "threshold_resolved" }),
""
);
@@ -457,7 +440,7 @@ describe("NotificationMessageBuilder", () => {
// Instead, let's verify the default case exists by checking that
// non-standard types would get default content
const monitor = makeMonitor({ status: "up", type: "http" });
const msg = builder.buildMessage(monitor, makeStatusResponse(), makeDecision(), "");
const msg = builder.buildMessage(monitor, makeCheck(), makeDecision(), "");
// monitor_up is handled, so content should be monitor_up specific
expect(msg.content.title).toBe("Monitor Recovered: Test Monitor");
@@ -484,7 +467,7 @@ describe("NotificationMessageBuilder", () => {
describe("buildContent edge cases", () => {
it("returns default content for unhandled notification type", () => {
const monitor = makeMonitor({ status: "up", type: "http" });
const result = (builder as any).buildContent("test", monitor, makeStatusResponse());
const result = (builder as any).buildContent("test", monitor, makeCheck());
expect(result.title).toBe("Monitor: Test Monitor");
expect(result.summary).toBe('Status update for monitor "Test Monitor".');
@@ -499,27 +482,24 @@ describe("NotificationMessageBuilder", () => {
describe("extractThresholdBreaches", () => {
it("returns empty array for non-hardware monitor", () => {
const monitor = makeMonitor({ type: "http" });
const response = makeStatusResponse();
const check = makeCheck({ cpu: { usage_percent: 0.99 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toEqual([]);
});
it("returns empty array when payload is missing", () => {
const monitor = makeMonitor({ type: "hardware" });
const response = makeStatusResponse({ payload: undefined } as any);
it("returns empty array when the check carries no hardware data", () => {
const monitor = makeMonitor({
type: "hardware",
cpuAlertThreshold: 80,
memoryAlertThreshold: 80,
diskAlertThreshold: 80,
tempAlertThreshold: 80,
});
const check = makeCheck();
const breaches = builder.extractThresholdBreaches(monitor, response);
expect(breaches).toEqual([]);
});
it("returns empty array when hardware data is missing", () => {
const monitor = makeMonitor({ type: "hardware" });
const response = makeStatusResponse({ payload: { data: undefined } } as any);
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toEqual([]);
});
@@ -529,11 +509,9 @@ describe("NotificationMessageBuilder", () => {
describe("cpu threshold", () => {
it("detects CPU breach when usage exceeds threshold", () => {
const monitor = makeMonitor({ type: "hardware", cpuAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.9, temperature: [50] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.9, temperature: [50] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toContainEqual(
expect.objectContaining({
@@ -548,55 +526,45 @@ describe("NotificationMessageBuilder", () => {
it("does not report CPU breach when usage is below threshold", () => {
const monitor = makeMonitor({ type: "hardware", cpuAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: [50] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: [50] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "cpu")).toBeUndefined();
});
it("skips CPU check when cpuAlertThreshold is undefined", () => {
const monitor = makeMonitor({ type: "hardware", cpuAlertThreshold: undefined });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.99 } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.99 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "cpu")).toBeUndefined();
});
it("skips CPU check when cpuAlertThreshold is null", () => {
const monitor = makeMonitor({ type: "hardware", cpuAlertThreshold: null as any });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.99 } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.99 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "cpu")).toBeUndefined();
});
it("skips CPU check when cpu usage_percent is undefined", () => {
const monitor = makeMonitor({ type: "hardware", cpuAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: undefined } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: undefined } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "cpu")).toBeUndefined();
});
it("skips CPU check when cpu object is undefined", () => {
const monitor = makeMonitor({ type: "hardware", cpuAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: undefined as any }),
} as any);
const check = makeCheck({ cpu: undefined });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "cpu")).toBeUndefined();
});
@@ -607,11 +575,9 @@ describe("NotificationMessageBuilder", () => {
describe("memory threshold", () => {
it("detects memory breach when usage exceeds threshold", () => {
const monitor = makeMonitor({ type: "hardware", memoryAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ memory: { usage_percent: 0.85 } as any }),
} as any);
const check = makeCheck({ memory: { usage_percent: 0.85 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toContainEqual(
expect.objectContaining({
@@ -626,55 +592,45 @@ describe("NotificationMessageBuilder", () => {
it("does not report memory breach when usage is below threshold", () => {
const monitor = makeMonitor({ type: "hardware", memoryAlertThreshold: 90 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ memory: { usage_percent: 0.5 } as any }),
} as any);
const check = makeCheck({ memory: { usage_percent: 0.5 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "memory")).toBeUndefined();
});
it("skips memory check when memoryAlertThreshold is undefined", () => {
const monitor = makeMonitor({ type: "hardware", memoryAlertThreshold: undefined });
const response = makeStatusResponse({
payload: makeHardwarePayload({ memory: { usage_percent: 0.99 } as any }),
} as any);
const check = makeCheck({ memory: { usage_percent: 0.99 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "memory")).toBeUndefined();
});
it("skips memory check when memoryAlertThreshold is null", () => {
const monitor = makeMonitor({ type: "hardware", memoryAlertThreshold: null as any });
const response = makeStatusResponse({
payload: makeHardwarePayload({ memory: { usage_percent: 0.99 } as any }),
} as any);
const check = makeCheck({ memory: { usage_percent: 0.99 } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "memory")).toBeUndefined();
});
it("skips memory check when memory usage_percent is undefined", () => {
const monitor = makeMonitor({ type: "hardware", memoryAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ memory: { usage_percent: undefined } as any }),
} as any);
const check = makeCheck({ memory: { usage_percent: undefined } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "memory")).toBeUndefined();
});
it("skips memory check when memory object is undefined", () => {
const monitor = makeMonitor({ type: "hardware", memoryAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ memory: undefined as any }),
} as any);
const check = makeCheck({ memory: undefined });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "memory")).toBeUndefined();
});
@@ -685,13 +641,9 @@ describe("NotificationMessageBuilder", () => {
describe("disk threshold", () => {
it("detects disk breach using highest usage across multiple disks", () => {
const monitor = makeMonitor({ type: "hardware", diskAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({
disk: [{ usage_percent: 0.5 }, { usage_percent: 0.95 }, { usage_percent: 0.7 }] as any,
}),
} as any);
const check = makeCheck({ disk: [{ usage_percent: 0.5 }, { usage_percent: 0.95 }, { usage_percent: 0.7 }] });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toContainEqual(
expect.objectContaining({
@@ -705,59 +657,45 @@ describe("NotificationMessageBuilder", () => {
it("does not report disk breach when all disks are below threshold", () => {
const monitor = makeMonitor({ type: "hardware", diskAlertThreshold: 90 });
const response = makeStatusResponse({
payload: makeHardwarePayload({
disk: [{ usage_percent: 0.5 }, { usage_percent: 0.6 }] as any,
}),
} as any);
const check = makeCheck({ disk: [{ usage_percent: 0.5 }, { usage_percent: 0.6 }] });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "disk")).toBeUndefined();
});
it("skips disk check when diskAlertThreshold is undefined", () => {
const monitor = makeMonitor({ type: "hardware", diskAlertThreshold: undefined });
const response = makeStatusResponse({
payload: makeHardwarePayload({ disk: [{ usage_percent: 0.99 }] as any }),
} as any);
const check = makeCheck({ disk: [{ usage_percent: 0.99 }] });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "disk")).toBeUndefined();
});
it("skips disk check when diskAlertThreshold is null", () => {
const monitor = makeMonitor({ type: "hardware", diskAlertThreshold: null as any });
const response = makeStatusResponse({
payload: makeHardwarePayload({ disk: [{ usage_percent: 0.99 }] as any }),
} as any);
const check = makeCheck({ disk: [{ usage_percent: 0.99 }] });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "disk")).toBeUndefined();
});
it("skips disk check when disk is not an array", () => {
const monitor = makeMonitor({ type: "hardware", diskAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ disk: "not-an-array" as any }),
} as any);
const check = makeCheck({ disk: "not-an-array" as any });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "disk")).toBeUndefined();
});
it("skips disks with undefined usage_percent", () => {
const monitor = makeMonitor({ type: "hardware", diskAlertThreshold: 50 });
const response = makeStatusResponse({
payload: makeHardwarePayload({
disk: [{ usage_percent: undefined }, { usage_percent: 0.3 }] as any,
}),
} as any);
const check = makeCheck({ disk: [{ usage_percent: undefined }, { usage_percent: 0.3 }] });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "disk")).toBeUndefined();
});
@@ -768,11 +706,9 @@ describe("NotificationMessageBuilder", () => {
describe("temperature threshold", () => {
it("detects temperature breach from array of temperatures", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: [65, 75, 68] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: [65, 75, 68] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toContainEqual(
expect.objectContaining({
@@ -787,11 +723,9 @@ describe("NotificationMessageBuilder", () => {
it("handles single temperature value (non-array)", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: 80 } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: 80 as any } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches).toContainEqual(
expect.objectContaining({
@@ -804,11 +738,9 @@ describe("NotificationMessageBuilder", () => {
it("does not report temperature breach when below threshold", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: [60, 65] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: [60, 65] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "temp")).toBeUndefined();
});
@@ -820,55 +752,45 @@ describe("NotificationMessageBuilder", () => {
// content for a breach some OTHER metric triggered could still list temp as breaching).
it("does not report temperature breach when exactly at threshold", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: 80 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: [80] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: [80] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "temp")).toBeUndefined();
});
it("skips temperature check when tempAlertThreshold is undefined", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: undefined });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: [99] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: [99] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "temp")).toBeUndefined();
});
it("skips temperature check when tempAlertThreshold is null", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: null as any });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: [99] } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: [99] } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "temp")).toBeUndefined();
});
it("skips temperature check when cpu.temperature is falsy", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: { usage_percent: 0.5, temperature: null } as any }),
} as any);
const check = makeCheck({ cpu: { usage_percent: 0.5, temperature: null as any } });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "temp")).toBeUndefined();
});
it("skips temperature check when cpu object is undefined", () => {
const monitor = makeMonitor({ type: "hardware", tempAlertThreshold: 70 });
const response = makeStatusResponse({
payload: makeHardwarePayload({ cpu: undefined as any }),
} as any);
const check = makeCheck({ cpu: undefined });
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
expect(breaches.find((b) => b.metric === "temp")).toBeUndefined();
});
@@ -885,15 +807,13 @@ describe("NotificationMessageBuilder", () => {
diskAlertThreshold: 85,
tempAlertThreshold: 65,
});
const response = makeStatusResponse({
payload: makeHardwarePayload({
cpu: { usage_percent: 0.9, temperature: [70] } as any,
memory: { usage_percent: 0.85 } as any,
disk: [{ usage_percent: 0.95 }] as any,
}),
} as any);
const check = makeCheck({
cpu: { usage_percent: 0.9, temperature: [70] },
memory: { usage_percent: 0.85 },
disk: [{ usage_percent: 0.95 }],
});
const breaches = builder.extractThresholdBreaches(monitor, response);
const breaches = builder.extractThresholdBreaches(monitor, check);
const metrics = breaches.map((b) => b.metric);
expect(metrics).toContain("cpu");