@oneuptime/common 12.0.31 → 12.0.32

package/Tests/Server/Services/UserNotificationSettingMonitorDefaults.test.ts

@@ -0,0 +1,248 @@
+import UserNotificationSetting from "../../../Models/DatabaseModels/UserNotificationSetting";
+import UserNotificationSettingService from "../../../Server/Services/UserNotificationSettingService";
+import NotificationSettingEventType from "../../../Types/NotificationSetting/NotificationSettingEventType";
+import ObjectID from "../../../Types/ObjectID";
+import PositiveNumber from "../../../Types/PositiveNumber";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const OTHER_PROJECT_ID: ObjectID = new ObjectID(
+  "33333333-3333-4333-8333-333333333333",
+);
+const USER_ID: ObjectID = new ObjectID("22222222-2222-4222-8222-222222222222");
+const OTHER_USER_ID: ObjectID = new ObjectID(
+  "44444444-4444-4444-8444-444444444444",
+);
+
+const STATUS_CHANGE_EVENT: NotificationSettingEventType =
+  NotificationSettingEventType.SEND_MONITOR_STATUS_CHANGED_OWNER_NOTIFICATION;
+
+const ENABLED_MONITOR_EVENTS: Array<NotificationSettingEventType> = [
+  NotificationSettingEventType.SEND_MONITOR_NOTIFICATION_WHEN_NO_PROBES_ARE_MONITORING_THE_MONITOR,
+  NotificationSettingEventType.SEND_MONITOR_NOTIFICATION_WHEN_PORBE_STATUS_CHANGES,
+];
+
+interface StoredSetting {
+  userId: string;
+  projectId: string;
+  eventType: NotificationSettingEventType;
+  alertByEmail: boolean;
+  alertBySMS: boolean;
+  alertByCall: boolean;
+  alertByPush: boolean;
+  alertByWhatsApp: boolean;
+  alertByTelegram: boolean;
+  alertBySlack: boolean;
+  alertByMicrosoftTeams: boolean;
+  alertByWebhook: boolean;
+  isRoot: boolean;
+}
+
+interface SettingIdentity {
+  userId: unknown;
+  projectId: unknown;
+  eventType: unknown;
+}
+
+function key(data: SettingIdentity): string {
+  return `${String(data.userId)}|${String(data.projectId)}|${String(
+    data.eventType,
+  )}`;
+}
+
+describe("UserNotificationSettingService monitor defaults", () => {
+  let store: Map<string, StoredSetting>;
+  let createdSettings: Array<StoredSetting>;
+  let queriedSettings: Array<SettingIdentity>;
+
+  beforeEach(() => {
+    store = new Map<string, StoredSetting>();
+    createdSettings = [];
+    queriedSettings = [];
+
+    jest
+      .spyOn(UserNotificationSettingService, "countBy")
+      .mockImplementation(((args: {
+        query: {
+          userId: ObjectID;
+          projectId: ObjectID;
+          eventType: NotificationSettingEventType;
+        };
+      }): Promise<PositiveNumber> => {
+        queriedSettings.push(args.query);
+
+        return Promise.resolve(
+          new PositiveNumber(store.has(key(args.query)) ? 1 : 0),
+        );
+      }) as never);
+
+    jest
+      .spyOn(UserNotificationSettingService, "create")
+      .mockImplementation(((args: {
+        data: UserNotificationSetting;
+        props: { isRoot?: boolean };
+      }): Promise<UserNotificationSetting> => {
+        const item: UserNotificationSetting = args.data;
+        const storedSetting: StoredSetting = {
+          userId: String(item.userId),
+          projectId: String(item.projectId),
+          eventType: item.eventType as NotificationSettingEventType,
+          alertByEmail: Boolean(item.alertByEmail),
+          alertBySMS: Boolean(item.alertBySMS),
+          alertByCall: Boolean(item.alertByCall),
+          alertByPush: Boolean(item.alertByPush),
+          alertByWhatsApp: Boolean(item.alertByWhatsApp),
+          alertByTelegram: Boolean(item.alertByTelegram),
+          alertBySlack: Boolean(item.alertBySlack),
+          alertByMicrosoftTeams: Boolean(item.alertByMicrosoftTeams),
+          alertByWebhook: Boolean(item.alertByWebhook),
+          isRoot: Boolean(args.props.isRoot),
+        };
+
+        createdSettings.push(storedSetting);
+        store.set(key(storedSetting), storedSetting);
+
+        return Promise.resolve(item);
+      }) as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  function stored(
+    eventType: NotificationSettingEventType,
+    userId: ObjectID = USER_ID,
+    projectId: ObjectID = PROJECT_ID,
+  ): StoredSetting | undefined {
+    return store.get(key({ userId, projectId, eventType }));
+  }
+
+  function seed(setting: StoredSetting): void {
+    store.set(key(setting), setting);
+  }
+
+  test("does not seed monitor status-change notifications for a new membership", async () => {
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      USER_ID,
+      PROJECT_ID,
+    );
+
+    expect(stored(STATUS_CHANGE_EVENT)).toBeUndefined();
+    expect(
+      createdSettings.some((setting: StoredSetting) => {
+        return setting.eventType === STATUS_CHANGE_EVENT;
+      }),
+    ).toBe(false);
+    expect(
+      queriedSettings.some((setting: SettingIdentity) => {
+        return setting.eventType === STATUS_CHANGE_EVENT;
+      }),
+    ).toBe(false);
+  });
+
+  test("keeps the other monitor defaults enabled by email only", async () => {
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      USER_ID,
+      PROJECT_ID,
+    );
+
+    for (const eventType of ENABLED_MONITOR_EVENTS) {
+      expect(stored(eventType)).toEqual({
+        userId: USER_ID.toString(),
+        projectId: PROJECT_ID.toString(),
+        eventType,
+        alertByEmail: true,
+        alertBySMS: false,
+        alertByCall: false,
+        alertByPush: false,
+        alertByWhatsApp: false,
+        alertByTelegram: false,
+        alertBySlack: false,
+        alertByMicrosoftTeams: false,
+        alertByWebhook: false,
+        isRoot: true,
+      });
+    }
+  });
+
+  test("remains idempotent without recreating the disabled default", async () => {
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      USER_ID,
+      PROJECT_ID,
+    );
+
+    const settingsCreatedByFirstCall: number = createdSettings.length;
+    const rowsCreatedByFirstCall: number = store.size;
+
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      USER_ID,
+      PROJECT_ID,
+    );
+
+    expect(createdSettings).toHaveLength(settingsCreatedByFirstCall);
+    expect(store.size).toBe(rowsCreatedByFirstCall);
+    expect(stored(STATUS_CHANGE_EVENT)).toBeUndefined();
+  });
+
+  test("preserves an existing explicit status-change preference", async () => {
+    const optedInSetting: StoredSetting = {
+      userId: USER_ID.toString(),
+      projectId: PROJECT_ID.toString(),
+      eventType: STATUS_CHANGE_EVENT,
+      alertByEmail: false,
+      alertBySMS: false,
+      alertByCall: false,
+      alertByPush: true,
+      alertByWhatsApp: false,
+      alertByTelegram: false,
+      alertBySlack: true,
+      alertByMicrosoftTeams: false,
+      alertByWebhook: false,
+      isRoot: true,
+    };
+    seed(optedInSetting);
+
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      USER_ID,
+      PROJECT_ID,
+    );
+
+    expect(stored(STATUS_CHANGE_EVENT)).toEqual(optedInSetting);
+    expect(
+      createdSettings.some((setting: StoredSetting) => {
+        return setting.eventType === STATUS_CHANGE_EVENT;
+      }),
+    ).toBe(false);
+  });
+
+  test("applies the off default independently to every user and project", async () => {
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      USER_ID,
+      PROJECT_ID,
+    );
+    await UserNotificationSettingService.addDefaultNotificationSettingsForUser(
+      OTHER_USER_ID,
+      OTHER_PROJECT_ID,
+    );
+
+    expect(stored(STATUS_CHANGE_EVENT, USER_ID, PROJECT_ID)).toBeUndefined();
+    expect(
+      stored(STATUS_CHANGE_EVENT, OTHER_USER_ID, OTHER_PROJECT_ID),
+    ).toBeUndefined();
+
+    for (const eventType of ENABLED_MONITOR_EVENTS) {
+      expect(stored(eventType, USER_ID, PROJECT_ID)).toBeDefined();
+      expect(stored(eventType, OTHER_USER_ID, OTHER_PROJECT_ID)).toBeDefined();
+    }
+  });
+});

