add logic for entering/leaving maintenance windows, add tests

This commit is contained in:
Alex Holliday committed 2026-05-21 10:23:27 -07:00
1 parent 4f571a258c
commit abf66eed95
3 files changed
+284 -1

No files matched your search

@@ -1,6 +1,7 @@
import { IMaintenanceWindowsRepository, IMonitorsRepository } from "@/repositories/index.js";
import type { DurationUnit, MaintenanceWindow } from "@/types/index.js";
import { AppError } from "@/utils/AppError.js";
import { isWindowActive } from "@/utils/maintenanceWindow.js";
const SERVICE_NAME = "maintenanceWindowService";
@@ -145,6 +146,8 @@ export class MaintenanceWindowService implements IMaintenanceWindowService {
teamId: string;
body: Partial<Omit<MaintenanceWindow, "monitorIds">> & { monitors?: string[] };
}) => {
const existing = await this.maintenanceWindowsRepository.findById(id, teamId);
const { monitors, ...rest } = body;
const update: Partial<MaintenanceWindow> = rest;
@@ -162,6 +165,35 @@ export class MaintenanceWindowService implements IMaintenanceWindowService {
update.monitorIds = monitors;
}
return await this.maintenanceWindowsRepository.updateById(id, teamId, update);
const updated = await this.maintenanceWindowsRepository.updateById(id, teamId, update);
const now = new Date();
const wasActive = isWindowActive(existing, now);
const isActive = isWindowActive(updated, now);
const enteringMaintenance = isActive ? updated.monitorIds.filter((monitorId) => !wasActive || !existing.monitorIds.includes(monitorId)) : [];
const leavingCandidates = wasActive ? existing.monitorIds.filter((monitorId) => !isActive || !updated.monitorIds.includes(monitorId)) : [];
if (enteringMaintenance.length > 0) {
await this.monitorsRepository.updateByIds(enteringMaintenance, teamId, { status: "maintenance" });
}
if (leavingCandidates.length > 0) {
const otherWindows = await this.maintenanceWindowsRepository.findByMonitorIds(leavingCandidates, teamId, existing.id);
const stillCovered = new Set<string>();
for (const otherWindow of otherWindows) {
if (!isWindowActive(otherWindow, now)) continue;
for (const monitorId of otherWindow.monitorIds) {
if (leavingCandidates.includes(monitorId)) stillCovered.add(monitorId);
}
}
const toInitializing = leavingCandidates.filter((monitorId) => !stillCovered.has(monitorId));
if (toInitializing.length > 0) {
await this.monitorsRepository.updateByIds(toInitializing, teamId, { status: "initializing" });
}
}
return updated;
};
}
@@ -11,6 +11,7 @@ const createMaintenanceWindowsRepo = () =>
create: jest.fn().mockResolvedValue(makeWindow()),
findById: jest.fn().mockResolvedValue(makeWindow()),
findByMonitorId: jest.fn().mockResolvedValue([makeWindow()]),
findByMonitorIds: jest.fn().mockResolvedValue([]),
findByTeamId: jest.fn().mockResolvedValue([makeWindow()]),
updateById: jest.fn().mockResolvedValue(makeWindow()),
deleteById: jest.fn().mockResolvedValue(makeWindow()),
@@ -23,6 +24,7 @@ const createMonitorsRepo = () =>
{ id: "mon-1", teamId: "team-1" },
{ id: "mon-2", teamId: "team-1" },
]),
updateByIds: jest.fn().mockResolvedValue(0),
}) as unknown as jest.Mocked<IMonitorsRepository>;
const createService = (overrides?: {
@@ -51,6 +53,16 @@ const makeWindow = (overrides?: Partial<MaintenanceWindow>): MaintenanceWindow =
...overrides,
});
// A window whose start/end straddle "now" — active per isWindowActive
const makeActiveWindow = (overrides?: Partial<MaintenanceWindow>): MaintenanceWindow => {
const now = Date.now();
return makeWindow({
start: new Date(now - 60_000).toISOString(),
end: new Date(now + 60_000).toISOString(),
...overrides,
});
};
const defaultCreateParams = {
teamId: "team-1",
monitorIDs: ["mon-1", "mon-2"],
@@ -302,5 +314,149 @@ describe("MaintenanceWindowService", () => {
expect(monitorsRepository.findByIds).not.toHaveBeenCalled();
});
// ── transitions ──────────────────────────────────────────────────
it("does not touch monitor status when window was inactive and stays inactive", async () => {
// default fixture: start/end in 2026-04-10 (past) → inactive
const { service, monitorsRepository } = createService();
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { name: "Updated Name" },
});
expect(monitorsRepository.updateByIds).not.toHaveBeenCalled();
});
it("sets all monitors to maintenance when window transitions inactive → active", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeWindow({ monitorIds: ["mon-1", "mon-2"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"] }));
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { start: new Date(Date.now() - 60_000).toISOString() },
});
expect(monitorsRepository.updateByIds).toHaveBeenCalledTimes(1);
expect(monitorsRepository.updateByIds).toHaveBeenCalledWith(["mon-1", "mon-2"], "team-1", { status: "maintenance" });
});
it("sets all monitors to initializing when window transitions active → inactive", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"], active: false }));
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { active: false },
});
expect(monitorsRepository.updateByIds).toHaveBeenCalledTimes(1);
expect(monitorsRepository.updateByIds).toHaveBeenCalledWith(["mon-1", "mon-2"], "team-1", { status: "initializing" });
});
it("flips only newly added monitors to maintenance when window stays active", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"] }));
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { monitors: ["mon-1", "mon-2"] },
});
expect(monitorsRepository.updateByIds).toHaveBeenCalledTimes(1);
expect(monitorsRepository.updateByIds).toHaveBeenCalledWith(["mon-2"], "team-1", { status: "maintenance" });
});
it("flips only removed monitors to initializing when window stays active", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1"] }));
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { monitors: ["mon-1"] },
});
expect(monitorsRepository.updateByIds).toHaveBeenCalledTimes(1);
expect(monitorsRepository.updateByIds).toHaveBeenCalledWith(["mon-2"], "team-1", { status: "initializing" });
});
it("makes no monitor updates when window stays active and monitor set is unchanged", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"], name: "Renamed" }));
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { name: "Renamed" },
});
expect(monitorsRepository.updateByIds).not.toHaveBeenCalled();
});
it("does not flip a leaving monitor to initializing if another active window still covers it", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1", "mon-2"], active: false }));
(maintenanceWindowsRepository.findByMonitorIds as jest.Mock).mockResolvedValue([makeActiveWindow({ id: "mw-2", monitorIds: ["mon-2"] })]);
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { active: false },
});
expect(monitorsRepository.updateByIds).toHaveBeenCalledTimes(1);
expect(monitorsRepository.updateByIds).toHaveBeenCalledWith(["mon-1"], "team-1", { status: "initializing" });
});
it("excludes the current window from the overlap check", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1"], active: false }));
const { service } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { active: false },
});
expect(maintenanceWindowsRepository.findByMonitorIds).toHaveBeenCalledWith(["mon-1"], "team-1", "mw-1");
});
it("flips a leaving monitor to initializing if other windows covering it are inactive", async () => {
const maintenanceWindowsRepository = createMaintenanceWindowsRepo();
(maintenanceWindowsRepository.findById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1"] }));
(maintenanceWindowsRepository.updateById as jest.Mock).mockResolvedValue(makeActiveWindow({ monitorIds: ["mon-1"], active: false }));
(maintenanceWindowsRepository.findByMonitorIds as jest.Mock).mockResolvedValue([
makeWindow({ id: "mw-2", monitorIds: ["mon-1"], active: false }),
]);
const { service, monitorsRepository } = createService({ maintenanceWindowsRepository });
await service.editMaintenanceWindow({
id: "mw-1",
teamId: "team-1",
body: { active: false },
});
expect(monitorsRepository.updateByIds).toHaveBeenCalledWith(["mon-1"], "team-1", { status: "initializing" });
});
});
});
@@ -0,0 +1,95 @@
import { describe, expect, it } from "@jest/globals";
import { isWindowActive } from "../../../src/utils/maintenanceWindow.ts";
import type { MaintenanceWindow } from "../../../src/types/index.ts";
const makeWindow = (overrides?: Partial<MaintenanceWindow>): MaintenanceWindow => {
const now = Date.now();
return {
id: "mw-1",
monitorIds: ["mon-1"],
teamId: "team-1",
active: true,
name: "Scheduled Maintenance",
duration: 60,
durationUnit: "minutes",
repeat: 0,
start: new Date(now - 1000).toISOString(),
end: new Date(now + 1000).toISOString(),
createdAt: "2026-01-01T00:00:00Z",
updatedAt: "2026-01-01T00:00:00Z",
...overrides,
};
};
describe("isWindowActive", () => {
it("returns false when window.active is false even if dates span now", () => {
expect(isWindowActive(makeWindow({ active: false }))).toBe(false);
});
it("returns true for a one-time window where now is between start and end", () => {
expect(isWindowActive(makeWindow())).toBe(true);
});
it("returns false when the one-time window has not started yet", () => {
const now = Date.now();
expect(
isWindowActive(
makeWindow({
start: new Date(now + 60_000).toISOString(),
end: new Date(now + 120_000).toISOString(),
})
)
).toBe(false);
});
it("returns false when the one-time window has already ended", () => {
const now = Date.now();
expect(
isWindowActive(
makeWindow({
start: new Date(now - 120_000).toISOString(),
end: new Date(now - 60_000).toISOString(),
repeat: 0,
})
)
).toBe(false);
});
it("returns true when a recurring window's advanced occurrence covers now", () => {
const now = Date.now();
// 2h ago, 10-min window, hourly repeat — third occurrence (0h) covers now
expect(
isWindowActive(
makeWindow({
start: new Date(now - 7_200_000).toISOString(),
end: new Date(now - 7_200_000 + 600_000).toISOString(),
repeat: 3_600_000,
})
)
).toBe(true);
});
it("returns false when a recurring window's occurrences all miss now", () => {
const now = Date.now();
// 31min ago, 1-min window, hourly repeat → next occurrence ~29min from now
expect(
isWindowActive(
makeWindow({
start: new Date(now - 1_860_000).toISOString(),
end: new Date(now - 1_800_000).toISOString(),
repeat: 3_600_000,
})
)
).toBe(false);
});
it("respects the explicit `now` parameter for comparisons", () => {
const win = makeWindow({
start: "2026-01-15T11:00:00Z",
end: "2026-01-15T13:00:00Z",
});
expect(isWindowActive(win, new Date("2026-01-15T12:00:00Z"))).toBe(true);
expect(isWindowActive(win, new Date("2026-01-15T14:00:00Z"))).toBe(false);
expect(isWindowActive(win, new Date("2026-01-15T10:00:00Z"))).toBe(false);
});
});