@oneuptime/common 12.0.4 → 12.0.5

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

@@ -0,0 +1,500 @@
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import "@testing-library/jest-dom";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import React, { act } from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+const postMock: MockFunction = getJestMockFunction();
+const getCommonHeadersMock: MockFunction = getJestMockFunction();
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      post: (...args: Array<any>) => {
+        return postMock(...args);
+      },
+      getFriendlyMessage: () => {
+        return "Request failed";
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getCommonHeaders: (...args: Array<any>) => {
+        return getCommonHeadersMock(...args);
+      },
+    },
+  };
+});
+
+import InvestigationPanel from "../../../../App/FeatureSet/Dashboard/src/Components/AI/InvestigationPanel";
+import { AI_INVESTIGATION_PANEL_ID } from "../../../../App/FeatureSet/Dashboard/src/Components/AI/AIInvestigationStatus";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../Types/API/HTTPResponse";
+import AIRunStatus from "../../../Types/AI/AIRunStatus";
+import { JSONObject } from "../../../Types/JSON";
+import ObjectID from "../../../Types/ObjectID";
+
+const SUBJECT_ID: ObjectID = new ObjectID(
+  "11111111-1111-4111-8111-111111111111",
+);
+const SECOND_SUBJECT_ID: ObjectID = new ObjectID(
+  "22222222-2222-4222-8222-222222222222",
+);
+const POLL_INTERVAL_MS: number = 2500;
+
+type InvestigationResponseFunction = (
+  status: AIRunStatus | null,
+) => HTTPResponse<JSONObject>;
+
+const investigationResponse: InvestigationResponseFunction = (
+  status: AIRunStatus | null,
+): HTTPResponse<JSONObject> => {
+  return new HTTPResponse<JSONObject>(
+    200,
+    {
+      run: status
+        ? {
+            status: status,
+            toolCallCount: 0,
+            totalTokens: 0,
+          }
+        : null,
+      events: [],
+    },
+    {},
+  );
+};
+
+type AdvanceFunction = () => void;
+
+const advance: AdvanceFunction = (): void => {
+  act(() => {
+    jest.advanceTimersByTime(POLL_INTERVAL_MS);
+  });
+};
+
+beforeEach(() => {
+  postMock.mockReset();
+  getCommonHeadersMock.mockReset();
+  getCommonHeadersMock.mockReturnValue({ tenantid: "project-id" });
+});
+
+afterEach(() => {
+  cleanup();
+  jest.useRealTimers();
+});
+
+describe("InvestigationPanel status reporting", () => {
+  test("reports a running investigation and uses the existing incident endpoint", async () => {
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock.mockResolvedValue(investigationResponse(AIRunStatus.Running));
+
+    const { container } = render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+
+    expect(await screen.findByText("Investigating…")).toBeInTheDocument();
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Running);
+    });
+
+    const request: any = postMock.mock.calls[0]?.[0];
+    expect(request.url.toString()).toContain("/ai-investigation/incident");
+    expect(request.data).toEqual({ incidentId: SUBJECT_ID.toString() });
+    expect(request.headers).toEqual({ tenantid: "project-id" });
+
+    const panel: HTMLElement = screen.getByRole("region", {
+      name: "AI Investigation",
+    });
+    expect(panel).toHaveAttribute("id", AI_INVESTIGATION_PANEL_ID);
+    expect(panel).toHaveAttribute("tabindex", "-1");
+    expect(container.innerHTML).toContain("motion-safe:animate-ping");
+  });
+
+  test("reports null only after a successful response confirms no run exists", async () => {
+    const onStatusChange: MockFunction = getJestMockFunction();
+    let resolveRequest: ((response: HTTPResponse<JSONObject>) => void) | null =
+      null;
+    postMock.mockReturnValue(
+      new Promise<HTTPResponse<JSONObject>>(
+        (resolve: (response: HTTPResponse<JSONObject>) => void) => {
+          resolveRequest = resolve;
+        },
+      ),
+    );
+
+    const { container } = render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+
+    expect(onStatusChange).not.toHaveBeenCalled();
+
+    resolveRequest!(investigationResponse(null));
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenCalledTimes(1);
+    });
+
+    expect(onStatusChange).toHaveBeenCalledWith(null);
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  test("discovers an AI run that is enqueued after the incident page loads", async () => {
+    jest.useFakeTimers();
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock
+      .mockResolvedValueOnce(investigationResponse(null))
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Queued));
+
+    render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(null);
+    });
+    expect(jest.getTimerCount()).toBe(1);
+
+    advance();
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Queued);
+    });
+
+    expect(screen.getByText(/Queued/)).toBeInTheDocument();
+    expect(postMock).toHaveBeenCalledTimes(2);
+    expect(jest.getTimerCount()).toBe(1);
+  });
+
+  test("stops discovery polling when no AI run appears", async () => {
+    jest.useFakeTimers();
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock.mockResolvedValue(investigationResponse(null));
+
+    render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(null);
+    });
+
+    for (
+      let expectedRequestCount: number = 2;
+      expectedRequestCount <= 5;
+      expectedRequestCount++
+    ) {
+      advance();
+      await waitFor(() => {
+        expect(postMock).toHaveBeenCalledTimes(expectedRequestCount);
+      });
+      await Promise.resolve();
+      await Promise.resolve();
+    }
+
+    expect(jest.getTimerCount()).toBe(0);
+    advance();
+    expect(postMock).toHaveBeenCalledTimes(5);
+  });
+
+  test("follows queued to running to completed and stops polling at the terminal state", async () => {
+    jest.useFakeTimers();
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Queued))
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Running))
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Completed));
+
+    render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Queued);
+    });
+    expect(screen.getByText(/Queued/)).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(1);
+
+    advance();
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Running);
+    });
+    expect(screen.getByText("Investigating…")).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(1);
+
+    advance();
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Completed);
+    });
+    expect(screen.getByText("Investigation complete")).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(0);
+
+    advance();
+    expect(postMock).toHaveBeenCalledTimes(3);
+  });
+
+  test("does not start a poller for an already completed investigation", async () => {
+    jest.useFakeTimers();
+    postMock.mockResolvedValue(investigationResponse(AIRunStatus.Completed));
+
+    render(
+      <InvestigationPanel subjectType="incident" subjectId={SUBJECT_ID} />,
+    );
+    expect(
+      await screen.findByText("Investigation complete"),
+    ).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(0);
+    advance();
+    expect(postMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("clears its active timer when the panel unmounts", async () => {
+    jest.useFakeTimers();
+    postMock.mockResolvedValue(investigationResponse(AIRunStatus.Running));
+
+    const { unmount } = render(
+      <InvestigationPanel subjectType="incident" subjectId={SUBJECT_ID} />,
+    );
+    expect(await screen.findByText("Investigating…")).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(1);
+
+    unmount();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test("degrades silently when the initial request fails", async () => {
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock.mockResolvedValue(
+      new HTTPErrorResponse(500, { message: "boom" }, {}),
+    );
+
+    const { container } = render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenCalledWith(null);
+    });
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  test("preserves the last active status through a transient polling failure", async () => {
+    jest.useFakeTimers();
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Running))
+      .mockResolvedValueOnce(
+        new HTTPErrorResponse(503, { message: "try again" }, {}),
+      );
+
+    render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Running);
+    });
+
+    advance();
+    await waitFor(() => {
+      expect(postMock).toHaveBeenCalledTimes(2);
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Running);
+    expect(onStatusChange).toHaveBeenCalledTimes(1);
+    expect(screen.getByText("Investigating…")).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(1);
+  });
+
+  test("does not refetch when the same subject is passed as a new ObjectID instance", async () => {
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock.mockResolvedValue(investigationResponse(AIRunStatus.Completed));
+
+    const { rerender } = render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    expect(
+      await screen.findByText("Investigation complete"),
+    ).toBeInTheDocument();
+
+    rerender(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={new ObjectID(SUBJECT_ID.toString())}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    expect(postMock).toHaveBeenCalledTimes(1);
+    expect(onStatusChange).toHaveBeenCalledTimes(1);
+  });
+
+  test("clears an old active investigation when the subject changes and the new request fails", async () => {
+    const onStatusChange: MockFunction = getJestMockFunction();
+    postMock
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Running))
+      .mockResolvedValueOnce(
+        new HTTPErrorResponse(503, { message: "try again" }, {}),
+      );
+
+    const { container, rerender } = render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    expect(await screen.findByText("Investigating…")).toBeInTheDocument();
+
+    rerender(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SECOND_SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(container).toBeEmptyDOMElement();
+      expect(onStatusChange).toHaveBeenLastCalledWith(null);
+    });
+    expect(postMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("ignores a late response from the previous subject", async () => {
+    const onStatusChange: MockFunction = getJestMockFunction();
+    let resolveFirstSubject:
+      | ((response: HTTPResponse<JSONObject>) => void)
+      | null = null;
+
+    postMock.mockImplementation((request: any) => {
+      if (request.data.incidentId === SUBJECT_ID.toString()) {
+        return new Promise<HTTPResponse<JSONObject>>(
+          (resolve: (response: HTTPResponse<JSONObject>) => void) => {
+            resolveFirstSubject = resolve;
+          },
+        );
+      }
+
+      return Promise.resolve(investigationResponse(AIRunStatus.Completed));
+    });
+
+    const { rerender } = render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    await waitFor(() => {
+      expect(postMock).toHaveBeenCalledTimes(1);
+    });
+
+    rerender(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SECOND_SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    expect(
+      await screen.findByText("Investigation complete"),
+    ).toBeInTheDocument();
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Completed);
+    });
+
+    resolveFirstSubject!(investigationResponse(AIRunStatus.Running));
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(screen.getByText("Investigation complete")).toBeInTheDocument();
+    expect(screen.queryByText("Investigating…")).not.toBeInTheDocument();
+    expect(onStatusChange).not.toHaveBeenCalledWith(AIRunStatus.Running);
+    expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Completed);
+  });
+
+  test("waits for an in-flight poll before scheduling another one", async () => {
+    jest.useFakeTimers();
+    const onStatusChange: MockFunction = getJestMockFunction();
+    let resolvePoll: ((response: HTTPResponse<JSONObject>) => void) | null =
+      null;
+    postMock
+      .mockResolvedValueOnce(investigationResponse(AIRunStatus.Running))
+      .mockReturnValueOnce(
+        new Promise<HTTPResponse<JSONObject>>(
+          (resolve: (response: HTTPResponse<JSONObject>) => void) => {
+            resolvePoll = resolve;
+          },
+        ),
+      );
+
+    render(
+      <InvestigationPanel
+        subjectType="incident"
+        subjectId={SUBJECT_ID}
+        onStatusChange={onStatusChange}
+      />,
+    );
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Running);
+    });
+
+    advance();
+    await waitFor(() => {
+      expect(postMock).toHaveBeenCalledTimes(2);
+    });
+    expect(jest.getTimerCount()).toBe(0);
+
+    advance();
+    expect(postMock).toHaveBeenCalledTimes(2);
+
+    resolvePoll!(investigationResponse(AIRunStatus.Completed));
+    await waitFor(() => {
+      expect(onStatusChange).toHaveBeenLastCalledWith(AIRunStatus.Completed);
+    });
+
+    expect(screen.getByText("Investigation complete")).toBeInTheDocument();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+});

