@oneuptime/common 12.0.33 → 12.0.34

package/Tests/App/Dashboard/NotificationEmailPreferences.test.tsx

@@ -0,0 +1,399 @@
+import "@testing-library/jest-dom";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+import React from "react";
+import NotificationSettings from "../../../../App/FeatureSet/Dashboard/src/Pages/UserSettings/NotificationSettings";
+import EmailNoiseCard from "../../../../App/FeatureSet/Dashboard/src/Components/NotificationMethods/EmailNoiseCard";
+import UserNotificationSetting from "../../../Models/DatabaseModels/UserNotificationSetting";
+import UserNotificationEmailRollupSetting from "../../../Models/DatabaseModels/UserNotificationEmailRollupSetting";
+import Route from "../../../Types/API/Route";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import Query from "../../../Types/BaseDatabase/Query";
+import NotificationSettingEventType from "../../../Types/NotificationSetting/NotificationSettingEventType";
+import { ROUTINE_EMAIL_EVENT_TYPES } from "../../../Types/NotificationSetting/RoutineEmailEvents";
+import ObjectID from "../../../Types/ObjectID";
+import API from "../../../UI/Utils/API/API";
+import ModelAPI from "../../../UI/Utils/ModelAPI/ModelAPI";
+import ProjectUtil from "../../../UI/Utils/Project";
+import User from "../../../UI/Utils/User";
+
+const PROJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const USER_ID: ObjectID = new ObjectID("22222222-2222-4222-8222-222222222222");
+
+describe("notification email preferences", () => {
+  let rows: Array<UserNotificationSetting>;
+  let post: jest.SpyInstance;
+  let getList: jest.SpyInstance;
+
+  beforeEach(() => {
+    rows = Object.values(NotificationSettingEventType).map(
+      (
+        eventType: NotificationSettingEventType,
+        index: number,
+      ): UserNotificationSetting => {
+        const row: UserNotificationSetting = new UserNotificationSetting();
+        row._id = `33333333-3333-4333-8333-${String(index).padStart(12, "0")}`;
+        row.projectId = PROJECT_ID;
+        row.userId = USER_ID;
+        row.eventType = eventType;
+        row.alertByEmail = true;
+        row.alertBySMS = true;
+        return row;
+      },
+    );
+    jest.spyOn(ProjectUtil, "getCurrentProjectId").mockReturnValue(PROJECT_ID);
+    jest.spyOn(User, "getUserId").mockReturnValue(USER_ID);
+    jest
+      .spyOn(ModelAPI, "getCommonHeaders")
+      .mockReturnValue({ tenantid: PROJECT_ID.toString() });
+    jest
+      .spyOn(API, "getFriendlyMessage")
+      .mockImplementation((err: unknown): string => {
+        return err instanceof Error || err instanceof HTTPErrorResponse
+          ? err.message
+          : "Request failed";
+      });
+    getList = jest
+      .spyOn(ModelAPI, "getList")
+      .mockImplementation(
+        async (data: Parameters<typeof ModelAPI.getList>[0]): Promise<any> => {
+          if (data.modelType === UserNotificationEmailRollupSetting) {
+            return { data: [], count: 0 };
+          }
+          const query: Query<UserNotificationSetting> = data.query;
+          const eventTypes: Array<string> = (query.eventType as Includes)
+            .values as Array<string>;
+          const settings: Array<UserNotificationSetting> = rows.filter(
+            (row: UserNotificationSetting): boolean => {
+              return (
+                eventTypes.includes(row.eventType!) &&
+                row.projectId?.toString() ===
+                  (query.projectId as ObjectID).toString() &&
+                row.userId?.toString() === (query.userId as ObjectID).toString()
+              );
+            },
+          );
+          return {
+            data: settings,
+            count: settings.length,
+          };
+        },
+      );
+    post = jest
+      .spyOn(API, "post")
+      .mockImplementation(async (): Promise<any> => {
+        rows = rows.map(
+          (row: UserNotificationSetting): UserNotificationSetting => {
+            const copy: UserNotificationSetting = Object.assign(
+              new UserNotificationSetting(),
+              row,
+            );
+            if (ROUTINE_EMAIL_EVENT_TYPES.includes(copy.eventType!)) {
+              copy.alertByEmail = false;
+            }
+            return copy;
+          },
+        );
+        return new HTTPResponse(200, { success: true }, {});
+      });
+  });
+
+  afterEach(() => {
+    cleanup();
+    jest.restoreAllMocks();
+  });
+
+  function renderPage(): void {
+    render(
+      <NotificationSettings
+        pageRoute={new Route("/user-settings/notification-settings")}
+        currentProject={null}
+        hasPaymentMethod={true}
+      />,
+    );
+  }
+
+  async function findEventRow(label: string): Promise<HTMLElement> {
+    return (await screen.findByText(label)).closest("tr")!;
+  }
+
+  test("offers reduction without changing preferences on page load", async () => {
+    renderPage();
+    await findEventRow("Incident created");
+    expect(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    ).toBeEnabled();
+    expect(screen.getByText(/Applies to you in this project/)).toBeVisible();
+    expect(post).not.toHaveBeenCalled();
+  });
+
+  test("reloads preferences and clears the old success message when switching projects", async () => {
+    const { rerender } = render(
+      <NotificationSettings
+        pageRoute={new Route("/user-settings/notification-settings")}
+        currentProject={null}
+        hasPaymentMethod={true}
+      />,
+    );
+    await findEventRow("Incident created");
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    );
+    await screen.findByRole("status");
+    const otherProjectId: ObjectID = new ObjectID(
+      "44444444-4444-4444-8444-444444444444",
+    );
+    jest
+      .spyOn(ProjectUtil, "getCurrentProjectId")
+      .mockReturnValue(otherProjectId);
+    getList.mockClear();
+    rerender(
+      <NotificationSettings
+        pageRoute={new Route("/user-settings/notification-settings")}
+        currentProject={null}
+        hasPaymentMethod={true}
+      />,
+    );
+    const row: HTMLElement = await findEventRow("Incident created");
+    expect(
+      within(row).getByRole("switch", { name: /^Email:/ }),
+    ).toHaveAttribute("aria-checked", "false");
+    expect(
+      screen.queryByText(
+        "Routine emails turned off. Review or change individual preferences below.",
+      ),
+    ).not.toBeInTheDocument();
+    expect(getList.mock.calls.length).toBeGreaterThan(0);
+    for (const call of getList.mock.calls) {
+      expect(call[0].query.projectId).toEqual(otherProjectId);
+      expect(call[0].query.userId).toEqual(USER_ID);
+    }
+  });
+
+  test("applies once, refreshes visible settings, and preserves urgent emails and SMS", async () => {
+    renderPage();
+    const before: HTMLElement = await findEventRow("Incident note posted");
+    expect(
+      within(before).getByRole("switch", { name: /^Email:/ }),
+    ).toHaveAttribute("aria-checked", "true");
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    );
+    await screen.findByRole("status");
+    await waitFor(() => {
+      const after: HTMLElement = screen
+        .getByText("Incident note posted")
+        .closest("tr")!;
+      expect(
+        within(after).getByRole("switch", { name: /^Email:/ }),
+      ).toHaveAttribute("aria-checked", "false");
+      expect(
+        within(after).getByRole("switch", { name: /^SMS:/ }),
+      ).toHaveAttribute("aria-checked", "true");
+    });
+    const urgent: HTMLElement = await findEventRow("Incident created");
+    expect(
+      within(urgent).getByRole("switch", { name: /^Email:/ }),
+    ).toHaveAttribute("aria-checked", "true");
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(post.mock.calls[0][0].url.toString()).toContain(
+      "/user-notification-setting/reduce-routine-emails",
+    );
+    expect(post.mock.calls[0][0].data).toEqual({});
+    expect(post.mock.calls[0][0].headers).toEqual({
+      tenantid: PROJECT_ID.toString(),
+    });
+  });
+
+  test("does not reenable an urgent email the user had already disabled", async () => {
+    rows.find((row: UserNotificationSetting): boolean => {
+      return (
+        row.eventType ===
+        NotificationSettingEventType.SEND_INCIDENT_CREATED_OWNER_NOTIFICATION
+      );
+    })!.alertByEmail = false;
+    renderPage();
+    await findEventRow("Incident created");
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    );
+    await screen.findByRole("status");
+    const urgent: HTMLElement = await findEventRow("Incident created");
+    expect(
+      within(urgent).getByRole("switch", { name: /^Email:/ }),
+    ).toHaveAttribute("aria-checked", "false");
+  });
+
+  test("disables repeated submission and channel edits while the action is pending", async () => {
+    let resolveRequest!: (response: HTTPResponse<any>) => void;
+    post.mockReturnValue(
+      new Promise<HTTPResponse<any>>(
+        (resolve: (response: HTTPResponse<any>) => void): void => {
+          resolveRequest = resolve;
+        },
+      ),
+    );
+    renderPage();
+    const row: HTMLElement = await findEventRow("Incident note posted");
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    );
+    const saving: HTMLElement = screen.getByRole("button", {
+      name: "Saving email preferences…",
+    });
+    expect(saving).toBeDisabled();
+    fireEvent.click(saving);
+    expect(within(row).getByRole("switch", { name: /^Email:/ })).toBeDisabled();
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(screen.queryByRole("status")).not.toBeInTheDocument();
+    await act(async () => {
+      resolveRequest(new HTTPResponse(200, { success: true }, {}));
+    });
+    await screen.findByRole("status");
+  });
+
+  test("waits for an earlier individual save before allowing the routine preset", async () => {
+    rows.find((row: UserNotificationSetting): boolean => {
+      return (
+        row.eventType ===
+        NotificationSettingEventType.SEND_INCIDENT_NOTE_POSTED_OWNER_NOTIFICATION
+      );
+    })!.alertByEmail = false;
+    let finishSave!: (response: HTTPResponse<any>) => void;
+    const save: jest.SpyInstance = jest
+      .spyOn(ModelAPI, "updateById")
+      .mockReturnValue(
+        new Promise<HTTPResponse<any>>(
+          (resolve: (response: HTTPResponse<any>) => void): void => {
+            finishSave = resolve;
+          },
+        ),
+      );
+    renderPage();
+    const row: HTMLElement = await findEventRow("Incident note posted");
+    fireEvent.click(within(row).getByRole("switch", { name: /^Email:/ }));
+    expect(save).toHaveBeenCalledTimes(1);
+    const reduce: HTMLElement = screen.getByRole("button", {
+      name: "Reduce routine emails",
+    });
+    expect(reduce).toBeDisabled();
+    fireEvent.click(reduce);
+    expect(post).not.toHaveBeenCalled();
+    await act(async () => {
+      finishSave(new HTTPResponse(200, {}, {}));
+    });
+    await waitFor(() => {
+      expect(reduce).toBeEnabled();
+    });
+    fireEvent.click(reduce);
+    await screen.findByRole("status");
+    const updated: HTMLElement = await findEventRow("Incident note posted");
+    expect(
+      within(updated).getByRole("switch", { name: /^Email:/ }),
+    ).toHaveAttribute("aria-checked", "false");
+    expect(post).toHaveBeenCalledTimes(1);
+  });
+
+  test.each(["resolved HTTP error", "network rejection"])(
+    "shows %s, keeps settings, and allows retry",
+    async (kind: string) => {
+      if (kind === "resolved HTTP error") {
+        post.mockResolvedValueOnce(
+          new HTTPErrorResponse(
+            503,
+            { message: "Preferences could not be saved" },
+            {},
+          ),
+        );
+      } else {
+        post.mockRejectedValueOnce(new Error("Preferences could not be saved"));
+      }
+      renderPage();
+      await findEventRow("Incident note posted");
+      const readsBefore: number = getList.mock.calls.length;
+      fireEvent.click(
+        screen.getByRole("button", { name: "Reduce routine emails" }),
+      );
+      expect(await screen.findByRole("alert")).toHaveTextContent(
+        "Preferences could not be saved",
+      );
+      expect(screen.queryByRole("status")).not.toBeInTheDocument();
+      expect(getList).toHaveBeenCalledTimes(readsBefore);
+      const row: HTMLElement = await findEventRow("Incident note posted");
+      expect(
+        within(row).getByRole("switch", { name: /^Email:/ }),
+      ).toHaveAttribute("aria-checked", "true");
+      fireEvent.click(
+        screen.getByRole("button", { name: "Reduce routine emails" }),
+      );
+      await screen.findByRole("status");
+      expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    },
+  );
+
+  test("every event has one reachable preference and reads are scoped to the current member", async () => {
+    renderPage();
+    await findEventRow("Assigned to an incident");
+    for (const tabName of [
+      "Alerts",
+      "Monitoring",
+      "Status Pages",
+      "Scheduled Maintenance",
+      "On-Call",
+    ]) {
+      fireEvent.click(screen.getByRole("tab", { name: tabName }));
+      await waitFor(() => {
+        expect(screen.getAllByRole("switch").length).toBeGreaterThan(1);
+      });
+      if (tabName === "Monitoring") {
+        await screen.findByText("AI agent status changed");
+        await screen.findByText("Added as AI agent owner");
+      }
+    }
+    const eventReads: Array<any> = getList.mock.calls
+      .map((call: Array<any>): any => {
+        return call[0];
+      })
+      .filter((call: any): boolean => {
+        return call.modelType === UserNotificationSetting;
+      });
+    const queriedTypes: Array<string> = eventReads.flatMap(
+      (call: any): Array<string> => {
+        return call.query.eventType.values;
+      },
+    );
+    expect(queriedTypes.sort()).toEqual(
+      Object.values(NotificationSettingEventType).sort(),
+    );
+    for (const call of eventReads) {
+      expect(call.query.projectId).toEqual(PROJECT_ID);
+      expect(call.query.userId).toEqual(USER_ID);
+    }
+  });
+
+  test("the reduction card can be used again after an individual preference change", async () => {
+    const apply: jest.Mock = jest.fn().mockResolvedValue(undefined);
+    render(<EmailNoiseCard onApply={apply} />);
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    );
+    await screen.findByRole("status");
+    fireEvent.click(
+      screen.getByRole("button", { name: "Reduce routine emails" }),
+    );
+    await waitFor(() => {
+      expect(apply).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/Tests/App/StatusPage/StatusPageLastUpdated.test.tsx

@@ -0,0 +1,263 @@
+import "@testing-library/jest-dom";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import React from "react";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * react-i18next is not initialized in the test environment. Echo the default
+ * value and interpolate, so the assertions below are about the sentence the
+ * component builds rather than about a translation file.
+ */
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (
+          key: string,
+          opts?: { defaultValue?: string } & Record<string, unknown>,
+        ): string => {
+          let out: string = opts?.defaultValue ?? key;
+
+          for (const name of Object.keys(opts || {})) {
+            out = out
+              .split(`{{${name}}}`)
+              .join(String((opts as Record<string, unknown>)[name]));
+          }
+
+          return out;
+        },
+        i18n: { resolvedLanguage: "en", language: "en" },
+      };
+    },
+  };
+});
+
+import LastUpdated from "../../../../App/FeatureSet/StatusPage/src/Components/LiveStatus/LastUpdated";
+
+/*
+ * Contract under test - the line that says how old the page is.
+ *
+ * A status page is read during an outage, often from a tab that has been open
+ * a while. Without this line there is no way to tell a page that says
+ * "operational" because everything recovered from one that says it because it
+ * was loaded before anything broke. So: the sentence has to age on its own
+ * while the page sits still, the refresh control has to be honest about
+ * whether it is working, and a refresh that failed has to say so instead of
+ * silently leaving stale data behind a confident timestamp.
+ */
+
+function text(): string {
+  return screen.getByTestId("status-page-last-updated-text").textContent || "";
+}
+
+describe("LastUpdated", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date("2026-03-03T12:00:00.000Z"));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("a page just loaded says it is current", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date("2026-03-03T12:00:00.000Z")}
+        isRefreshing={false}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    expect(text()).toBe("Updated now");
+  });
+
+  test("an older page says how old it is", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date("2026-03-03T11:58:00.000Z")}
+        isRefreshing={false}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    expect(text()).toBe("Updated 2 minutes ago");
+  });
+
+  /*
+   * The whole point. A page nobody touches has to get visibly older, or the
+   * timestamp is just as misleading as no timestamp.
+   */
+  test("the sentence ages while the page sits still", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date("2026-03-03T12:00:00.000Z")}
+        isRefreshing={false}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    expect(text()).toBe("Updated now");
+
+    act(() => {
+      jest.advanceTimersByTime(60 * 1000);
+    });
+
+    expect(text()).toBe("Updated 1 minute ago");
+
+    act(() => {
+      jest.advanceTimersByTime(60 * 60 * 1000);
+    });
+
+    expect(text()).toBe("Updated 1 hour ago");
+  });
+
+  test("its timer is cleaned up when it goes away", () => {
+    const { unmount } = render(
+      <LastUpdated
+        lastRefreshedAt={new Date("2026-03-03T12:00:00.000Z")}
+        isRefreshing={false}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    expect(jest.getTimerCount()).toBeGreaterThan(0);
+
+    unmount();
+
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  /*
+   * Deliberately not a live region: it changes every ten seconds, and a
+   * screen reader reading the age of the page over and over would make the
+   * page unusable. The status itself is the live region.
+   */
+  test("the timestamp does not announce itself over and over", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date("2026-03-03T12:00:00.000Z")}
+        isRefreshing={false}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    const container: HTMLElement = screen.getByTestId(
+      "status-page-last-updated",
+    );
+
+    expect(container.querySelector("[aria-live]")).toBeNull();
+  });
+});
+
+describe("LastUpdated - the refresh control", () => {
+  test("pressing it asks for a refresh", () => {
+    const onRefreshClick: ReturnType<typeof jest.fn<() => void>> =
+      jest.fn<() => void>();
+
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date()}
+        isRefreshing={false}
+        onRefreshClick={onRefreshClick}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("status-page-refresh-button"));
+
+    expect(onRefreshClick).toHaveBeenCalledTimes(1);
+  });
+
+  test("it says so, and locks, while a refresh is in flight", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date()}
+        isRefreshing={true}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    const button: HTMLElement = screen.getByTestId(
+      "status-page-refresh-button",
+    );
+
+    expect(button).toBeDisabled();
+    expect(button).toHaveTextContent("Refreshing");
+  });
+
+  test("a locked control cannot fire a second request", () => {
+    const onRefreshClick: ReturnType<typeof jest.fn<() => void>> =
+      jest.fn<() => void>();
+
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date()}
+        isRefreshing={true}
+        onRefreshClick={onRefreshClick}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("status-page-refresh-button"));
+
+    expect(onRefreshClick).not.toHaveBeenCalled();
+  });
+});
+
+describe("LastUpdated - a refresh that failed", () => {
+  /*
+   * The failure mode this guards against is the quiet one: a background
+   * refresh fails, the page keeps showing a confident timestamp, and the
+   * visitor believes a status that is now half an hour old.
+   */
+  test("says the page is stale rather than showing a confident timestamp", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date("2026-03-03T11:00:00.000Z")}
+        isRefreshing={false}
+        refreshError="Network request failed"
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    expect(text()).toBe("Could not refresh. Showing the last known status.");
+    expect(text()).not.toContain("Updated");
+  });
+
+  test("the refresh control is still offered so the visitor can retry", () => {
+    const onRefreshClick: ReturnType<typeof jest.fn<() => void>> =
+      jest.fn<() => void>();
+
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date()}
+        isRefreshing={false}
+        refreshError="Network request failed"
+        onRefreshClick={onRefreshClick}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("status-page-refresh-button"));
+
+    expect(onRefreshClick).toHaveBeenCalledTimes(1);
+  });
+
+  test("an empty error is not an error", () => {
+    render(
+      <LastUpdated
+        lastRefreshedAt={new Date()}
+        isRefreshing={false}
+        refreshError={null}
+        onRefreshClick={() => {}}
+      />,
+    );
+
+    expect(text()).toContain("Updated");
+  });
+});