From 365987c28736683beeb012b0661e3a195b1b19d4 Mon Sep 17 00:00:00 2001 From: Alex Holliday Date: Wed, 8 Apr 2026 10:31:24 -0700 Subject: [PATCH] relocate tests, add statusService tests --- server/package-lock.json | 86 -- server/package.json | 3 +- .../service/infrastructure/statusService.ts | 18 +- server/test/{ => unit}/monitorService.test.ts | 4 +- server/test/unit/statusService.test.ts | 889 ++++++++++++++++++ .../{ => unit}/superSimpleQueueHelper.test.ts | 6 +- server/test/{ => unit}/teamsProvider.test.ts | 8 +- 7 files changed, 906 insertions(+), 108 deletions(-) rename server/test/{ => unit}/monitorService.test.ts (98%) create mode 100644 server/test/unit/statusService.test.ts rename server/test/{ => unit}/superSimpleQueueHelper.test.ts (95%) rename server/test/{ => unit}/teamsProvider.test.ts (96%) diff --git a/server/package-lock.json b/server/package-lock.json index 067a46b64..1b9061d0c 100644 --- a/server/package-lock.json +++ b/server/package-lock.json @@ -69,7 +69,6 @@ "@types/ws": "^8.18.1", "@typescript-eslint/eslint-plugin": "^8.56.1", "@typescript-eslint/parser": "^8.56.1", - "c8": "10.1.3", "eslint": "^9.17.0", "eslint-plugin-mocha": "^10.5.0", "esm": "3.2.25", @@ -1358,16 +1357,6 @@ "integrity": "sha512-wMue2Sy4GAVTk6Ic4tJVcnfdau+gx2EnG7S+uAEe+TWJFqE4YoWN4/H8MSLj4eYJKxGg26lZwboEniNiNwZQ6Q==", "license": "Apache-2.0" }, - "node_modules/@bcoe/v8-coverage": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz", - "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - } - }, "node_modules/@colors/colors": { "version": "1.6.0", "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.6.0.tgz", @@ -6053,40 +6042,6 @@ "node": ">= 0.8" } }, - "node_modules/c8": { - "version": "10.1.3", - "resolved": "https://registry.npmjs.org/c8/-/c8-10.1.3.tgz", - "integrity": "sha512-LvcyrOAaOnrrlMpW22n690PUvxiq4Uf9WMhQwNJ9vgagkL/ph1+D4uvjvDA5XCbykrc0sx+ay6pVi9YZ1GnhyA==", - "dev": true, - "license": "ISC", - "dependencies": { - "@bcoe/v8-coverage": "^1.0.1", - "@istanbuljs/schema": "^0.1.3", - "find-up": "^5.0.0", - "foreground-child": "^3.1.1", - "istanbul-lib-coverage": "^3.2.0", - "istanbul-lib-report": "^3.0.1", - "istanbul-reports": "^3.1.6", - "test-exclude": "^7.0.1", - "v8-to-istanbul": "^9.0.0", - "yargs": "^17.7.2", - "yargs-parser": "^21.1.1" - }, - "bin": { - "c8": "bin/c8.js" - }, - "engines": { - "node": ">=18" - }, - "peerDependencies": { - "monocart-coverage-reports": "^2" - }, - "peerDependenciesMeta": { - "monocart-coverage-reports": { - "optional": true - } - } - }, "node_modules/cacheable-lookup": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz", @@ -14666,47 +14621,6 @@ "node": ">=6" } }, - "node_modules/test-exclude": { - "version": "7.0.1", - "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-7.0.1.tgz", - "integrity": "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==", - "dev": true, - "license": "ISC", - "dependencies": { - "@istanbuljs/schema": "^0.1.2", - "glob": "^10.4.1", - "minimatch": "^9.0.4" - }, - "engines": { - "node": ">=18" - } - }, - "node_modules/test-exclude/node_modules/brace-expansion": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz", - "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^1.0.0" - } - }, - "node_modules/test-exclude/node_modules/minimatch": { - "version": "9.0.9", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz", - "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==", - "dev": true, - "license": "ISC", - "dependencies": { - "brace-expansion": "^2.0.2" - }, - "engines": { - "node": ">=16 || 14 >=14.17" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "node_modules/text-hex": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz", diff --git a/server/package.json b/server/package.json index 4d1ab4c98..45057ccbf 100755 --- a/server/package.json +++ b/server/package.json @@ -5,7 +5,7 @@ "main": "index.js", "type": "module", "scripts": { - "test": "NODE_OPTIONS=--experimental-vm-modules c8 jest --runInBand", + "test": "NODE_OPTIONS=--experimental-vm-modules jest --coverage", "dev": "nodemon --exec tsx src/index.js", "start": "node --watch ./dist/index.js", "build": "tsc && tsc-alias && cp -r src/templates dist/templates", @@ -84,7 +84,6 @@ "@types/ws": "^8.18.1", "@typescript-eslint/eslint-plugin": "^8.56.1", "@typescript-eslint/parser": "^8.56.1", - "c8": "10.1.3", "eslint": "^9.17.0", "eslint-plugin-mocha": "^10.5.0", "esm": "3.2.25", diff --git a/server/src/service/infrastructure/statusService.ts b/server/src/service/infrastructure/statusService.ts index ef725b80a..1ade8f1f7 100755 --- a/server/src/service/infrastructure/statusService.ts +++ b/server/src/service/infrastructure/statusService.ts @@ -147,13 +147,7 @@ export class StatusService implements IStatusService { } // Calculate uptime percentage - let uptimePercentage; - if (stats.totalChecks > 0) { - uptimePercentage = stats.totalUpChecks / stats.totalChecks; - } else { - uptimePercentage = status === true ? 100 : 0; - } - stats.uptimePercentage = uptimePercentage; + stats.uptimePercentage = stats.totalUpChecks / stats.totalChecks; // latest check stats.lastCheckTimestamp = new Date().getTime(); @@ -268,7 +262,7 @@ export class StatusService implements IStatusService { let thresholdBreaches: { cpu: boolean; memory: boolean; disk: boolean; temp: boolean } | undefined; if (monitor.type === "hardware" && statusResponse.payload) { const payload = statusResponse.payload as HardwareStatusPayload; - const metrics = payload?.data; + const metrics = payload.data; if (metrics) { // Evaluate threshold breaches @@ -278,9 +272,11 @@ export class StatusService implements IStatusService { const memoryUsage = metrics.memory?.usage_percent ?? -1; const memoryBreach = memoryUsage !== -1 && memoryUsage > monitor.memoryAlertThreshold / 100; - const diskBreach = - metrics.disk?.some((d: CheckDiskInfo) => typeof d?.usage_percent === "number" && d.usage_percent > monitor.diskAlertThreshold / 100) ?? - false; + const diskBreach = metrics.disk + ? metrics.disk.some( + (d: CheckDiskInfo) => d != null && typeof d.usage_percent === "number" && d.usage_percent > monitor.diskAlertThreshold / 100 + ) + : false; const temps = metrics.cpu?.temperature ?? []; const tempBreach = temps.some((temp: number) => temp > monitor.tempAlertThreshold); diff --git a/server/test/monitorService.test.ts b/server/test/unit/monitorService.test.ts similarity index 98% rename from server/test/monitorService.test.ts rename to server/test/unit/monitorService.test.ts index 02e62c75b..598797bc5 100644 --- a/server/test/monitorService.test.ts +++ b/server/test/unit/monitorService.test.ts @@ -1,5 +1,5 @@ import { jest } from "@jest/globals"; -import { MonitorService } from "../src/service/business/monitorService.ts"; +import { MonitorService } from "../../src/service/business/monitorService.ts"; import type { IChecksRepository, IGeoChecksRepository, @@ -7,7 +7,7 @@ import type { IMonitorStatsRepository, IMonitorsRepository, IStatusPagesRepository, -} from "../src/repositories/index.ts"; +} from "../../src/repositories/index.ts"; const createMonitorsRepositoryMock = () => ({ diff --git a/server/test/unit/statusService.test.ts b/server/test/unit/statusService.test.ts new file mode 100644 index 000000000..ec42536ea --- /dev/null +++ b/server/test/unit/statusService.test.ts @@ -0,0 +1,889 @@ +import { describe, expect, it, jest, beforeEach } from "@jest/globals"; +import { StatusService } from "../../src/service/infrastructure/statusService.ts"; +import { createMockLogger } from "../helpers/createMockLogger.ts"; +import type { Monitor, MonitorStatusResponse, Check, HardwareStatusPayload } from "../../src/types/index.ts"; +import type { IMonitorsRepository, IMonitorStatsRepository, IChecksRepository } from "../../src/repositories/index.ts"; +import type { IBufferService } from "../../src/service/infrastructure/bufferService.ts"; + +// ── Helpers ────────────────────────────────────────────────────────────────── + +const createBuffer = (): jest.Mocked> => ({ + addToBuffer: jest.fn(), +}); + +const createMonitorsRepo = () => + ({ + findById: jest.fn(), + updateById: jest.fn(), + }) as unknown as jest.Mocked; + +const createMonitorStatsRepo = () => + ({ + findByMonitorId: jest.fn(), + create: jest.fn(), + updateByMonitorId: jest.fn(), + }) as unknown as jest.Mocked; + +const createChecksRepo = () => ({}) as unknown as jest.Mocked; + +const createService = (overrides?: { + logger?: ReturnType; + buffer?: ReturnType; + monitorsRepository?: ReturnType; + monitorStatsRepository?: ReturnType; + checksRepository?: ReturnType; +}) => { + const logger = overrides?.logger ?? createMockLogger(); + const buffer = overrides?.buffer ?? createBuffer(); + const monitorsRepository = overrides?.monitorsRepository ?? createMonitorsRepo(); + const monitorStatsRepository = overrides?.monitorStatsRepository ?? createMonitorStatsRepo(); + const checksRepository = overrides?.checksRepository ?? createChecksRepo(); + + const service = new StatusService(logger as any, buffer as any, monitorsRepository, monitorStatsRepository, checksRepository); + return { service, logger, buffer, monitorsRepository, monitorStatsRepository, checksRepository }; +}; + +const makeMonitor = (overrides?: Partial): Monitor => + ({ + id: "mon-1", + userId: "user-1", + teamId: "team-1", + name: "Test Monitor", + type: "http", + url: "https://example.com", + isActive: true, + interval: 60000, + status: "up", + statusWindow: [], + statusWindowSize: 5, + statusWindowThreshold: 80, + recentChecks: [], + cpuAlertThreshold: 80, + memoryAlertThreshold: 80, + diskAlertThreshold: 80, + tempAlertThreshold: 80, + cpuAlertCounter: 5, + memoryAlertCounter: 5, + diskAlertCounter: 5, + tempAlertCounter: 5, + createdAt: "2026-01-01T00:00:00Z", + updatedAt: "2026-01-01T00:00:00Z", + ...overrides, + }) as Monitor; + +const makeStatusResponse = (overrides?: Partial): MonitorStatusResponse => + ({ + monitorId: "mon-1", + teamId: "team-1", + type: "http", + status: true, + code: 200, + message: "OK", + responseTime: 100, + ...overrides, + }) as MonitorStatusResponse; + +const makeCheck = (overrides?: Partial): Check => + ({ + id: "check-1", + metadata: { monitorId: "mon-1", teamId: "team-1" }, + status: true, + responseTime: 100, + statusCode: 200, + message: "OK", + createdAt: "2026-01-01T00:00:00Z", + updatedAt: "2026-01-01T00:00:00Z", + ...overrides, + }) as Check; + +const makeExistingStats = (overrides?: Record) => ({ + id: "stats-1", + monitorId: "mon-1", + avgResponseTime: 100, + maxResponseTime: 200, + totalChecks: 10, + totalUpChecks: 9, + totalDownChecks: 1, + uptimePercentage: 0.9, + lastResponseTime: 90, + lastCheckTimestamp: 1000, + timeOfLastFailure: 500, + createdAt: "2026-01-01T00:00:00Z", + updatedAt: "2026-01-01T00:00:00Z", + ...overrides, +}); + +// ── Tests ──────────────────────────────────────────────────────────────────── + +describe("StatusService", () => { + describe("serviceName", () => { + it("returns StatusService", () => { + const { service } = createService(); + expect(service.serviceName).toBe("StatusService"); + }); + }); + + // ── updateRunningStats ─────────────────────────────────────────────────── + + describe("updateRunningStats", () => { + it("creates new stats when none exist", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockRejectedValue(new Error("not found")); + (monitorStatsRepository.create as jest.Mock).mockResolvedValue({}); + + const result = await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 50 })); + + expect(result).toBe(true); + expect(monitorStatsRepository.create).toHaveBeenCalledWith( + expect.objectContaining({ + monitorId: "mon-1", + totalChecks: 1, + totalUpChecks: 1, + avgResponseTime: 50, + lastResponseTime: 50, + }) + ); + }); + + it("updates existing stats for a successful check", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats()); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + const result = await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 110 })); + + expect(result).toBe(true); + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith( + "mon-1", + expect.objectContaining({ + totalChecks: 11, + totalUpChecks: 10, + totalDownChecks: 1, + }) + ); + }); + + it("increments totalDownChecks and resets timeOfLastFailure on failure", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats()); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ status: false, responseTime: 100 })); + + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith( + "mon-1", + expect.objectContaining({ + totalDownChecks: 2, + timeOfLastFailure: 0, + }) + ); + }); + + it("sets timeOfLastFailure when status is up and it was previously 0", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ timeOfLastFailure: 0 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ status: true })); + + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith( + "mon-1", + expect.objectContaining({ + timeOfLastFailure: expect.any(Number), + }) + ); + const call = (monitorStatsRepository.updateByMonitorId as jest.Mock).mock.calls[0] as [string, Record]; + expect(call[1].timeOfLastFailure).toBeGreaterThan(0); + }); + + it("updates maxResponseTime when new response is higher", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ maxResponseTime: 200 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 300 })); + + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith("mon-1", expect.objectContaining({ maxResponseTime: 300 })); + }); + + it("does not update maxResponseTime when new response is lower", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ maxResponseTime: 200 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 50 })); + + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith("mon-1", expect.objectContaining({ maxResponseTime: 200 })); + }); + + it("initializes avgResponseTime when previous avg was 0", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ avgResponseTime: 0 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 75 })); + + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith("mon-1", expect.objectContaining({ avgResponseTime: 75 })); + }); + + it("computes running average when avgResponseTime is nonzero", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ avgResponseTime: 100, totalChecks: 10 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 210 })); + + const call = (monitorStatsRepository.updateByMonitorId as jest.Mock).mock.calls[0] as [string, Record]; + // (100 * 10 + 210) / 11 = 110 + expect(call[1].avgResponseTime).toBe(110); + }); + + it("leaves avgResponseTime unchanged when responseTime is undefined", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ avgResponseTime: 100 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: undefined })); + + expect(monitorStatsRepository.updateByMonitorId).toHaveBeenCalledWith("mon-1", expect.objectContaining({ avgResponseTime: 100 })); + }); + + it("handles responseTime of 0 (falsy but defined)", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats({ avgResponseTime: 100, maxResponseTime: 200 })); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockResolvedValue({}); + + await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 0 })); + + const call = (monitorStatsRepository.updateByMonitorId as jest.Mock).mock.calls[0] as [string, Record]; + expect(call[1].lastResponseTime).toBe(0); + // responseTime 0 is falsy, so maxResponseTime stays unchanged + expect(call[1].maxResponseTime).toBe(200); + }); + + it("returns false and logs error when an exception is thrown", async () => { + const { service, logger, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats()); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockRejectedValue(new Error("db write failed")); + + const result = await service.updateRunningStats(makeMonitor(), makeStatusResponse()); + + expect(result).toBe(false); + expect(logger.error).toHaveBeenCalledWith( + expect.objectContaining({ + service: "StatusService", + method: "updateRunningStats", + message: "db write failed", + }) + ); + }); + + it("logs error with 'Unknown error' for non-Error exceptions", async () => { + const { service, logger, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(makeExistingStats()); + (monitorStatsRepository.updateByMonitorId as jest.Mock).mockRejectedValue("string error"); + + const result = await service.updateRunningStats(makeMonitor(), makeStatusResponse()); + + expect(result).toBe(false); + expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ message: "Unknown error", stack: undefined })); + }); + + it("creates new stats when findByMonitorId resolves to null", async () => { + const { service, monitorStatsRepository } = createService(); + (monitorStatsRepository.findByMonitorId as jest.Mock).mockResolvedValue(null); + (monitorStatsRepository.create as jest.Mock).mockResolvedValue({}); + + const result = await service.updateRunningStats(makeMonitor(), makeStatusResponse({ responseTime: 50, status: true })); + + expect(result).toBe(true); + expect(monitorStatsRepository.create).toHaveBeenCalled(); + }); + }); + + // ── updateMonitorStatus ────────────────────────────────────────────────── + + describe("updateMonitorStatus", () => { + it("returns early with no status change when statusWindow is not full", async () => { + const monitor = makeMonitor({ statusWindow: [], statusWindowSize: 5, status: "up" }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse({ status: true }), makeCheck()); + + expect(result.statusChanged).toBe(false); + expect(result.prevStatus).toBe("up"); + }); + + it("pushes to statusWindow and trims to statusWindowSize", async () => { + const monitor = makeMonitor({ statusWindow: [true, true, true, true, true], statusWindowSize: 5 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + await service.updateMonitorStatus(makeStatusResponse({ status: false }), makeCheck()); + + // Window should have shifted: [true, true, true, true, false] + expect(monitor.statusWindow).toHaveLength(5); + expect(monitor.statusWindow[4]).toBe(false); + }); + + it("pushes check snapshot to recentChecks and trims to 25", async () => { + const existingChecks = Array.from({ length: 25 }, (_, i) => ({ id: `old-${i}` })); + const monitor = makeMonitor({ recentChecks: existingChecks as any, statusWindow: [], statusWindowSize: 5 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + await service.updateMonitorStatus(makeStatusResponse(), makeCheck({ id: "new-check" })); + + expect(monitor.recentChecks).toHaveLength(25); + expect(monitor.recentChecks[24]).toEqual(expect.objectContaining({ id: "new-check" })); + }); + + it("marks status as down when failure threshold is met", async () => { + // 5/5 failures = 100% >= 80% threshold + const monitor = makeMonitor({ + statusWindow: [false, false, false, false], + statusWindowSize: 5, + statusWindowThreshold: 80, + status: "up", + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse({ status: false }), makeCheck({ status: false })); + + expect(result.statusChanged).toBe(true); + expect(result.monitor.status).toBe("down"); + }); + + it("recovers to up when failure rate drops below threshold", async () => { + // 1/5 failures = 20% < 80% threshold, and monitor was down + const monitor = makeMonitor({ + statusWindow: [true, true, true, false], + statusWindowSize: 5, + statusWindowThreshold: 80, + status: "down", + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse({ status: true }), makeCheck({ status: true })); + + expect(result.statusChanged).toBe(true); + expect(result.monitor.status).toBe("up"); + }); + + it("does not change status when already up and below threshold", async () => { + const monitor = makeMonitor({ + statusWindow: [true, true, true, true], + statusWindowSize: 5, + statusWindowThreshold: 80, + status: "up", + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse({ status: true }), makeCheck()); + + expect(result.statusChanged).toBe(false); + expect(result.monitor.status).toBe("up"); + }); + + it("does not change status when already down and still above threshold", async () => { + const monitor = makeMonitor({ + statusWindow: [false, false, false, false], + statusWindowSize: 5, + statusWindowThreshold: 80, + status: "down", + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse({ status: false }), makeCheck({ status: false })); + + expect(result.statusChanged).toBe(false); + expect(result.monitor.status).toBe("down"); + }); + + it("initializes statusWindow when undefined", async () => { + const monitor = makeMonitor({ statusWindow: undefined as any, statusWindowSize: 5 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + await service.updateMonitorStatus(makeStatusResponse(), makeCheck()); + + expect(monitor.statusWindow).toEqual([true]); + }); + + it("initializes recentChecks when undefined", async () => { + const monitor = makeMonitor({ recentChecks: undefined as any, statusWindowSize: 5 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + await service.updateMonitorStatus(makeStatusResponse(), makeCheck()); + + expect(monitor.recentChecks).toHaveLength(1); + }); + + it("throws AppError when repository throws", async () => { + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockRejectedValue(new Error("db error")); + + await expect(service.updateMonitorStatus(makeStatusResponse(), makeCheck())).rejects.toThrow("Failed to update monitor"); + }); + + it("throws AppError with 'Unknown error' for non-Error exceptions", async () => { + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockRejectedValue("string error"); + + await expect(service.updateMonitorStatus(makeStatusResponse(), makeCheck())).rejects.toThrow("Unknown error"); + }); + + it("returns code and timestamp in result", async () => { + const monitor = makeMonitor({ statusWindow: [true, true, true, true], statusWindowSize: 5 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse({ code: 201 }), makeCheck()); + + expect(result.code).toBe(201); + expect(result.timestamp).toBeGreaterThan(0); + }); + + // ── Hardware threshold breach tests ────────────────────────────────── + + describe("hardware threshold breaches", () => { + const makeHardwareMonitor = (overrides?: Partial) => + makeMonitor({ + type: "hardware", + statusWindow: [true, true, true, true], + statusWindowSize: 5, + status: "up", + cpuAlertThreshold: 80, + memoryAlertThreshold: 80, + diskAlertThreshold: 80, + tempAlertThreshold: 80, + cpuAlertCounter: 5, + memoryAlertCounter: 5, + diskAlertCounter: 5, + tempAlertCounter: 5, + ...overrides, + }); + + const makeHardwareResponse = (payload: HardwareStatusPayload, overrides?: Partial>) => + makeStatusResponse({ + type: "hardware", + status: true, + payload, + ...overrides, + } as any) as MonitorStatusResponse; + + it("detects CPU threshold breach and decrements counter", async () => { + const monitor = makeHardwareMonitor({ cpuAlertCounter: 1 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ data: { cpu: { usage_percent: 0.9 }, memory: { usage_percent: 0.5 }, disk: [], host: {} } } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.cpu).toBe(true); + expect(result.thresholdBreaches?.memory).toBe(false); + expect(monitor.cpuAlertCounter).toBe(0); + expect(result.statusChanged).toBe(true); + expect(result.monitor.status).toBe("breached"); + }); + + it("detects memory threshold breach", async () => { + const monitor = makeHardwareMonitor({ memoryAlertCounter: 1 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ data: { cpu: { usage_percent: 0.5 }, memory: { usage_percent: 0.9 }, disk: [], host: {} } } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.memory).toBe(true); + expect(monitor.memoryAlertCounter).toBe(0); + expect(result.monitor.status).toBe("breached"); + }); + + it("detects disk threshold breach", async () => { + const monitor = makeHardwareMonitor({ diskAlertCounter: 1 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1 }, memory: { usage_percent: 0.1 }, disk: [{ usage_percent: 0.95 }], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.disk).toBe(true); + expect(monitor.diskAlertCounter).toBe(0); + expect(result.monitor.status).toBe("breached"); + }); + + it("detects temperature threshold breach", async () => { + const monitor = makeHardwareMonitor({ tempAlertCounter: 1 }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1, temperature: [90] }, memory: { usage_percent: 0.1 }, disk: [], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.temp).toBe(true); + expect(monitor.tempAlertCounter).toBe(0); + expect(result.monitor.status).toBe("breached"); + }); + + it("resets counters to 5 when thresholds are not breached", async () => { + const monitor = makeHardwareMonitor({ + cpuAlertCounter: 2, + memoryAlertCounter: 2, + diskAlertCounter: 2, + tempAlertCounter: 2, + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1, temperature: [30] }, memory: { usage_percent: 0.1 }, disk: [{ usage_percent: 0.1 }], host: {} }, + } as any); + await service.updateMonitorStatus(response, makeCheck()); + + expect(monitor.cpuAlertCounter).toBe(5); + expect(monitor.memoryAlertCounter).toBe(5); + expect(monitor.diskAlertCounter).toBe(5); + expect(monitor.tempAlertCounter).toBe(5); + }); + + it("stays breached without statusChanged when already breached and counter still at 0", async () => { + const monitor = makeHardwareMonitor({ + status: "breached", + cpuAlertCounter: 1, + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ data: { cpu: { usage_percent: 0.9 }, memory: { usage_percent: 0.1 }, disk: [], host: {} } } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.monitor.status).toBe("breached"); + expect(result.statusChanged).toBe(false); + }); + + it("recovers from breached to up when all thresholds return to normal", async () => { + const monitor = makeHardwareMonitor({ status: "breached" }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1, temperature: [30] }, memory: { usage_percent: 0.1 }, disk: [{ usage_percent: 0.1 }], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.statusChanged).toBe(true); + expect(result.monitor.status).toBe("up"); + }); + + it("does not override down status with breached", async () => { + // Monitor is down due to failure threshold, hardware breaches should not override + const monitor = makeHardwareMonitor({ + statusWindow: [false, false, false, false], + statusWindowSize: 5, + statusWindowThreshold: 80, + status: "up", + cpuAlertCounter: 1, + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + status: false, + data: { cpu: { usage_percent: 0.9 }, memory: { usage_percent: 0.1 }, disk: [], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck({ status: false })); + + expect(result.monitor.status).toBe("down"); + }); + + it("handles missing cpu usage_percent (returns -1)", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ data: { cpu: {}, memory: { usage_percent: 0.1 }, disk: [], host: {} } } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.cpu).toBe(false); + }); + + it("handles missing memory usage_percent", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ data: { cpu: { usage_percent: 0.1 }, memory: {}, disk: [], host: {} } } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.memory).toBe(false); + }); + + it("handles empty temperature array", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1, temperature: [] }, memory: { usage_percent: 0.1 }, disk: [], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.temp).toBe(false); + }); + + it("handles undefined temperature", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1 }, memory: { usage_percent: 0.1 }, disk: [], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.temp).toBe(false); + }); + + it("skips threshold evaluation when payload is undefined", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse(undefined as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches).toBeUndefined(); + }); + + it("skips threshold evaluation when payload.data is undefined", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({} as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches).toBeUndefined(); + }); + + it("does not set thresholdBreaches for non-hardware monitors", async () => { + const monitor = makeMonitor({ + type: "http", + statusWindow: [true, true, true, true], + statusWindowSize: 5, + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const result = await service.updateMonitorStatus(makeStatusResponse(), makeCheck()); + + expect(result.thresholdBreaches).toBeUndefined(); + }); + + it("handles null entry in disk array", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1 }, memory: { usage_percent: 0.1 }, disk: [null as any], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.disk).toBe(false); + }); + + it("handles disk with undefined usage_percent entries", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1 }, memory: { usage_percent: 0.1 }, disk: [{ device: "/dev/sda" }], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.disk).toBe(false); + }); + + it("handles nullish cpu in metrics", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: undefined, memory: { usage_percent: 0.1 }, disk: [], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.cpu).toBe(false); + expect(result.thresholdBreaches?.temp).toBe(false); + }); + + it("handles nullish memory in metrics", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1 }, memory: undefined, disk: [], host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.memory).toBe(false); + }); + + it("handles nullish disk in metrics", async () => { + const monitor = makeHardwareMonitor(); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.1 }, memory: { usage_percent: 0.1 }, disk: undefined, host: {} }, + } as any); + const result = await service.updateMonitorStatus(response, makeCheck()); + + expect(result.thresholdBreaches?.disk).toBe(false); + }); + + it("counters do not go below 0", async () => { + const monitor = makeHardwareMonitor({ + cpuAlertCounter: 0, + memoryAlertCounter: 0, + diskAlertCounter: 0, + tempAlertCounter: 0, + }); + const { service, monitorsRepository } = createService(); + (monitorsRepository.findById as jest.Mock).mockResolvedValue(monitor); + (monitorsRepository.updateById as jest.Mock).mockImplementation((_id: unknown, _tid: unknown, m: unknown) => Promise.resolve(m)); + + const response = makeHardwareResponse({ + data: { cpu: { usage_percent: 0.9, temperature: [90] }, memory: { usage_percent: 0.9 }, disk: [{ usage_percent: 0.95 }], host: {} }, + } as any); + await service.updateMonitorStatus(response, makeCheck()); + + expect(monitor.cpuAlertCounter).toBe(0); + expect(monitor.memoryAlertCounter).toBe(0); + expect(monitor.diskAlertCounter).toBe(0); + expect(monitor.tempAlertCounter).toBe(0); + }); + }); + }); + + // ── insertCheck ────────────────────────────────────────────────────────── + + describe("insertCheck", () => { + it("adds check to buffer and returns true", async () => { + const { service, buffer } = createService(); + const check = makeCheck(); + + const result = await service.insertCheck(check); + + expect(result).toBe(true); + expect(buffer.addToBuffer).toHaveBeenCalledWith(check); + }); + + it("returns false and logs warning when check is undefined", async () => { + const { service, logger } = createService(); + + const result = await service.insertCheck(undefined as any); + + expect(result).toBe(false); + expect(logger.warn).toHaveBeenCalledWith( + expect.objectContaining({ + message: "Failed to build check", + service: "StatusService", + method: "insertCheck", + }) + ); + }); + + it("logs error when buffer throws", async () => { + const buffer = createBuffer(); + (buffer.addToBuffer as jest.Mock).mockImplementation(() => { + throw new Error("buffer full"); + }); + const { service, logger } = createService({ buffer }); + + const result = await service.insertCheck(makeCheck()); + + expect(result).toBeUndefined(); + expect(logger.error).toHaveBeenCalledWith( + expect.objectContaining({ + message: "buffer full", + service: "StatusService", + method: "insertCheck", + }) + ); + }); + + it("handles nullish check in error path", async () => { + const buffer = createBuffer(); + (buffer.addToBuffer as jest.Mock).mockImplementation(() => { + throw new Error("boom"); + }); + const { service, logger } = createService({ buffer }); + + await service.insertCheck(null as any); + + expect(logger.error).toHaveBeenCalledWith( + expect.objectContaining({ + details: { msg: "Error inserting check for monitor: undefined" }, + }) + ); + }); + + it("logs 'Unknown error' for non-Error exceptions in insertCheck", async () => { + const buffer = createBuffer(); + (buffer.addToBuffer as jest.Mock).mockImplementation(() => { + throw "string error"; + }); + const { service, logger } = createService({ buffer }); + + await service.insertCheck(makeCheck()); + + expect(logger.error).toHaveBeenCalledWith(expect.objectContaining({ message: "Unknown error", stack: undefined })); + }); + }); +}); diff --git a/server/test/superSimpleQueueHelper.test.ts b/server/test/unit/superSimpleQueueHelper.test.ts similarity index 95% rename from server/test/superSimpleQueueHelper.test.ts rename to server/test/unit/superSimpleQueueHelper.test.ts index 25db19dbc..8a24718b6 100644 --- a/server/test/superSimpleQueueHelper.test.ts +++ b/server/test/unit/superSimpleQueueHelper.test.ts @@ -1,7 +1,7 @@ import { describe, expect, it, jest } from "@jest/globals"; -import { SuperSimpleQueueHelper } from "../src/service/infrastructure/SuperSimpleQueue/SuperSimpleQueueHelper.ts"; -import type { Monitor } from "../src/types/monitor.ts"; -import { createMockLogger } from "./helpers/createMockLogger.ts"; +import { SuperSimpleQueueHelper } from "../../src/service/infrastructure/SuperSimpleQueue/SuperSimpleQueueHelper.ts"; +import type { Monitor } from "../../src/types/monitor.ts"; +import { createMockLogger } from "../helpers/createMockLogger.ts"; const createHelper = (overrides?: Record) => { const maintenanceWindowsRepository = { diff --git a/server/test/teamsProvider.test.ts b/server/test/unit/teamsProvider.test.ts similarity index 96% rename from server/test/teamsProvider.test.ts rename to server/test/unit/teamsProvider.test.ts index d63324f9b..6640826f3 100644 --- a/server/test/teamsProvider.test.ts +++ b/server/test/unit/teamsProvider.test.ts @@ -1,7 +1,7 @@ import { describe, expect, it, jest, beforeEach } from "@jest/globals"; -import type { Notification } from "../src/types/notification.ts"; -import type { NotificationMessage } from "../src/types/notificationMessage.ts"; -import { createMockLogger } from "./helpers/createMockLogger.ts"; +import type { Notification } from "../../src/types/notification.ts"; +import type { NotificationMessage } from "../../src/types/notificationMessage.ts"; +import { createMockLogger } from "../helpers/createMockLogger.ts"; const mockPost = jest.fn(); jest.unstable_mockModule("got", () => ({ @@ -9,7 +9,7 @@ jest.unstable_mockModule("got", () => ({ HTTPError: class HTTPError extends Error {}, })); -const { TeamsProvider } = await import("../src/service/infrastructure/notificationProviders/teams.ts"); +const { TeamsProvider } = await import("../../src/service/infrastructure/notificationProviders/teams.ts"); const createNotification = (overrides?: Partial): Notification => ({ id: "notif-1",