package/Tests/Server/Services/UserNotificationSettingWorkspaceChannels.test.ts

@@ -3,10 +3,13 @@ import UserSlackService from "../../../Server/Services/UserSlackService";
 import UserMicrosoftTeamsService from "../../../Server/Services/UserMicrosoftTeamsService";
 import WorkspaceUserNotificationService from "../../../Server/Services/WorkspaceUserNotificationService";
 import ProjectCallSMSConfigService from "../../../Server/Services/ProjectCallSMSConfigService";
+import MailService from "../../../Server/Services/MailService";
+import UserEmailService from "../../../Server/Services/UserEmailService";
 import logger from "../../../Server/Utils/Logger";
 import UserNotificationSetting from "../../../Models/DatabaseModels/UserNotificationSetting";
 import UserSlack from "../../../Models/DatabaseModels/UserSlack";
 import UserMicrosoftTeams from "../../../Models/DatabaseModels/UserMicrosoftTeams";
+import UserEmail from "../../../Models/DatabaseModels/UserEmail";
 import { CallRequestMessage } from "../../../Types/Call/CallRequest";
 import { EmailEnvelope } from "../../../Types/Email/EmailMessage";
 import EmailTemplateType from "../../../Types/Email/EmailTemplateType";
@@ -60,6 +63,8 @@ const TEAMS_USER_ID: string = "entra-object-id-1";
 
 const EVENT_TYPE: NotificationSettingEventType =
   NotificationSettingEventType.SEND_INCIDENT_CREATED_OWNER_NOTIFICATION;
