refactor(notifications): address maintainer feedback on sanitization typing and test coverage

Ref #2369

Author: harsh-aghara

server/src/controllers/notificationController.ts

@@ -12,6 +12,7 @@ import { AppError } from "@/utils/AppError.js";
 import { INotificationsService } from "@/service/index.js";
 import { requireTeamId, requireUserId } from "./controllerUtils.js";
 import { IMonitorsRepository } from "@/repositories/index.js";
+import type { Notification } from "@/types/notification.js";
 
 const SERVICE_NAME = "NotificationController";
 
@@ -47,10 +48,10 @@ class NotificationController implements INotificationController {
 		}
 	};
 
-	private sanitizeNotification = (notification: any) => {
+	private sanitizeNotification = (notification: Notification | null | undefined): Notification | null | undefined => {
 		if (!notification) return notification;
-		const { authPassword, authToken, accessToken, ...sanitized } = notification;
-		return sanitized;
+		const { authPassword, authToken, ...sanitized } = notification;
+		return sanitized as Notification;
 	};
 
 	createNotification = async (req: Request, res: Response, next: NextFunction) => {

server/test/unit/providers/notifications/webhookProvider.test.ts

@@ -45,6 +45,98 @@ describe("WebhookProvider", () => {
 			const { provider } = createProvider();
 			expect(await provider.sendTestAlert(makeNotification())).toBe(false);
 		});
+
+		it("omits Authorization header when authType is none", async () => {
+			const { provider } = createProvider();
+			await provider.sendTestAlert(makeNotification({ authType: "none" }));
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBeUndefined();
+			expect(headers["Content-Type"]).toBe("application/json");
+		});
+
+		it("sends Basic Authorization when authType is basic", async () => {
+			const { provider } = createProvider();
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "basic",
+					authUsername: "user",
+					authPassword: "secret",
+				})
+			);
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBe(`Basic ${Buffer.from("user:secret").toString("base64")}`);
+		});
+
+		it("sends Bearer Authorization when authType is bearer", async () => {
+			const { provider } = createProvider();
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "bearer",
+					authToken: "my-bearer-token",
+				})
+			);
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBe("Bearer my-bearer-token");
+		});
+
+		it("omits Authorization when basic auth is missing password", async () => {
+			const { provider } = createProvider();
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "basic",
+					authUsername: "user",
+					authPassword: undefined,
+				})
+			);
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBeUndefined();
+		});
+
+		it("omits Authorization when bearer auth is missing token", async () => {
+			const { provider } = createProvider();
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "bearer",
+					authToken: undefined,
+				})
+			);
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBeUndefined();
+		});
+
+		it("omits Authorization when basic auth is missing username", async () => {
+			const { provider } = createProvider();
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "basic",
+					authUsername: undefined,
+					authPassword: "secret",
+				})
+			);
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBeUndefined();
+		});
+
+		it("handles empty strings for auth fields by omitting Authorization", async () => {
+			const { provider } = createProvider();
+
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "basic",
+					authUsername: "",
+					authPassword: "",
+				})
+			);
+			expect(mockGotPost.mock.calls[0][1].headers.Authorization).toBeUndefined();
+
+			await provider.sendTestAlert(
+				makeNotification({
+					authType: "bearer",
+					authToken: "",
+				})
+			);
+			expect(mockGotPost.mock.calls[1][1].headers.Authorization).toBeUndefined();
+		});
 	});
 
 	describe("sendMessage", () => {
@@ -98,5 +190,19 @@ describe("WebhookProvider", () => {
 			expect(text).not.toContain("Additional Information");
 			expect(text).not.toContain("View Incident");
 		});
+
+		it("sends Basic Authorization on sendMessage when authType is basic", async () => {
+			const { provider } = createProvider();
+			await provider.sendMessage(
+				makeNotification({
+					authType: "basic",
+					authUsername: "user",
+					authPassword: "secret",
+				}) as any,
+				makeMessage()
+			);
+			const headers = mockGotPost.mock.calls[0][1].headers;
+			expect(headers.Authorization).toBe(`Basic ${Buffer.from("user:secret").toString("base64")}`);
+		});
 	});
 });