From abf66eed9506740d75ac2957485801ed12996290 Mon Sep 17 00:00:00 2001 From: Alex Holliday Date: Thu, 21 May 2026 10:23:27 -0700 Subject: [PATCH] add logic for entering/leaving maintenance windows, add tests --- .../business/maintenanceWindowService.ts | 34 +++- .../services/maintenanceWindowService.test.ts | 156 ++++++++++++++++++ .../test/unit/utils/maintenanceWindow.test.ts | 95 +++++++++++ 3 files changed, 284 insertions(+), 1 deletion(-) create mode 100644 server/test/unit/utils/maintenanceWindow.test.ts diff --git a/server/src/service/business/maintenanceWindowService.ts b/server/src/service/business/maintenanceWindowService.ts index e56ad3757..541b028f5 100644 --- a/server/src/service/business/maintenanceWindowService.ts +++ b/server/src/service/business/maintenanceWindowService.ts @@ -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> & { monitors?: string[] }; }) => { + const existing = await this.maintenanceWindowsRepository.findById(id, teamId); + const { monitors, ...rest } = body; const update: Partial = 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(); + 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; }; } diff --git a/server/test/unit/services/maintenanceWindowService.test.ts b/server/test/unit/services/maintenanceWindowService.test.ts index 5ce64238a..ee3615d97 100644 --- a/server/test/unit/services/maintenanceWindowService.test.ts +++ b/server/test/unit/services/maintenanceWindowService.test.ts @@ -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; const createService = (overrides?: { @@ -51,6 +53,16 @@ const makeWindow = (overrides?: Partial): MaintenanceWindow = ...overrides, }); +// A window whose start/end straddle "now" — active per isWindowActive +const makeActiveWindow = (overrides?: Partial): 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" }); + }); }); }); diff --git a/server/test/unit/utils/maintenanceWindow.test.ts b/server/test/unit/utils/maintenanceWindow.test.ts new file mode 100644 index 000000000..5a3a39b6a --- /dev/null +++ b/server/test/unit/utils/maintenanceWindow.test.ts @@ -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 => { + 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); + }); +});