+const MONITOR_STATUS_CHANGE_EVENT: NotificationSettingEventType =
+  NotificationSettingEventType.SEND_MONITOR_STATUS_CHANGED_OWNER_NOTIFICATION;
 
 type SendUserNotificationData = Parameters<
   typeof UserNotificationSettingService.sendUserNotification
@@ -114,6 +119,8 @@ describe("UserNotificationSettingService.sendUserNotification - workspace channe
   let findSettings: jest.SpyInstance;
   let findSlacks: jest.SpyInstance;
   let findTeams: jest.SpyInstance;
+  let findEmails: jest.SpyInstance;
+  let sendMail: jest.SpyInstance;
   let sendDm: jest.SpyInstance;
   let loggerError: jest.SpyInstance;
 
@@ -133,6 +140,16 @@ describe("UserNotificationSettingService.sendUserNotification - workspace channe
       .spyOn(ProjectCallSMSConfigService, "getProjectDefaultTwilioConfig")
       .mockResolvedValue(undefined as never);
 
+    findEmails = jest.spyOn(UserEmailService, "findBy").mockResolvedValue([
+      {
+        email: "user@example.com",
+      } as unknown as UserEmail,
+    ] as never);
+
+    sendMail = jest
+      .spyOn(MailService, "sendMail")
+      .mockResolvedValue(undefined as never);
+
     findSlacks = jest.spyOn(UserSlackService, "findBy").mockResolvedValue([
       {
         id: new ObjectID("44444444-4444-4444-8444-444444444444"),
@@ -251,13 +268,37 @@ describe("UserNotificationSettingService.sendUserNotification - workspace channe
       expect(findTeams).not.toHaveBeenCalled();
     });
 
-    test("no settings row at all sends nothing", async () => {
+    test("no monitor status-change setting sends nothing on any channel", async () => {
       findSettings.mockResolvedValue(null as never);
 
       await UserNotificationSettingService.sendUserNotification(
-        notificationData(),
+        notificationData({ eventType: MONITOR_STATUS_CHANGE_EVENT }),
+      );
+
+      expect(findEmails).not.toHaveBeenCalled();
+      expect(sendMail).not.toHaveBeenCalled();
+      expect(
+        ProjectCallSMSConfigService.getProjectDefaultTwilioConfig,
+      ).not.toHaveBeenCalled();
+      expect(findSlacks).not.toHaveBeenCalled();
+      expect(findTeams).not.toHaveBeenCalled();
+      expect(sendDm).not.toHaveBeenCalled();
+    });
+
+    test("an explicit monitor status-change email opt-in still delivers", async () => {
+      findSettings.mockResolvedValue(
+        settingsRow({ alertByEmail: true }) as never,
       );
 
+      await UserNotificationSettingService.sendUserNotification(
+        notificationData({ eventType: MONITOR_STATUS_CHANGE_EVENT }),
+      );
+
+      expect(findEmails).toHaveBeenCalledTimes(1);
+      expect(sendMail).toHaveBeenCalledTimes(1);
+      expect(sendMail.mock.calls[0]?.[0]).toMatchObject({
+        toEmail: "user@example.com",
+      });
       expect(sendDm).not.toHaveBeenCalled();
     });
   });

package/Tests/Server/Utils/BasicCron.test.ts

@@ -0,0 +1,283 @@
+import { beforeEach, describe, expect, jest, test } from "@jest/globals";
+import cron from "node-cron";
+import logger from "../../../Server/Utils/Logger";
+import BasicCron from "../../../Server/Utils/BasicCron";
+
+/*
+ * The wrapper every scheduled job in the app is registered through.
+ *
+ * Its job is not scheduling — node-cron does that — it is making sure one bad
+ * run cannot end the schedule. A cron callback that throws takes its timer
+ * with it, so a job that failed once at 03:00 would simply never run again,
+ * and nothing would say so: the next morning looks exactly like a night with
+ * nothing to do. That is why the tick is wrapped, and it is the behaviour
+ * worth pinning here.
+ *
+ * The startup run is deliberately NOT inside that guard, and the asymmetry is
+ * the interesting part of this module — see the last block.
+ */
+
+jest.mock("node-cron", () => {
+  return { __esModule: true, default: { schedule: jest.fn() } };
+});
+
+jest.mock("../../../Server/Utils/Logger", () => {
+  return {
+    __esModule: true,
+    default: {
+      debug: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+    },
+  };
+});
+
+const mockedCron: { schedule: jest.Mock } = cron as unknown as {
+  schedule: jest.Mock;
+};
+
+const mockedLogger: { debug: jest.Mock; error: jest.Mock } =
+  logger as unknown as { debug: jest.Mock; error: jest.Mock };
+
+const EVERY_FIVE_MINUTES: string = "*/5 * * * *";
+
+/*
+ * The run function BasicCron is handed. jest.Mock's first type parameter is
+ * the RETURN type, so this is "a mock taking no arguments and answering with
+ * a promise" - named once here rather than restated at every call site.
+ */
+type RunMock = jest.Mock<Promise<void>, []>;
+
+function succeedingRun(): RunMock {
+  const mock: RunMock = jest.fn() as unknown as RunMock;
+  mock.mockImplementation((): Promise<void> => {
+    return Promise.resolve();
+  });
+  return mock;
+}
+
+function failingRun(message: string): RunMock {
+  const mock: RunMock = jest.fn() as unknown as RunMock;
+  mock.mockImplementation((): Promise<void> => {
+    return Promise.reject(new Error(message));
+  });
+  return mock;
+}
+
+/*
+ * BasicCron is declared as returning void but its implementation is async, so
+ * every call site here goes through this. That mismatch is not incidental
+ * tidying - it is the reason a startup failure reaches callers as an
+ * unhandled rejection rather than a thrown error, which the last test covers.
+ */
+function startCron(data: {
+  jobName: string;
+  schedule: string;
+  runOnStartup: boolean;
+  runFunction: RunMock;
+}): Promise<void> {
+  return BasicCron({
+    jobName: data.jobName,
+    options: {
+      schedule: data.schedule,
+      runOnStartup: data.runOnStartup,
+    },
+    runFunction: data.runFunction as never,
+  }) as unknown as Promise<void>;
+}
+
+/*
+ * The callback node-cron was handed. Invoking it is what "the schedule fired"
+ * means, without waiting five real minutes for it.
+ */
+function scheduledTick(): () => Promise<void> {
+  return mockedCron.schedule.mock.calls[0]![1] as () => Promise<void>;
+}
+
+describe("BasicCron", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("registration", () => {
+    test("registers the job on the schedule it was given", async () => {
+      const run: RunMock = succeedingRun();
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: false,
+        runFunction: run,
+      });
+
+      expect(mockedCron.schedule).toHaveBeenCalledTimes(1);
+      expect(mockedCron.schedule.mock.calls[0]![0]).toBe(EVERY_FIVE_MINUTES);
+    });
+
+    /*
+     * Registering must not run the job. A job that ran once per process start
+     * would fire on every rolling restart and every replica.
+     */
+    test("registering alone does not run the job", async () => {
+      const run: RunMock = succeedingRun();
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: false,
+        runFunction: run,
+      });
+
+      expect(run).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("a scheduled run", () => {
+    test("runs the job when the schedule fires", async () => {
+      const run: RunMock = succeedingRun();
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: false,
+        runFunction: run,
+      });
+
+      await scheduledTick()();
+
+      expect(run).toHaveBeenCalledTimes(1);
+    });
+
+    /*
+     * The whole point of the wrapper. An unhandled throw inside a node-cron
+     * callback ends that timer, so the job silently stops running for the
+     * lifetime of the process - and a job that never runs looks identical to
+     * a job with nothing to do.
+     */
+    test("a throwing run is swallowed, so the schedule survives it", async () => {
+      const run: RunMock = failingRun("job blew up");
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: false,
+        runFunction: run,
+      });
+
+      await expect(scheduledTick()()).resolves.toBeUndefined();
+      expect(mockedLogger.error).toHaveBeenCalled();
+    });
+
+    test("a failed run does not stop later runs from firing", async () => {
+      const run: RunMock = succeedingRun();
+      run.mockImplementationOnce((): Promise<void> => {
+        return Promise.reject(new Error("first run blew up"));
+      });
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: false,
+        runFunction: run,
+      });
+
+      await scheduledTick()();
+      await scheduledTick()();
+
+      expect(run).toHaveBeenCalledTimes(2);
+    });
+
+    /*
+     * The job's name is what makes a line in the log attributable to one of
+     * many scheduled jobs. Logged without it, a failure says only that
+     * something somewhere failed.
+     */
+    test("the job's name is in what it logs", async () => {
+      const run: RunMock = succeedingRun();
+
+      await startCron({
+        jobName: "DistinctiveJobName",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: false,
+        runFunction: run,
+      });
+
+      await scheduledTick()();
+
+      const logged: string = mockedLogger.debug.mock.calls
+        .map((callArgs: Array<unknown>): string => {
+          return String(callArgs[0]);
+        })
+        .join("\n");
+
+      expect(logged).toContain("DistinctiveJobName");
+    });
+  });
+
+  describe("the startup run", () => {
+    test("runs the job immediately when asked to", async () => {
+      const run: RunMock = succeedingRun();
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: true,
+        runFunction: run,
+      });
+
+      expect(run).toHaveBeenCalledTimes(1);
+    });
+
+    /*
+     * The startup run is in addition to the schedule, not instead of it - a
+     * job that ran once at boot and was never registered would go quiet after
+     * the first tick.
+     */
+    test("it still registers the recurring schedule", async () => {
+      const run: RunMock = succeedingRun();
+
+      await startCron({
+        jobName: "TestJob",
+        schedule: EVERY_FIVE_MINUTES,
+        runOnStartup: true,
+        runFunction: run,
+      });
+
+      expect(mockedCron.schedule).toHaveBeenCalledTimes(1);
+
+      await scheduledTick()();
+
+      expect(run).toHaveBeenCalledTimes(2);
+    });
+
+    /*
+     * DELIBERATE ASYMMETRY, pinned so a later reader does not "fix" it by
+     * reflex: unlike a scheduled tick, a startup failure is NOT swallowed. It
+     * rejects out of BasicCron.
+     *
+     * That is the right way round. A scheduled run fails against a live
+     * system and the next tick is a genuine retry, so surviving it is what
+     * keeps the job alive. A startup run fails against a process that is
+     * still coming up - usually because configuration or a dependency is
+     * wrong - and a boot that swallowed that would come up looking healthy
+     * with a job that never worked.
+     *
+     * Note the callers' side of this: BasicCronFunction is typed as returning
+     * void, so a caller that does not await gets an unhandled rejection
+     * rather than a thrown error. Loud either way, which is the intent.
+     */
+    test("a startup failure propagates rather than being swallowed", async () => {
+      const run: RunMock = failingRun("bad configuration at boot");
+
+      await expect(
+        startCron({
+          jobName: "TestJob",
+          schedule: EVERY_FIVE_MINUTES,
+          runOnStartup: true,
+          runFunction: run,
+        }),
+      ).rejects.toThrow("bad configuration at boot");
+    });
+  });
+});