package/Tests/App/Dashboard/PortMonitorCriteriaFilter.test.ts

@@ -0,0 +1,93 @@
+import CriteriaFilterUtil from "../../../../App/FeatureSet/Dashboard/src/Utils/Form/Monitor/CriteriaFilter";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
+import FilterCondition from "../../../Types/Filter/FilterCondition";
+import { describe, expect, test } from "@jest/globals";
+
+function values(options: Array<DropdownOption>): Array<string> {
+  return options.map((option: DropdownOption) => {
+    return option.value.toString();
+  });
+}
+
+describe("Dashboard Port timing criteria", () => {
+  test("offers DNS and TCP phase thresholds for Port monitors", () => {
+    expect(
+      values(
+        CriteriaFilterUtil.getCheckOnOptionsByMonitorType(MonitorType.Port),
+      ),
+    ).toEqual([
+      CheckOn.ResponseTime,
+      CheckOn.PortDnsLookupTime,
+      CheckOn.PortTcpConnectTime,
+      CheckOn.IsOnline,
+      CheckOn.IsRequestTimeout,
+    ]);
+  });
+
+  test("labels the persisted response-time criterion as total connection time", () => {
+    const responseTimeOption: DropdownOption | undefined =
+      CriteriaFilterUtil.getCheckOnOptionsByMonitorType(MonitorType.Port).find(
+        (option: DropdownOption) => {
+          return option.value === CheckOn.ResponseTime;
+        },
+      );
+
+    expect(responseTimeOption).toEqual({
+      label: "Total Connection Time (DNS + TCP) (in ms)",
+      value: CheckOn.ResponseTime,
+    });
+  });
+
+  test("does not expose Port phase thresholds on Website monitors", () => {
+    const websiteOptions: Array<string> = values(
+      CriteriaFilterUtil.getCheckOnOptionsByMonitorType(MonitorType.Website),
+    );
+
+    expect(websiteOptions).not.toContain(CheckOn.PortDnsLookupTime);
+    expect(websiteOptions).not.toContain(CheckOn.PortTcpConnectTime);
+  });
+
+  test.each([CheckOn.PortDnsLookupTime, CheckOn.PortTcpConnectTime])(
+    "%s supports numeric threshold comparisons",
+    (checkOn: CheckOn) => {
+      expect(
+        values(CriteriaFilterUtil.getFilterTypeOptionsByCheckOn(checkOn)),
+      ).toEqual([
+        FilterType.GreaterThan,
+        FilterType.LessThan,
+        FilterType.GreaterThanOrEqualTo,
+        FilterType.LessThanOrEqualTo,
+      ]);
+    },
+  );
+
+  test.each([CheckOn.PortDnsLookupTime, CheckOn.PortTcpConnectTime])(
+    "%s gets a millisecond threshold placeholder",
+    (checkOn: CheckOn) => {
+      expect(
+        CriteriaFilterUtil.getFilterTypePlaceholderValueByCheckOn({
+          monitorType: MonitorType.Port,
+          checkOn: checkOn,
+        }),
+      ).toBe("1000");
+    },
+  );
+
+  test("renders the threshold with a millisecond suffix", () => {
+    const filter: CriteriaFilter = {
+      checkOn: CheckOn.PortTcpConnectTime,
+      filterType: FilterType.GreaterThan,
+      value: 125,
+    };
+
+    expect(
+      CriteriaFilterUtil.translateFilterToText(filter, FilterCondition.All),
+    ).toContain("125ms");
+  });
+});

