@oneuptime/common 13.0.1 → 13.0.3

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

@@ -25,22 +25,32 @@ const userWithStatus: (enabled: boolean) => User = (enabled: boolean): User => {
   return user;
 };
 
-const openConfirmation: () => Promise<HTMLElement> =
-  async (): Promise<HTMLElement> => {
-    fireEvent.click(
-      await screen.findByRole("button", {
-        name: "Enable two-factor authentication",
-        exact: true,
-      }),
-    );
-    return screen.getByRole("dialog", {
-      name: "Enable two-factor authentication?",
-    });
-  };
+const actionForStatus: (isEnabled: boolean) => string = (
+  isEnabled: boolean,
+): string => {
+  return isEnabled
+    ? "Turn off two-factor authentication"
+    : "Enable two-factor authentication";
+};
+
+const openConfirmation: (isEnabled?: boolean) => Promise<HTMLElement> = async (
+  isEnabled: boolean = false,
+): Promise<HTMLElement> => {
+  const action: string = actionForStatus(isEnabled);
+  fireEvent.click(
+    await screen.findByRole("button", {
+      name: action,
+      exact: true,
+    }),
+  );
+  return screen.getByRole("dialog", {
+    name: `${action}?`,
+  });
+};
 
 describe("two-factor authentication status", () => {
   let loadStatus: jest.SpyInstance;
-  let enable: jest.SpyInstance;
+  let updateStatus: jest.SpyInstance;
 
   beforeEach(() => {
     jest.spyOn(UserUtil, "getUserId").mockReturnValue(userId);
@@ -52,7 +62,7 @@ describe("two-factor authentication status", () => {
     loadStatus = jest
       .spyOn(ModelAPI, "getItem")
       .mockResolvedValue(userWithStatus(false));
-    enable = jest
+    updateStatus = jest
       .spyOn(ModelAPI, "updateById")
       .mockResolvedValue(new HTTPResponse<JSONObject>(200, {}, {}));
   });
@@ -73,7 +83,7 @@ describe("two-factor authentication status", () => {
 
     expect(screen.queryByTestId("two-factor-status")).not.toBeInTheDocument();
     expect(
-      screen.queryByRole("button", { name: /Enable two-factor/ }),
+      screen.queryByRole("button", { name: /Enable|Turn off two-factor/ }),
     ).not.toBeInTheDocument();
     expect(loadStatus).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -92,10 +102,10 @@ describe("two-factor authentication status", () => {
     expect(
       screen.getByRole("button", { name: "Enable two-factor authentication" }),
     ).toBeEnabled();
-    expect(enable).not.toHaveBeenCalled();
+    expect(updateStatus).not.toHaveBeenCalled();
   });
 
-  test("shows enabled status without offering an unsupported self-service disable action", async () => {
+  test("lets the current user turn off enabled two-factor authentication", async () => {
     loadStatus.mockResolvedValue(userWithStatus(true));
     render(<TwoFactorStatus />);
 
@@ -103,12 +113,23 @@ describe("two-factor authentication status", () => {
       "Enabled",
     );
     expect(
-      screen.getByText(/An administrator can turn this off/),
+      screen.getByText(
+        "Use an authenticator app or security key for your second step.",
+      ),
     ).toBeVisible();
     expect(
-      screen.queryByRole("button", { name: /Enable|Disable|Turn off|Edit/i }),
+      screen.getByRole("button", {
+        name: "Turn off two-factor authentication",
+      }),
+    ).toBeEnabled();
+    expect(screen.queryByText(/administrator/i)).not.toBeInTheDocument();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", {
+        name: "Enable two-factor authentication",
+      }),
     ).not.toBeInTheDocument();
-    expect(enable).not.toHaveBeenCalled();
+    expect(updateStatus).not.toHaveBeenCalled();
   });
 
   test.each(["missing user", "missing setting"])(
@@ -126,126 +147,272 @@ describe("two-factor authentication status", () => {
       ).toBeVisible();
       expect(screen.queryByTestId("two-factor-status")).not.toBeInTheDocument();
       expect(
-        screen.queryByRole("button", { name: /Enable two-factor/ }),
+        screen.queryByRole("button", { name: /Enable|Turn off two-factor/ }),
       ).not.toBeInTheDocument();
       expect(screen.getByRole("button", { name: "Try again" })).toBeEnabled();
     },
   );
 
-  test("recovers from a failed status request without making an account change", async () => {
-    loadStatus.mockRejectedValueOnce(
-      new Error("Unable to load account security"),
-    );
-    render(<TwoFactorStatus />);
+  test.each([false, true])(
+    "recovers from a failed status request without making an account change: enabled %s",
+    async (isEnabled: boolean) => {
+      loadStatus
+        .mockRejectedValueOnce(new Error("Unable to load account security"))
+        .mockResolvedValueOnce(userWithStatus(isEnabled));
+      render(<TwoFactorStatus />);
 
-    expect(
-      await screen.findByText("Unable to load account security"),
-    ).toBeVisible();
-    expect(screen.queryByTestId("two-factor-status")).not.toBeInTheDocument();
-    fireEvent.click(screen.getByRole("button", { name: "Try again" }));
-    expect(await screen.findByTestId("two-factor-status")).toHaveTextContent(
-      "Not enabled",
-    );
-    expect(
-      screen.queryByText("Unable to load account security"),
-    ).not.toBeInTheDocument();
-    expect(loadStatus).toHaveBeenCalledTimes(2);
-    expect(enable).not.toHaveBeenCalled();
-  });
+      expect(
+        await screen.findByText("Unable to load account security"),
+      ).toBeVisible();
+      expect(screen.queryByTestId("two-factor-status")).not.toBeInTheDocument();
+      expect(
+        screen.queryByRole("button", { name: /Enable|Turn off two-factor/ }),
+      ).not.toBeInTheDocument();
+      fireEvent.click(screen.getByRole("button", { name: "Try again" }));
+      expect(await screen.findByTestId("two-factor-status")).toHaveTextContent(
+        isEnabled ? "Enabled" : "Not enabled",
+      );
+      expect(
+        screen.getByRole("button", { name: actionForStatus(isEnabled) }),
+      ).toBeEnabled();
+      expect(
+        screen.queryByText("Unable to load account security"),
+      ).not.toBeInTheDocument();
+      expect(loadStatus).toHaveBeenCalledTimes(2);
+      expect(updateStatus).not.toHaveBeenCalled();
+    },
+  );
 
-  test("explains the next sign-in and administrator requirement before enabling, and cancel leaves it unchanged", async () => {
+  test("explains the next sign-in before enabling, and cancel leaves it unchanged", async () => {
     render(<TwoFactorStatus />);
     const dialog: HTMLElement = await openConfirmation();
 
     expect(dialog).toHaveTextContent("finish setup at your next sign-in");
-    expect(dialog).toHaveTextContent("only an administrator can turn it off");
-    expect(enable).not.toHaveBeenCalled();
+    expect(dialog).not.toHaveTextContent(/administrator/i);
+    expect(updateStatus).not.toHaveBeenCalled();
     fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" }));
     expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
     expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
       "Not enabled",
     );
-    expect(enable).not.toHaveBeenCalled();
+    expect(updateStatus).not.toHaveBeenCalled();
   });
 
-  test("sends one enable request and waits for the server before changing status", async () => {
-    let finish: (() => void) | undefined;
-    enable.mockReturnValue(
-      new Promise<void>((resolve: () => void) => {
-        finish = resolve;
-      }),
-    );
-    render(<TwoFactorStatus />);
-    const dialog: HTMLElement = await openConfirmation();
-    const submit: HTMLElement = within(dialog).getByRole("button", {
-      name: "Enable two-factor authentication",
-    });
+  test.each(["Cancel", "Escape"])(
+    "explains turning off two-factor authentication and preserves the account when dismissed with %s",
+    async (dismissal: string) => {
+      loadStatus.mockResolvedValue(userWithStatus(true));
+      render(<TwoFactorStatus />);
+      const dialog: HTMLElement = await openConfirmation(true);
 
-    act(() => {
-      fireEvent.click(submit);
-      fireEvent.click(submit);
-    });
-    expect(enable).toHaveBeenCalledTimes(1);
-    expect(enable).toHaveBeenCalledWith({
-      modelType: User,
-      id: userId,
-      data: { enableTwoFactorAuth: true },
-    });
-    expect(submit).toBeDisabled();
-    expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
-      "Not enabled",
-    );
-    expect(
-      within(dialog).queryByRole("button", { name: "Cancel" }),
-    ).not.toBeInTheDocument();
-    fireEvent.keyDown(dialog, { key: "Escape" });
-    expect(dialog).toBeInTheDocument();
+      expect(dialog).toHaveTextContent(
+        "You will no longer be asked for a second step when signing in with a password.",
+      );
+      expect(dialog).toHaveTextContent(
+        "Your authenticator apps and security keys will stay saved so you can enable it again.",
+      );
+      expect(dialog).not.toHaveTextContent(/administrator/i);
+      expect(updateStatus).not.toHaveBeenCalled();
+      expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
+        "Enabled",
+      );
 
-    await act(async () => {
-      finish!();
-    });
-    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
-    expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
-      "Enabled",
-    );
-    expect(
-      screen.queryByRole("button", {
-        name: "Enable two-factor authentication",
-      }),
-    ).not.toBeInTheDocument();
-  });
+      if (dismissal === "Cancel") {
+        fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" }));
+      } else {
+        fireEvent.keyDown(dialog, { key: "Escape" });
+      }
 
-  test("keeps a failed update visible and supports retrying in the same confirmation", async () => {
-    enable.mockRejectedValueOnce(
-      new Error("Your account could not be updated"),
-    );
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
+        "Enabled",
+      );
+      expect(
+        screen.getByRole("button", {
+          name: "Turn off two-factor authentication",
+        }),
+      ).toBeEnabled();
+      expect(updateStatus).not.toHaveBeenCalled();
+    },
+  );
+
+  test.each([false, true])(
+    "sends one confirmed request and waits for the server before changing status: initially enabled %s",
+    async (isEnabled: boolean) => {
+      let finish: (() => void) | undefined;
+      loadStatus.mockResolvedValue(userWithStatus(isEnabled));
+      updateStatus.mockReturnValue(
+        new Promise<void>((resolve: () => void) => {
+          finish = resolve;
+        }),
+      );
+      render(<TwoFactorStatus />);
+      const dialog: HTMLElement = await openConfirmation(isEnabled);
+      const submit: HTMLElement = within(dialog).getByRole("button", {
+        name: actionForStatus(isEnabled),
+      });
+      expect(updateStatus).not.toHaveBeenCalled();
+
+      act(() => {
+        fireEvent.click(submit);
+        fireEvent.click(submit);
+      });
+      expect(updateStatus).toHaveBeenCalledTimes(1);
+      expect(updateStatus).toHaveBeenCalledWith({
+        modelType: User,
+        id: userId,
+        data: { enableTwoFactorAuth: !isEnabled },
+      });
+      expect(submit).toBeDisabled();
+      expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
+        isEnabled ? "Enabled" : "Not enabled",
+      );
+      expect(
+        within(dialog).queryByRole("button", { name: "Cancel" }),
+      ).not.toBeInTheDocument();
+      expect(
+        within(dialog).queryByRole("button", { name: "Close" }),
+      ).not.toBeInTheDocument();
+      fireEvent.keyDown(dialog, { key: "Escape" });
+      expect(dialog).toBeInTheDocument();
+      expect(updateStatus).toHaveBeenCalledTimes(1);
+
+      await act(async () => {
+        finish!();
+      });
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
+        isEnabled ? "Not enabled" : "Enabled",
+      );
+      expect(
+        screen.getByRole("button", { name: actionForStatus(!isEnabled) }),
+      ).toBeEnabled();
+      expect(
+        screen.queryByRole("button", { name: actionForStatus(isEnabled) }),
+      ).not.toBeInTheDocument();
+    },
+  );
+
+  test.each([false, true])(
+    "keeps a failed update visible and retries the same requested status: initially enabled %s",
+    async (isEnabled: boolean) => {
+      loadStatus.mockResolvedValue(userWithStatus(isEnabled));
+      updateStatus.mockRejectedValueOnce(
+        new Error("Your account could not be updated"),
+      );
+      render(<TwoFactorStatus />);
+      const dialog: HTMLElement = await openConfirmation(isEnabled);
+      fireEvent.click(
+        within(dialog).getByRole("button", {
+          name: actionForStatus(isEnabled),
+        }),
+      );
+
+      expect(
+        await within(dialog).findByText("Your account could not be updated"),
+      ).toBeVisible();
+      expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
+        isEnabled ? "Enabled" : "Not enabled",
+      );
+      const retry: HTMLElement = within(dialog).getByRole("button", {
+        name: actionForStatus(isEnabled),
+      });
+      expect(retry).toBeEnabled();
+      expect(
+        within(dialog).getByRole("button", { name: "Cancel" }),
+      ).toBeEnabled();
+      fireEvent.click(retry);
+      await screen.findByText(isEnabled ? "Not enabled" : "Enabled", {
+        exact: true,
+      });
+      expect(updateStatus).toHaveBeenCalledTimes(2);
+      for (const call of [1, 2]) {
+        expect(updateStatus).toHaveBeenNthCalledWith(call, {
+          modelType: User,
+          id: userId,
+          data: { enableTwoFactorAuth: !isEnabled },
+        });
+      }
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(
+        screen.getByRole("button", { name: actionForStatus(!isEnabled) }),
+      ).toBeEnabled();
+    },
+  );
+
+  test.each([false, true])(
+    "clears a failed update when its confirmation is closed and reopened: initially enabled %s",
+    async (isEnabled: boolean) => {
+      loadStatus.mockResolvedValue(userWithStatus(isEnabled));
+      updateStatus.mockRejectedValueOnce(new Error("Please try again later"));
+      render(<TwoFactorStatus />);
+      const dialog: HTMLElement = await openConfirmation(isEnabled);
+      fireEvent.click(
+        within(dialog).getByRole("button", {
+          name: actionForStatus(isEnabled),
+        }),
+      );
+      expect(
+        await within(dialog).findByText("Please try again later"),
+      ).toBeVisible();
+
+      fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" }));
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
+        isEnabled ? "Enabled" : "Not enabled",
+      );
+
+      const reopened: HTMLElement = await openConfirmation(isEnabled);
+      expect(
+        within(reopened).queryByText("Please try again later"),
+      ).not.toBeInTheDocument();
+      expect(
+        within(reopened).getByRole("button", {
+          name: actionForStatus(isEnabled),
+        }),
+      ).toBeEnabled();
+      expect(updateStatus).toHaveBeenCalledTimes(1);
+    },
+  );
+
+  test("can enable two-factor authentication again after turning it off", async () => {
+    loadStatus.mockResolvedValue(userWithStatus(true));
     render(<TwoFactorStatus />);
-    const dialog: HTMLElement = await openConfirmation();
+    const turnOffDialog: HTMLElement = await openConfirmation(true);
     fireEvent.click(
-      within(dialog).getByRole("button", {
-        name: "Enable two-factor authentication",
+      within(turnOffDialog).getByRole("button", {
+        name: "Turn off two-factor authentication",
       }),
     );
+    await screen.findByText("Not enabled", { exact: true });
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
 
-    expect(
-      await within(dialog).findByText("Your account could not be updated"),
-    ).toBeVisible();
-    expect(screen.getByTestId("two-factor-status")).toHaveTextContent(
-      "Not enabled",
-    );
-    expect(
-      within(dialog).getByRole("button", {
-        name: "Enable two-factor authentication",
-      }),
-    ).toBeEnabled();
+    const enableDialog: HTMLElement = await openConfirmation();
+    expect(enableDialog).toHaveTextContent("finish setup at your next sign-in");
+    expect(enableDialog).not.toHaveTextContent(/administrator/i);
     fireEvent.click(
-      within(dialog).getByRole("button", {
+      within(enableDialog).getByRole("button", {
         name: "Enable two-factor authentication",
       }),
     );
     await screen.findByText("Enabled", { exact: true });
-    expect(enable).toHaveBeenCalledTimes(2);
     expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(updateStatus).toHaveBeenCalledTimes(2);
+    expect(updateStatus).toHaveBeenNthCalledWith(1, {
+      modelType: User,
+      id: userId,
+      data: { enableTwoFactorAuth: false },
+    });
+    expect(updateStatus).toHaveBeenNthCalledWith(2, {
+      modelType: User,
+      id: userId,
+      data: { enableTwoFactorAuth: true },
+    });
+    expect(
+      screen.getByRole("button", {
+        name: "Turn off two-factor authentication",
+      }),
+    ).toBeEnabled();
   });
 
   test("aborts a status request when the page unmounts", () => {

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

@@ -1,5 +1,5 @@
 import "@testing-library/jest-dom";
-import { fireEvent, render, waitFor } from "@testing-library/react";
+import { fireEvent, render, waitFor, within } from "@testing-library/react";
 import React from "react";
 import { beforeEach, describe, expect, jest, test } from "@jest/globals";
 
@@ -271,8 +271,18 @@ describe("BulkAddStatusPageMonitorsModal", () => {
     const view: ReturnType<typeof render> = renderModal();
 
     expect(view.getByText("Monitors")).toBeVisible();
-    expect(view.getByText("Monitor Details")).toBeVisible();
-    expect(view.getByText("Advanced")).toBeVisible();
+
+    /*
+     * The step names are read off the progress nav rather than the whole
+     * modal: the form also renders the current step's name as a heading over
+     * its fields, so an unscoped query for "Monitor Details" matches twice.
+     */
+    const steps: HTMLElement = view.getByRole("navigation", {
+      name: "Progress",
+    });
+
+    expect(within(steps).getByText("Monitor Details")).toBeVisible();
+    expect(within(steps).getByText("Advanced")).toBeVisible();
     expect(view.queryByText("Display Name")).not.toBeInTheDocument();
     expect(view.queryByText("Description")).not.toBeInTheDocument();
   });

package/Tests/Models/AnalyticsModels/RumSessionReplayColumns.test.ts

@@ -2,12 +2,15 @@ import { describe, expect, it, jest } from "@jest/globals";
 import fs from "fs";
 import path from "path";
 import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
-import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
+import AnalyticsTableColumn, {
+  SkipIndexType,
+} from "../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import Permission from "../../../Types/Permission";
 import RumSession from "../../../Models/AnalyticsModels/RumSession";
 import RumSessionChunk from "../../../Models/AnalyticsModels/RumSessionChunk";
 import AddSessionReplayEngagementColumns from "../../../../App/FeatureSet/Workers/DataMigrations/AddSessionReplayEngagementColumns";
+import AddSessionReplayVisitorIdColumn from "../../../../App/FeatureSet/Workers/DataMigrations/AddSessionReplayVisitorIdColumn";
 
 /*
  * The migration imports the two ClickHouse services for their column DDL
@@ -238,14 +241,22 @@ describe("AddSessionReplayEngagementColumns migration", () => {
     ).toHaveLength(2);
   });
 
-  it("is registered LAST in the data-migration chain", () => {
+  /*
+   * Pinned from the END of the chain, not by absolute index: the intent is
+   * that nothing was slipped in behind it, and only the visitor id
+   * migration - added later and registered after it - may follow.
+   */
+  it("is registered second-to-last in the data-migration chain, directly before the visitor id migration", () => {
     const instantiations: Array<string> =
       indexSource.match(/new [A-Za-z0-9_]+\(\)/g) || [];
 
-    expect(instantiations.length).toBeGreaterThan(0);
-    expect(instantiations[instantiations.length - 1]).toBe(
+    expect(instantiations.length).toBeGreaterThan(1);
+    expect(instantiations[instantiations.length - 2]).toBe(
       "new AddSessionReplayEngagementColumns()",
     );
+    expect(instantiations[instantiations.length - 1]).toBe(
+      "new AddSessionReplayVisitorIdColumn()",
+    );
   });
 
   it("does not run in cluster mode, because boot schema-sync performs the same ADD COLUMN there", () => {
@@ -260,3 +271,115 @@ describe("AddSessionReplayEngagementColumns migration", () => {
     );
   });
 });
+
+/*
+ * The anonymous visitor id column (github.com/OneUptime/oneuptime/issues/3705).
+ * The one privacy decision here is pinned by identity, the same way the
+ * traits column is: the id is a random token the RECORDER minted, not
+ * anything the host page said about a person, so it must sit behind
+ * exactly the ACL object the session id and identifiedUserKey use - and
+ * NOT the narrow identity object - or the anonymous applications it
+ * exists to serve could never read it from the session list.
+ */
+describe("RumSession visitor id column", () => {
+  const model: RumSession = new RumSession();
+
+  it("is declared exactly once", () => {
+    expect(
+      model.tableColumns.filter((column: AnalyticsTableColumn): boolean => {
+        return column.key === "visitorId";
+      }),
+    ).toHaveLength(1);
+  });
+
+  it("is a required String defaulting to \"\", so pre-existing rows read as 'predates the recorder'", () => {
+    const column: AnalyticsTableColumn = requireColumn(model, "visitorId");
+
+    expect(column.title).toBe("Visitor ID");
+    expect(column.type).toBe(TableColumnType.Text);
+    expect(column.required).toBe(true);
+    expect(column.defaultValue).toBe("");
+    expect(column.isLowCardinality).toBeFalsy();
+  });
+
+  it("is bloom-indexed for the equality lookup the visitor grouping performs", () => {
+    const column: AnalyticsTableColumn = requireColumn(model, "visitorId");
+
+    expect(column.skipIndex).toEqual({
+      name: "idx_visitor_id",
+      type: SkipIndexType.BloomFilter,
+      params: [0.01],
+      granularity: 1,
+    });
+  });
+
+  it("carries the SAME ACL object as identifiedUserKey and the session id, and NOT the label's", () => {
+    const column: AnalyticsTableColumn = requireColumn(model, "visitorId");
+    const key: AnalyticsTableColumn = requireColumn(model, "identifiedUserKey");
+    const label: AnalyticsTableColumn = requireColumn(
+      model,
+      "identifiedUserLabel",
+    );
+    const session: AnalyticsTableColumn = requireColumn(model, "sessionId");
+
+    expect(column.accessControl).toBeDefined();
+    expect(column.accessControl).toBe(key.accessControl);
+    expect(column.accessControl).toBe(session.accessControl);
+    expect(column.accessControl).not.toBe(label.accessControl);
+    /* The wide object: a plain list reader can group by visitor. */
+    expect(column.accessControl?.read).toContain(
+      Permission.ReadRumSessionReplay,
+    );
+  });
+
+  it("does not disturb the sort key or the no-projections rule", () => {
+    expect(model.sortKeys).toEqual([
+      "projectId",
+      "rumApplicationId",
+      "startTime",
+      "sessionId",
+    ]);
+    expect(model.projections).toEqual([]);
+  });
+});
+
+describe("AddSessionReplayVisitorIdColumn migration", () => {
+  const indexSource: string = fs.readFileSync(
+    path.resolve(
+      __dirname,
+      "../../../../App/FeatureSet/Workers/DataMigrations/Index.ts",
+    ),
+    "utf8",
+  );
+
+  it("is imported and instantiated in DataMigrations/Index.ts exactly once", () => {
+    expect(indexSource).toContain(
+      'import AddSessionReplayVisitorIdColumn from "./AddSessionReplayVisitorIdColumn";',
+    );
+    expect(
+      indexSource.split("new AddSessionReplayVisitorIdColumn()"),
+    ).toHaveLength(2);
+  });
+
+  it("is registered LAST in the data-migration chain", () => {
+    const instantiations: Array<string> =
+      indexSource.match(/new [A-Za-z0-9_]+\(\)/g) || [];
+
+    expect(instantiations.length).toBeGreaterThan(0);
+    expect(instantiations[instantiations.length - 1]).toBe(
+      "new AddSessionReplayVisitorIdColumn()",
+    );
+  });
+
+  it("does not run in cluster mode, because boot schema-sync performs the same ADD COLUMN there", () => {
+    expect(new AddSessionReplayVisitorIdColumn().runsInClusterMode()).toBe(
+      false,
+    );
+  });
+
+  it("names itself so the runner records it under a stable key", () => {
+    expect(new AddSessionReplayVisitorIdColumn().name).toBe(
+      "AddSessionReplayVisitorIdColumn",
+    );
+  });
+});

package/Tests/Models/DatabaseModels/DomainRoleTierCoverage.test.ts

@@ -122,13 +122,14 @@ const NOT_READABLE_BY_THEIR_DOMAIN_ROLES: Array<string> = [
   "StatusPagePrivateUserSession",
 
   /*
-   * The inbound call policy and its escalation rules are configured under
-   * Settings -> Calls rather than alongside on-call schedules, so they follow
-   * the Settings tiers. Their label and owner rules follow their owner models,
-   * which are on-call.
+   * The inbound call policy, its attached phone numbers, and its escalation
+   * rules are configured under Settings -> Calls rather than alongside on-call
+   * schedules, so they follow the Settings tiers. Their label and owner rules
+   * follow their owner models, which are on-call.
    */
   "IncomingCallPolicy",
   "IncomingCallPolicyEscalationRule",
+  "IncomingCallPolicyPhoneNumber",
 ];
 
 /*