From 1e26fb1e3b18a0854ed08f06e1ab801750c1e9b0 Mon Sep 17 00:00:00 2001 From: Alex Holliday Date: Mon, 24 Nov 2025 22:49:55 +0000 Subject: [PATCH] improve test coverage --- server/jest.config.mjs | 69 ++++++---- server/src/controllers/InviteController.ts | 15 +- server/src/controllers/RecoveryController.ts | 8 +- .../src/controllers/TeamMemberController.ts | 6 +- server/src/db/models/auth/TeamMembership.ts | 21 --- server/src/init/controllers.ts | 5 +- server/src/services/business/InviteService.ts | 10 ++ .../services/business/TeamMemberServices.ts | 16 ++- .../NotificationServices/Email.ts | 11 +- .../tests/middleware/AddUserContext.test.js | 55 ++++++++ .../infrastructure/DiscordService.test.js | 26 +++- .../infrastructure/EmailService.test.js | 129 +++++++++++++++++- .../NotificationService.test.js | 43 ++++++ .../infrastructure/SlackService.test.js | 21 +++ .../infrastructure/WebhookService.test.js | 24 +++- 15 files changed, 388 insertions(+), 71 deletions(-) diff --git a/server/jest.config.mjs b/server/jest.config.mjs index f6ea9ba73..dc3d037b5 100644 --- a/server/jest.config.mjs +++ b/server/jest.config.mjs @@ -1,35 +1,46 @@ /** @type {import('jest').Config} */ const config = { - preset: "ts-jest/presets/default-esm", - testEnvironment: "node", - rootDir: "./", - roots: ["/tests"], - testMatch: ["**/*.test.ts", "**/*.test.js"], - verbose: true, - moduleNameMapper: { - "^@/(.*)\\.js$": "/src/$1.ts", - "^@/(.*)$": "/src/$1", - "^(\\.\\.?/.*)\\.js$": "$1" - }, - extensionsToTreatAsEsm: [".ts"], - transform: { - "^.+\\.(t|j)s$": ["ts-jest", { useESM: true, tsconfig: "./tsconfig.jest.json" }] - }, - transformIgnorePatterns: [ - "/node_modules/" + preset: "ts-jest/presets/default-esm", + testEnvironment: "node", + rootDir: "./", + roots: ["/tests"], + testMatch: ["**/*.test.ts", "**/*.test.js"], + verbose: true, + moduleNameMapper: { + "^@/(.*)\\.js$": "/src/$1.ts", + "^@/(.*)$": "/src/$1", + "^(\\.\\.?/.*)\\.js$": "$1", + }, + extensionsToTreatAsEsm: [".ts"], + transform: { + "^.+\\.(t|j)s$": [ + "ts-jest", + { useESM: true, tsconfig: "./tsconfig.jest.json" }, ], - collectCoverageFrom: ["src/**/*.{ts,js}", "!src/**/*.d.ts"], - coverageDirectory: "coverage", - coverageReporters: ["text", "lcov"], - coveragePathIgnorePatterns: ["/node_modules/", "/src/index.ts"], - coverageThreshold: { - global: { - branches: 80, - functions: 90, - lines: 90, - statements: 90, - }, - }, + }, + transformIgnorePatterns: ["/node_modules/"], + collectCoverageFrom: [ + "src/services/**/*.{ts,js}", + "src/middleware/**/*.{ts,js}", + "!src/**/*.d.ts", + ], + coverageDirectory: "coverage", + coverageReporters: ["text", "lcov"], + coveragePathIgnorePatterns: [ + "/node_modules/", + "/src/index.ts", + "/src/db/", + "/src/logger/", + "/src/types/", + ], + coverageThreshold: { + global: { + branches: 80, + functions: 90, + lines: 90, + statements: 90, + }, + }, }; export default config; diff --git a/server/src/controllers/InviteController.ts b/server/src/controllers/InviteController.ts index 888926b60..c3df0229b 100644 --- a/server/src/controllers/InviteController.ts +++ b/server/src/controllers/InviteController.ts @@ -1,11 +1,14 @@ import { Request, Response, NextFunction } from "express"; -import InviteService from "@/services/business/InviteService.js"; import ApiError from "@/utils/ApiError.js"; +import { EmailService, InviteService } from "@/services/index.js"; +import { config } from "@/config/index.js"; class InviteController { + private emailService: EmailService; private inviteService: InviteService; - constructor(inviteService: InviteService) { + constructor(inviteService: InviteService, emailService: EmailService) { this.inviteService = inviteService; + this.emailService = emailService; } create = async (req: Request, res: Response, next: NextFunction) => { @@ -36,6 +39,14 @@ class InviteController { teamId, teamRoleId ); + + try { + this.emailService.sendGeneric(email, "You're invited!", { + text: `You have been invited to join Checkmate. Use this link to accept the invite: ${config.ORIGIN}/register/${invite}`, + }); + } catch (error) { + console.error("Failed to send invite email:", error); + } res.status(201).json({ message: "OK", data: invite }); } catch (error: any) { next(error); diff --git a/server/src/controllers/RecoveryController.ts b/server/src/controllers/RecoveryController.ts index 7c6ee590e..9430cf27f 100644 --- a/server/src/controllers/RecoveryController.ts +++ b/server/src/controllers/RecoveryController.ts @@ -49,11 +49,9 @@ class RecoveryController implements IRecoveryController { const recoveryToken = await this.recoveryService.create(user._id); // Don't wait for email to be sent this.emailService - .sendGeneric( - user.email, - "Password Recovery", - `Your recovery link is: ${config.ORIGIN}/recovery/${recoveryToken}` - ) + .sendGeneric(user.email, "Password Recovery", { + text: `Your recovery link is: ${config.ORIGIN}/recovery/${recoveryToken}`, + }) .catch((error) => { logger.error(error); }); diff --git a/server/src/controllers/TeamMemberController.ts b/server/src/controllers/TeamMemberController.ts index e11b63d6c..4e75926fa 100644 --- a/server/src/controllers/TeamMemberController.ts +++ b/server/src/controllers/TeamMemberController.ts @@ -143,12 +143,14 @@ class TeamMemberController implements ITeamMemberController { } const teamMemberId = req.params.id; - if (!req.params.id) { + if (!teamMemberId) { throw new ApiError("No team member ID", 400); } - const deleted = await this.teamMemberService.delete(orgId, req.params.id); + console.log(teamMemberId); + const deleted = await this.teamMemberService.delete(orgId, teamMemberId); + invalidateCachesForUser(teamMemberId); if (!deleted) { throw new ApiError("Failed to delete team member", 500); } diff --git a/server/src/db/models/auth/TeamMembership.ts b/server/src/db/models/auth/TeamMembership.ts index aef296aa8..53e9a0a51 100644 --- a/server/src/db/models/auth/TeamMembership.ts +++ b/server/src/db/models/auth/TeamMembership.ts @@ -24,27 +24,6 @@ teamMembershipSchema.post("save", async function (doc) { invalidateCachesForUser(doc.userId.toString()); }); -teamMembershipSchema.post( - "deleteOne", - { document: true, query: false }, - async function (doc) { - invalidateCachesForUser(doc.userId.toString()); - } -); - -teamMembershipSchema.post("findOneAndDelete", function (doc: ITeamMembership) { - if (!doc) return; - invalidateCachesForUser(doc.userId.toString()); -}); - -teamMembershipSchema.post( - "findOneAndUpdate", - async function (doc: ITeamMembership) { - if (!doc) return; - invalidateCachesForUser(doc.userId.toString()); - } -); - export const TeamMembership = mongoose.model( "TeamMembership", teamMembershipSchema diff --git a/server/src/init/controllers.ts b/server/src/init/controllers.ts index 544f76586..b3200b576 100644 --- a/server/src/init/controllers.ts +++ b/server/src/init/controllers.ts @@ -24,7 +24,10 @@ export const initControllers = (services: any) => { services.authService, services.inviteService ); - controllers.inviteController = new InviteController(services.inviteService); + controllers.inviteController = new InviteController( + services.inviteService, + services.emailService + ); controllers.maintenanceController = new MaintenanceController( services.maintenanceService ); diff --git a/server/src/services/business/InviteService.ts b/server/src/services/business/InviteService.ts index 77e0a6ab5..7989e69c9 100644 --- a/server/src/services/business/InviteService.ts +++ b/server/src/services/business/InviteService.ts @@ -69,6 +69,16 @@ class InviteService implements IInviteService { throw new ApiError("User is already a team member", 409); } + // Check if inivite already exists + const existingInvite = await Invite.findOne({ + email, + teamId, + }); + + if (existingInvite) { + throw new ApiError("An invite already exists for this email", 409); + } + const token = crypto.randomBytes(32).toString("hex"); const tokenHash = crypto.createHash("sha256").update(token).digest("hex"); diff --git a/server/src/services/business/TeamMemberServices.ts b/server/src/services/business/TeamMemberServices.ts index 44840f181..f04646f19 100644 --- a/server/src/services/business/TeamMemberServices.ts +++ b/server/src/services/business/TeamMemberServices.ts @@ -10,6 +10,7 @@ import { IOrgMembership, } from "@/db/models/index.js"; import ApiError from "@/utils/ApiError.js"; +import { invalidateCachesForUser } from "@/middleware/AddUserContext.js"; const SERVICE_NAME = "TeamMemberService"; export interface ITeamMemberService { @@ -117,11 +118,21 @@ class TeamMemberService implements ITeamMemberService { throw new ApiError("Role not found", 404); } - const teamMembership = await TeamMembership.findOneAndUpdate( + const updated = await TeamMembership.findOneAndUpdate( { orgId: orgId, _id: teamMembershipId }, { roleId: roleId }, { new: true } - ) + ); + + if (!updated) { + throw new ApiError("Team membership not found", 404); + } + invalidateCachesForUser(updated.userId.toString()); + + const teamMembership = await TeamMembership.findOne({ + orgId: orgId, + _id: teamMembershipId, + }) .populate("userId", "firstName lastName email") .populate("roleId", "name scope permissions"); @@ -140,6 +151,7 @@ class TeamMemberService implements ITeamMemberService { if (!tm) { throw new ApiError("Team member not found", 404); } + invalidateCachesForUser(tm.userId.toString()); await TeamMembership.findOneAndDelete({ _id: teamMemberId, orgId: orgId }); return true; }; diff --git a/server/src/services/infrastructure/NotificationServices/Email.ts b/server/src/services/infrastructure/NotificationServices/Email.ts index c652cfd58..b6714151c 100644 --- a/server/src/services/infrastructure/NotificationServices/Email.ts +++ b/server/src/services/infrastructure/NotificationServices/Email.ts @@ -33,7 +33,7 @@ export interface IEmailService extends IMessageService { sendGeneric: ( to: string, subject: string, - content: string + content: { text?: string; html?: string } ) => Promise; testTransport: (transport: IEmailTransport) => Promise; rebuildTransport: (transport: IEmailTransport) => Promise; @@ -186,7 +186,11 @@ class EmailService implements IEmailService { ); }; - sendGeneric = async (to: string, subject: string, content: string) => { + sendGeneric = async ( + to: string, + subject: string, + content: { text?: string; html?: string } + ) => { try { if (this.transporter === null) { this.transporter = await this.buildTransport(); @@ -196,7 +200,8 @@ class EmailService implements IEmailService { from: `"Checkmate" <${this.from}>`, to: to, subject: subject, - text: content, + text: content.text, + html: content.html, }); return true; } catch (error) { diff --git a/server/tests/middleware/AddUserContext.test.js b/server/tests/middleware/AddUserContext.test.js index f04d2c5f3..3dce89ec2 100644 --- a/server/tests/middleware/AddUserContext.test.js +++ b/server/tests/middleware/AddUserContext.test.js @@ -50,4 +50,59 @@ describe("addUserContext", () => { expect(req.user.roles.teamRole).toEqual({ name: "team-role" }); expect(req.user.currentTeamId).toBe("t-1"); }); + + it("uses cached teamIds and roles when cache valid", async () => { + // First call populates cache + jest.spyOn(Models.TeamMembership, "find").mockReturnValue({ select: () => ({ lean: () => [{ teamId: { toString: () => "t-1" } }] }) }); + const req1 = mockReq({ sub: "u-cache", orgId: "o1" }, { "x-team-id": "t-1" }); + const next1 = mockNext(); + await addUserContext(req1, mockRes(), next1); + expect(next1).toHaveBeenCalled(); + + // Second call should hit cache and still succeed; mock find to fail if called + jest.spyOn(Models.TeamMembership, "find").mockImplementation(() => { throw new Error("should not query"); }); + const req2 = mockReq({ sub: "u-cache", orgId: "o1" }, { "x-team-id": "t-1" }); + const next2 = mockNext(); + await addUserContext(req2, mockRes(), next2); + expect(next2).toHaveBeenCalled(); + }); + + it("invalidates caches for user", async () => { + // Warm caches + jest.spyOn(Models.TeamMembership, "find").mockReturnValue({ select: () => ({ lean: () => [{ teamId: { toString: () => "t-1" } }] }) }); + const req = mockReq({ sub: "u-inv", orgId: "o1" }, { "x-team-id": "t-1" }); + const next = mockNext(); + await addUserContext(req, mockRes(), next); + expect(next).toHaveBeenCalled(); + + // Invalidate and ensure it re-queries without throwing + invalidateCachesForUser("u-inv"); + jest.spyOn(Models.TeamMembership, "find").mockReturnValue({ select: () => ({ lean: () => [{ teamId: { toString: () => "t-1" } }] }) }); + const next2 = mockNext(); + await addUserContext(mockReq({ sub: "u-inv", orgId: "o1" }, { "x-team-id": "t-1" }), mockRes(), next2); + expect(next2).toHaveBeenCalled(); + }); + + it("throws when org role missing", async () => { + jest.spyOn(Models.TeamMembership, "find").mockReturnValue({ select: () => ({ lean: () => [{ teamId: { toString: () => "t-1" } }] }) }); + jest.spyOn(Models.OrgMembership, "findOne").mockReturnValue({ populate: () => ({ select: () => ({ lean: () => null }) }) }); + const req = mockReq({ sub: "u2", orgId: "o1" }, { "x-team-id": "t-1" }); + const next = mockNext(); + await addUserContext(req, mockRes(), next); + const err = next.mock.calls[0][0]; + expect(err).toBeInstanceOf(ApiError); + expect(err.status).toBe(403); + }); + + it("throws when team role missing", async () => { + jest.spyOn(Models.TeamMembership, "find").mockReturnValue({ select: () => ({ lean: () => [{ teamId: { toString: () => "t-1" } }] }) }); + jest.spyOn(Models.OrgMembership, "findOne").mockReturnValue({ populate: () => ({ select: () => ({ lean: () => ({ roleId: { name: "org-role" } }) }) }) }); + jest.spyOn(Models.TeamMembership, "findOne").mockReturnValue({ populate: () => ({ select: () => ({ lean: () => null }) }) }); + const req = mockReq({ sub: "u3", orgId: "o1" }, { "x-team-id": "t-1" }); + const next = mockNext(); + await addUserContext(req, mockRes(), next); + const err = next.mock.calls[0][0]; + expect(err).toBeInstanceOf(ApiError); + expect(err.status).toBe(403); + }); }); diff --git a/server/tests/services/infrastructure/DiscordService.test.js b/server/tests/services/infrastructure/DiscordService.test.js index 3fb89b0ad..1eed10a74 100644 --- a/server/tests/services/infrastructure/DiscordService.test.js +++ b/server/tests/services/infrastructure/DiscordService.test.js @@ -40,5 +40,29 @@ describe("DiscordService", () => { const alert = service.buildAlert(buildMonitor(), buildIncident()); await expect(service.sendMessage(alert, channel)).rejects.toBeInstanceOf(ApiError); }); -}); + it("returns false when webhook post fails", async () => { + const service = new (await import("@/services/infrastructure/NotificationServices/Discord.js")).default(); + const getGot = () => jest.requireMock("got").default; + getGot().post.mockRejectedValue(new Error("net")); + const channel = buildChannel(); + const alert = service.buildAlert(buildMonitor(), buildIncident()); + const ok = await service.sendMessage(alert, channel); + expect(ok).toBe(false); + }); + + it("uses red color embed when status is down", async () => { + const service = new DiscordService(); + const getGot = () => jest.requireMock("got").default; + getGot().post.mockResolvedValue({}); + const channel = buildChannel(); + const alert = service.buildAlert( + buildMonitor({ status: "down" }), + buildIncident() + ); + await service.sendMessage(alert, channel); + const call = getGot().post.mock.calls[0]; + const payload = call[1].json; + expect(payload.embeds[0].color).toBe(16711680); + }); +}); diff --git a/server/tests/services/infrastructure/EmailService.test.js b/server/tests/services/infrastructure/EmailService.test.js index 987bd5f38..8aadcee80 100644 --- a/server/tests/services/infrastructure/EmailService.test.js +++ b/server/tests/services/infrastructure/EmailService.test.js @@ -2,9 +2,19 @@ jest.mock("nodemailer", () => ({ __esModule: true, default: { createTransport: jest.fn(() => ({ - sendMail: jest.fn().mockResolvedValue({}) - })) - } + sendMail: jest.fn().mockResolvedValue({}), + })), + }, +})); + +// Default: no env SMTP so system-settings path is used unless overridden per-test +jest.mock("@/config/index.js", () => ({ + config: { + SMTP_HOST: "not_set", + SMTP_PORT: -1, + SMTP_USER: "not_set", + SMTP_PASS: "not_set", + }, })); import EmailService from "@/services/infrastructure/NotificationServices/Email.js"; @@ -12,7 +22,22 @@ import EmailService from "@/services/infrastructure/NotificationServices/Email.j // Mock user service to avoid calling getAllUsers const userServiceMock = { getAllUsers: jest.fn().mockResolvedValue([{ email: "a@example.com" }]) }; // Settings service mock (unused path in test) -const settingsServiceMock = {}; +const settingsServiceMock = { + get: jest.fn().mockResolvedValue({ + systemEmailHost: "smtp.example.com", + systemEmailPort: 587, + systemEmailAddress: "noreply@example.com", + systemEmailUser: "smtp-user", + systemEmailPassword: "smtp-pass", + systemEmailConnectionHost: "example.com", + systemEmailTLSServername: "example.com", + systemEmailSecure: false, + systemEmailPool: false, + systemEmailIgnoreTLS: false, + systemEmailRequireTLS: false, + systemEmailRejectUnauthorized: true, + }), +}; const getMailer = () => jest.requireMock("nodemailer").default; @@ -36,4 +61,100 @@ describe("EmailService", () => { const ok = await service.testMessage(buildChannel()); expect(ok).toBe(true); }); + + it("uses system settings transport (no env) and sendGeneric succeeds", async () => { + const service = new EmailService(userServiceMock, settingsServiceMock); + const mailer = getMailer(); + const sendMail = jest.fn().mockResolvedValue({}); + mailer.createTransport.mockReturnValue({ sendMail }); + + const ok = await service.sendGeneric("to@example.com", "Subj", "Body"); + expect(ok).toBe(true); + expect(mailer.createTransport).toHaveBeenCalled(); + const arg = mailer.createTransport.mock.calls[0][0]; + expect(arg.host || arg?.host === undefined).toBeDefined(); + }); + + it("returns false when no user emails found in sendMessage", async () => { + const service = new EmailService({ getAllUsers: jest.fn().mockResolvedValue([]) }, settingsServiceMock); + const ok = await service.sendMessage({ name: "n", url: "u", status: "s", checkTime: new Date(), alertTime: new Date(), resolved: false }, buildChannel()); + expect(ok).toBe(false); + }); + + it("rebuildTransport sets transporter and from and returns true", async () => { + const service = new EmailService(userServiceMock, settingsServiceMock); + const mailer = getMailer(); + const sendMail = jest.fn().mockResolvedValue({}); + mailer.createTransport.mockReturnValue({ sendMail }); + const res = await service.rebuildTransport({ + systemEmailHost: "smtp.example.com", + systemEmailPort: 465, + systemEmailAddress: "noreply@example.com", + systemEmailUser: "smtp-user", + systemEmailPassword: "smtp-pass", + systemEmailSecure: true, + systemEmailPool: true, + systemEmailIgnoreTLS: false, + systemEmailRequireTLS: false, + systemEmailRejectUnauthorized: true, + }); + expect(res).toBe(true); + expect(mailer.createTransport).toHaveBeenCalled(); + }); + + it("testTransport throws when env SMTP configured", async () => { + jest.resetModules(); + jest.doMock("@/config/index.js", () => ({ + config: { SMTP_HOST: "smtp.env", SMTP_PORT: 465, SMTP_USER: "u", SMTP_PASS: "p" }, + })); + const { default: EmailServiceEnv } = await import("@/services/infrastructure/NotificationServices/Email.js"); + const service = new EmailServiceEnv(userServiceMock, settingsServiceMock); + await expect( + service.testTransport({ systemEmailAddress: "noreply@example.com", systemEmailSecure: false, systemEmailPool: false, systemEmailIgnoreTLS: false, systemEmailRequireTLS: false, systemEmailRejectUnauthorized: true }) + ).rejects.toMatchObject({ status: 400 }); + }); + + it("builds env transport when env present and uses secure flag", async () => { + jest.resetModules(); + jest.doMock("@/config/index.js", () => ({ + config: { SMTP_HOST: "smtp.env", SMTP_PORT: 465, SMTP_USER: "u", SMTP_PASS: "p" }, + })); + const { default: EmailServiceEnv } = await import("@/services/infrastructure/NotificationServices/Email.js"); + const mailer = getMailer(); + mailer.createTransport.mockReturnValue({ sendMail: jest.fn().mockResolvedValue({}) }); + const service = new EmailServiceEnv(userServiceMock, settingsServiceMock); + await service.sendGeneric("t@example.com", "s", "b"); + expect(mailer.createTransport).toHaveBeenCalledWith( + expect.objectContaining({ host: "smtp.env", port: 465, secure: true }) + ); + }); + + it("sendGeneric rejects when transporter sendMail fails", async () => { + const service = new EmailService(userServiceMock, settingsServiceMock); + // Bypass nodemailer mock by injecting a failing transporter directly + service.transporter = { sendMail: jest.fn().mockRejectedValue(new Error("fail")) }; + await expect(service.sendGeneric("t@example.com", "s", "b")).rejects.toBeInstanceOf(Error); + }); + + it("testTransport throws ApiError when sendMail fails", async () => { + const service = new EmailService(userServiceMock, settingsServiceMock); + // Force buildSystemSettingsTransport to return a transporter whose sendMail fails + service.buildSystemSettingsTransport = jest + .fn() + .mockResolvedValue({ sendMail: jest.fn().mockRejectedValue(new Error("smtp-fail")) }); + await expect( + service.testTransport({ + systemEmailHost: "smtp.example.com", + systemEmailPort: 587, + systemEmailAddress: "noreply@example.com", + systemEmailUser: "smtp-user", + systemEmailPassword: "smtp-pass", + systemEmailSecure: false, + systemEmailPool: false, + systemEmailIgnoreTLS: false, + systemEmailRequireTLS: false, + systemEmailRejectUnauthorized: true, + }) + ).rejects.toMatchObject({ status: 400 }); + }); }); diff --git a/server/tests/services/infrastructure/NotificationService.test.js b/server/tests/services/infrastructure/NotificationService.test.js index 8bc1905df..7eba58bc2 100644 --- a/server/tests/services/infrastructure/NotificationService.test.js +++ b/server/tests/services/infrastructure/NotificationService.test.js @@ -165,6 +165,24 @@ describe("NotificationService.testNotificationChannels", () => { expect(byType.discord).toBe(true); expect(byType.webhook).toBe(true); }); + + it("uses 'N/A' for missing channel URLs/emails in results", async () => { + const service = createService(); + const monitor = buildMonitor({ notificationChannels: ["c1", "c2"] }); + jest.spyOn(Monitor, "findOne").mockResolvedValue(monitor); + const channels = [ + buildChannel({ _id: "c1", type: "slack", config: {} }), + buildChannel({ _id: "c2", type: "email", config: {} }), + ]; + jest.spyOn(NotificationChannel, "find").mockReturnValue({ lean: () => channels }); + jest.spyOn(service["slackService"], "testMessage").mockResolvedValue(true); + jest.spyOn(service["emailService"], "testMessage").mockResolvedValue(true); + + const results = await service.testNotificationChannels("m1", "t1"); + const byType = Object.fromEntries(results.map((r) => [r.channelType, r.channelUrl])); + expect(byType.slack).toBe("N/A"); + expect(byType.email).toBe("N/A"); + }); }); describe("NotificationService.handleNotifications", () => { @@ -227,4 +245,29 @@ describe("NotificationService.handleNotifications", () => { expect(discordSpy).toHaveBeenCalled(); expect(webhookSpy).toHaveBeenCalled(); }); + + it("handles unknown channel types without throwing", async () => { + const service = createService(); + const monitor = buildMonitor({ notificationChannels: ["cx"] }); + jest + .spyOn(NotificationChannel, "find") + .mockResolvedValue([{ _id: "cx", type: "unknown", name: "u", config: {} }]); + + await expect( + service.handleNotifications(monitor, { _id: "i1", monitorId: "m1" }) + ).resolves.toBeUndefined(); + }); +}); + +describe("NotificationService unknown channel branch", () => { + it("testNotificationChannel returns false for unknown type", async () => { + const service = createService(); + const sent = await service.testNotificationChannel({ + _id: "c-unknown", + type: "unknown", + name: "u", + config: {}, + }); + expect(sent).toBe(false); + }); }); diff --git a/server/tests/services/infrastructure/SlackService.test.js b/server/tests/services/infrastructure/SlackService.test.js index 9434997cd..0ac532659 100644 --- a/server/tests/services/infrastructure/SlackService.test.js +++ b/server/tests/services/infrastructure/SlackService.test.js @@ -39,4 +39,25 @@ describe("SlackService", () => { const alert = service.buildAlert(buildMonitor(), buildIncident()); await expect(service.sendMessage(alert, channel)).rejects.toThrow("Webhook URL not configured"); }); + + it("returns false when webhook post fails", async () => { + const service = new SlackService(); + getGot().post.mockRejectedValue(new Error("net")); + const channel = buildChannel(); + const alert = service.buildAlert(buildMonitor(), buildIncident()); + const ok = await service.sendMessage(alert, channel); + expect(ok).toBe(false); + }); + + it("includes resolution fields and timestamps in payload", async () => { + const service = new SlackService(); + getGot().post.mockResolvedValue({}); + const channel = buildChannel(); + const incident = buildIncident({ resolved: true, resolutionType: "auto", resolutionNote: "n" }); + const alert = service.buildAlert(buildMonitor(), incident); + await service.sendMessage(alert, channel); + const payload = getGot().post.mock.calls[0][1].json; + expect(payload.blocks.some((b) => JSON.stringify(b).includes("Resolution Type"))).toBe(true); + expect(payload.blocks.some((b) => JSON.stringify(b).includes("Checked at"))).toBe(true); + }); }); diff --git a/server/tests/services/infrastructure/WebhookService.test.js b/server/tests/services/infrastructure/WebhookService.test.js index 22553caec..992c07064 100644 --- a/server/tests/services/infrastructure/WebhookService.test.js +++ b/server/tests/services/infrastructure/WebhookService.test.js @@ -40,5 +40,27 @@ describe("WebhookService", () => { const alert = service.buildAlert(buildMonitor(), buildIncident()); await expect(service.sendMessage(alert, channel)).rejects.toBeInstanceOf(ApiError); }); -}); + it("returns false when webhook post fails", async () => { + const getGot = () => jest.requireMock("got").default; + getGot().post.mockRejectedValue(new Error("net")); + const service = new WebhookService(); + const channel = buildChannel(); + const alert = service.buildAlert(buildMonitor(), buildIncident()); + const ok = await service.sendMessage(alert, channel); + expect(ok).toBe(false); + }); + + it("sends alert fields in JSON body", async () => { + const getGot = () => jest.requireMock("got").default; + getGot().post.mockResolvedValue({}); + const service = new WebhookService(); + const channel = buildChannel(); + const alert = service.buildAlert(buildMonitor(), buildIncident()); + await service.sendMessage(alert, channel); + const body = getGot().post.mock.calls[0][1].json; + expect(body.name).toBe(alert.name); + expect(body.status).toBe(alert.status); + expect(body.url).toBe(alert.url); + }); +});