package/Tests/App/StatusPage/PublicStatusPageAPIErrorHandling.test.ts

@@ -0,0 +1,117 @@
+import StatusPageAPI from "../../../../App/FeatureSet/StatusPage/src/Utils/API";
+import StatusPageUtil from "../../../../App/FeatureSet/StatusPage/src/Utils/StatusPage";
+import StatusPageUser from "../../../../App/FeatureSet/StatusPage/src/Utils/User";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
+import CookieName from "../../../Types/CookieName";
+import ObjectID from "../../../Types/ObjectID";
+import LocalStorage from "../../../UI/Utils/LocalStorage";
+import Navigation from "../../../UI/Utils/Navigation";
+import DashboardUser from "../../../UI/Utils/User";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+const STATUS_PAGE_ID: string = "22222222-2222-4222-8222-222222222222";
+const PREVIEW_PATH: string = `/status-page/${STATUS_PAGE_ID}/subscribe/email`;
+
+type SetUrlFunction = (url: string) => void;
+
+interface RecordedSpy {
+  mock: { calls: Array<Array<unknown>> };
+}
+
+const setUrl: SetUrlFunction = (url: string): void => {
+  window.history.replaceState(window.history.state, "", url);
+};
+
+describe("public Status Page API authentication errors", () => {
+  let dashboardLogoutSpy: RecordedSpy;
+  let statusPageLogoutSpy: RecordedSpy;
+  let navigateSpy: RecordedSpy;
+
+  beforeEach(() => {
+    window.localStorage.clear();
+    window.sessionStorage.clear();
+    setUrl(PREVIEW_PATH);
+
+    StatusPageUtil.setStatusPageId(new ObjectID(STATUS_PAGE_ID));
+    StatusPageUtil.setIsPrivateStatusPage(false);
+
+    LocalStorage.setItem("dashboard-session-marker", "keep-me");
+    window.sessionStorage.setItem("dashboard-tab-marker", "keep-me-too");
+    document.cookie = `${CookieName.Token}=dashboard-token; path=/`;
+
+    dashboardLogoutSpy = jest
+      .spyOn(DashboardUser, "logout")
+      .mockImplementation(() => {}) as unknown as RecordedSpy;
+    statusPageLogoutSpy = jest
+      .spyOn(StatusPageUser, "logout")
+      .mockResolvedValue(undefined) as unknown as RecordedSpy;
+    navigateSpy = jest
+      .spyOn(Navigation, "navigate")
+      .mockImplementation(() => {}) as unknown as RecordedSpy;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    document.cookie = `${CookieName.Token}=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/`;
+    window.localStorage.clear();
+    window.sessionStorage.clear();
+  });
+
+  test.each([401, 405])(
+    "keeps the dashboard and Status Page state intact on HTTP %s",
+    (statusCode: number) => {
+      const error: HTTPErrorResponse = new HTTPErrorResponse(
+        statusCode,
+        { message: "Unrelated account authentication error" },
+        {},
+      );
+
+      const result: HTTPErrorResponse = StatusPageAPI.handleError(
+        error,
+      ) as HTTPErrorResponse;
+
+      expect(result).toBe(error);
+      expect(dashboardLogoutSpy).not.toHaveBeenCalled();
+      expect(statusPageLogoutSpy).not.toHaveBeenCalled();
+      expect(navigateSpy).not.toHaveBeenCalled();
+
+      expect(StatusPageUtil.getStatusPageId()?.toString()).toBe(STATUS_PAGE_ID);
+      expect(LocalStorage.getItem("dashboard-session-marker")).toBe("keep-me");
+      expect(window.sessionStorage.getItem("dashboard-tab-marker")).toBe(
+        "keep-me-too",
+      );
+      expect(document.cookie).toContain(`${CookieName.Token}=dashboard-token`);
+      expect(window.location.pathname).toBe(PREVIEW_PATH);
+    },
+  );
+
+  test("retains page-scoped login handling for a private Status Page", () => {
+    StatusPageUtil.setIsPrivateStatusPage(true);
+
+    const error: HTTPErrorResponse = new HTTPErrorResponse(
+      401,
+      { message: "Status Page session expired" },
+      {},
+    );
+
+    StatusPageAPI.handleError(error);
+
+    expect(dashboardLogoutSpy).not.toHaveBeenCalled();
+    expect(statusPageLogoutSpy).toHaveBeenCalledTimes(1);
+    expect(statusPageLogoutSpy).toHaveBeenCalledWith(
+      new ObjectID(STATUS_PAGE_ID),
+    );
+    expect(navigateSpy).toHaveBeenCalledTimes(1);
+    expect(navigateSpy.mock.calls[0]?.[0]?.toString()).toBe(
+      `/status-page/${STATUS_PAGE_ID}/login`,
+    );
+    expect(navigateSpy.mock.calls[0]?.[1]).toEqual({ forceNavigate: true });
+  });
+});