@oneuptime/common 13.0.0 → 13.0.3

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

@@ -0,0 +1,476 @@
+import "@testing-library/jest-dom";
+import {
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import React, { act } from "react";
+import { Mock } from "jest-mock";
+import ArchiveResourceCard from "../../../../App/FeatureSet/Dashboard/src/Components/TelemetryResource/ArchiveResourceCard";
+import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import CloudResource from "../../../Models/DatabaseModels/CloudResource";
+import RumApplication from "../../../Models/DatabaseModels/RumApplication";
+import ServerlessFunction from "../../../Models/DatabaseModels/ServerlessFunction";
+import Route from "../../../Types/API/Route";
+import ObjectID from "../../../Types/ObjectID";
+import Permission from "../../../Types/Permission";
+
+interface ArchiveState {
+  isArchived: boolean;
+}
+
+interface ResourceCase {
+  name: string;
+  modelType: { new (): BaseModel };
+  modelId: ObjectID;
+  listRoute: Route;
+  singularName: string;
+  editPermission: Permission;
+  readPermission: Permission;
+  deletePermission: Permission;
+}
+
+interface Deferred<T> {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+}
+
+const getItemMock: Mock<(args: unknown) => Promise<ArchiveState | null>> =
+  jest.fn<(args: unknown) => Promise<ArchiveState | null>>();
+const updateByIdMock: Mock<(args: unknown) => Promise<void>> =
+  jest.fn<(args: unknown) => Promise<void>>();
+const navigateMock: Mock<(route: Route) => void> =
+  jest.fn<(route: Route) => void>();
+const friendlyMessageMock: Mock<(error: unknown) => string> =
+  jest.fn<(error: unknown) => string>();
+let permissions: Array<Permission> = [];
+
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getItem: (args: unknown): Promise<ArchiveState | null> => {
+        return getItemMock(args);
+      },
+      updateById: (args: unknown): Promise<void> => {
+        return updateByIdMock(args);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Navigation", () => {
+  return {
+    __esModule: true,
+    default: {
+      navigate: (route: Route): void => {
+        navigateMock(route);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/API/API", () => {
+  return {
+    __esModule: true,
+    default: {
+      getFriendlyMessage: (error: unknown): string => {
+        return friendlyMessageMock(error);
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Permission", () => {
+  return {
+    __esModule: true,
+    default: {
+      getAllPermissions: (): Array<Permission> => {
+        return permissions;
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: (): boolean => {
+        return false;
+      },
+    },
+  };
+});
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (value: string): string => {
+          return value;
+        },
+      };
+    },
+  };
+});
+
+const RESOURCE_CASES: Array<ResourceCase> = [
+  {
+    name: "RUM application",
+    modelType: RumApplication,
+    modelId: new ObjectID("11111111-0000-4000-8000-000000000001"),
+    listRoute: new Route("/dashboard/project/rum/applications"),
+    singularName: "application",
+    editPermission: Permission.EditRumApplication,
+    readPermission: Permission.ReadRumApplication,
+    deletePermission: Permission.DeleteRumApplication,
+  },
+  {
+    name: "cloud resource",
+    modelType: CloudResource,
+    modelId: new ObjectID("22222222-0000-4000-8000-000000000002"),
+    listRoute: new Route("/dashboard/project/cloud/resources"),
+    singularName: "cloud environment",
+    editPermission: Permission.EditCloudResource,
+    readPermission: Permission.ReadCloudResource,
+    deletePermission: Permission.DeleteCloudResource,
+  },
+  {
+    name: "serverless function",
+    modelType: ServerlessFunction,
+    modelId: new ObjectID("33333333-0000-4000-8000-000000000003"),
+    listRoute: new Route("/dashboard/project/serverless/functions"),
+    singularName: "function",
+    editPermission: Permission.EditServerlessFunction,
+    readPermission: Permission.ReadServerlessFunction,
+    deletePermission: Permission.DeleteServerlessFunction,
+  },
+];
+
+function deferred<T>(): Deferred<T> {
+  let resolvePromise: (value: T) => void = (): void => {};
+  const promise: Promise<T> = new Promise<T>((resolve: (value: T) => void) => {
+    resolvePromise = resolve;
+  });
+
+  return { promise: promise, resolve: resolvePromise };
+}
+
+async function renderCard(resource: ResourceCase): Promise<void> {
+  render(<ArchiveResourceCard {...resource} />);
+  await waitFor(() => {
+    expect(screen.queryByTestId("component-loader")).not.toBeInTheDocument();
+  });
+}
+
+function openConfirmation(action: "Archive" | "Unarchive"): HTMLElement {
+  fireEvent.click(screen.getByRole("button", { name: action }));
+  return screen.getByRole("dialog");
+}
+
+function submitConfirmation(dialog: HTMLElement): void {
+  fireEvent.click(within(dialog).getByTestId("modal-footer-submit-button"));
+}
+
+beforeEach(() => {
+  getItemMock.mockReset().mockResolvedValue({ isArchived: false });
+  updateByIdMock.mockReset().mockResolvedValue(undefined);
+  navigateMock.mockReset();
+  friendlyMessageMock
+    .mockReset()
+    .mockImplementation((error: unknown): string => {
+      return error instanceof Error ? error.message : "Request failed";
+    });
+  permissions = [Permission.EditRumApplication];
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+/*
+ * Exercise the real card, buttons, modal and model permission declarations.
+ * Only the server, navigation and signed-in permission snapshot are replaced.
+ */
+describe.each(RESOURCE_CASES)(
+  "ArchiveResourceCard for a $name",
+  (resource: ResourceCase) => {
+    beforeEach(() => {
+      permissions = [resource.editPermission];
+    });
+
+    test("loads its archive state and requires confirmation before archiving", async () => {
+      await renderCard(resource);
+
+      expect(getItemMock).toHaveBeenCalledTimes(1);
+      expect(getItemMock).toHaveBeenCalledWith({
+        modelType: resource.modelType,
+        id: resource.modelId,
+        select: { isArchived: true },
+      });
+      expect(
+        screen.getByRole("heading", {
+          name: `Archive ${resource.singularName}`,
+        }),
+      ).toBeInTheDocument();
+      expect(screen.getByTestId("card-description")).toHaveTextContent(
+        "keeps collecting telemetry",
+      );
+      expect(screen.getByRole("button", { name: "Archive" })).toBeEnabled();
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(updateByIdMock).not.toHaveBeenCalled();
+
+      const dialog: HTMLElement = openConfirmation("Archive");
+      expect(within(dialog).getByTestId("modal-title")).toHaveTextContent(
+        `Archive ${resource.singularName}`,
+      );
+      expect(
+        within(dialog).getByTestId("confirm-modal-description"),
+      ).toHaveTextContent(
+        `Are you sure you want to archive this ${resource.singularName}? It will be hidden from the list but will keep collecting telemetry.`,
+      );
+      expect(updateByIdMock).not.toHaveBeenCalled();
+
+      submitConfirmation(dialog);
+
+      await waitFor(() => {
+        expect(navigateMock).toHaveBeenCalledWith(resource.listRoute);
+      });
+      expect(navigateMock).toHaveBeenCalledTimes(1);
+      expect(updateByIdMock).toHaveBeenCalledTimes(1);
+      expect(updateByIdMock).toHaveBeenCalledWith({
+        modelType: resource.modelType,
+        id: resource.modelId,
+        data: { isArchived: true },
+      });
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(screen.getByRole("button", { name: "Unarchive" })).toBeEnabled();
+    });
+
+    test("restores an archived resource without leaving Settings", async () => {
+      getItemMock.mockResolvedValue({ isArchived: true });
+      await renderCard(resource);
+
+      expect(
+        screen.getByRole("heading", {
+          name: `Unarchive ${resource.singularName}`,
+        }),
+      ).toBeInTheDocument();
+      expect(screen.getByTestId("card-description")).toHaveTextContent(
+        "is archived and hidden from lists",
+      );
+      expect(screen.getByTestId("card-description")).toHaveTextContent(
+        "still collecting telemetry",
+      );
+
+      const dialog: HTMLElement = openConfirmation("Unarchive");
+      expect(
+        within(dialog).getByTestId("confirm-modal-description"),
+      ).toHaveTextContent(
+        `Are you sure you want to unarchive this ${resource.singularName}? It will reappear in the main list.`,
+      );
+      submitConfirmation(dialog);
+
+      await waitFor(() => {
+        expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      });
+      expect(updateByIdMock).toHaveBeenCalledTimes(1);
+      expect(updateByIdMock).toHaveBeenCalledWith({
+        modelType: resource.modelType,
+        id: resource.modelId,
+        data: { isArchived: false },
+      });
+      expect(screen.getByRole("button", { name: "Archive" })).toBeEnabled();
+      expect(navigateMock).not.toHaveBeenCalled();
+    });
+
+    test.each([false, true])(
+      "read permission alone cannot change archive state (archived: %s)",
+      async (isArchived: boolean) => {
+        permissions = [resource.readPermission];
+        getItemMock.mockResolvedValue({ isArchived: isArchived });
+        await renderCard(resource);
+
+        const action: string = isArchived ? "Unarchive" : "Archive";
+        const button: HTMLElement = screen.getByRole("button", {
+          name: action,
+        });
+        expect(button).toBeDisabled();
+        fireEvent.click(button);
+        expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+        expect(updateByIdMock).not.toHaveBeenCalled();
+
+        fireEvent.mouseEnter(
+          screen.getByTestId("card-button-disabled-wrapper"),
+        );
+        expect(await screen.findByRole("tooltip")).toHaveTextContent(
+          `You do not have permission to update this ${resource.singularName}.`,
+        );
+      },
+    );
+
+    test("delete permission does not substitute for update permission", async () => {
+      permissions = [resource.deletePermission];
+      await renderCard(resource);
+
+      expect(screen.getByRole("button", { name: "Archive" })).toBeDisabled();
+      fireEvent.click(screen.getByRole("button", { name: "Archive" }));
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(updateByIdMock).not.toHaveBeenCalled();
+    });
+  },
+);
+
+describe("ArchiveResourceCard request and confirmation handling", () => {
+  const resource: ResourceCase = RESOURCE_CASES[0]!;
+
+  test("shows loading without an action until archive state arrives", async () => {
+    const pending: Deferred<ArchiveState> = deferred<ArchiveState>();
+    getItemMock.mockReturnValue(pending.promise);
+    render(<ArchiveResourceCard {...resource} />);
+
+    expect(screen.getByTestId("component-loader")).toBeInTheDocument();
+    expect(screen.getByText("Loading…")).toBeInTheDocument();
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+    expect(updateByIdMock).not.toHaveBeenCalled();
+
+    await act(async () => {
+      pending.resolve({ isArchived: true });
+      await pending.promise;
+    });
+
+    expect(screen.queryByTestId("component-loader")).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Unarchive" })).toBeEnabled();
+  });
+
+  test.each([false, true])(
+    "cancel closes confirmation without changing the resource (archived: %s)",
+    async (isArchived: boolean) => {
+      getItemMock.mockResolvedValue({ isArchived: isArchived });
+      await renderCard(resource);
+
+      const action: "Archive" | "Unarchive" = isArchived
+        ? "Unarchive"
+        : "Archive";
+      const dialog: HTMLElement = openConfirmation(action);
+      fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" }));
+
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(screen.getByRole("button", { name: action })).toBeEnabled();
+      expect(updateByIdMock).not.toHaveBeenCalled();
+      expect(navigateMock).not.toHaveBeenCalled();
+    },
+  );
+
+  test("closing the confirmation never submits an archive request", async () => {
+    await renderCard(resource);
+    const dialog: HTMLElement = openConfirmation("Archive");
+    fireEvent.click(within(dialog).getByRole("button", { name: "Close" }));
+
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(updateByIdMock).not.toHaveBeenCalled();
+    expect(navigateMock).not.toHaveBeenCalled();
+  });
+
+  test("waits for a successful save and prevents duplicate submissions", async () => {
+    const pending: Deferred<void> = deferred<void>();
+    updateByIdMock.mockReturnValue(pending.promise);
+    await renderCard(resource);
+    const dialog: HTMLElement = openConfirmation("Archive");
+    submitConfirmation(dialog);
+
+    expect(
+      within(dialog).getByTestId("modal-footer-submit-button"),
+    ).toBeDisabled();
+    submitConfirmation(dialog);
+    expect(updateByIdMock).toHaveBeenCalledTimes(1);
+    expect(navigateMock).not.toHaveBeenCalled();
+
+    await act(async () => {
+      pending.resolve(undefined);
+      await pending.promise;
+    });
+
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(navigateMock).toHaveBeenCalledWith(resource.listRoute);
+  });
+
+  test("can archive and unarchive in place when no list route is supplied", async () => {
+    render(<ArchiveResourceCard {...resource} listRoute={undefined} />);
+    await screen.findByRole("button", { name: "Archive" });
+
+    submitConfirmation(openConfirmation("Archive"));
+    await screen.findByRole("button", { name: "Unarchive" });
+    submitConfirmation(openConfirmation("Unarchive"));
+    await waitFor(() => {
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    });
+
+    expect(updateByIdMock).toHaveBeenNthCalledWith(1, {
+      modelType: resource.modelType,
+      id: resource.modelId,
+      data: { isArchived: true },
+    });
+    expect(updateByIdMock).toHaveBeenNthCalledWith(2, {
+      modelType: resource.modelType,
+      id: resource.modelId,
+      data: { isArchived: false },
+    });
+    expect(screen.getByRole("button", { name: "Archive" })).toBeEnabled();
+    expect(navigateMock).not.toHaveBeenCalled();
+  });
+
+  test("uses the model name when no singular label is supplied", async () => {
+    render(<ArchiveResourceCard {...resource} singularName={undefined} />);
+
+    expect(
+      await screen.findByRole("heading", {
+        name: `Archive ${new RumApplication().singularName}`,
+      }),
+    ).toBeInTheDocument();
+  });
+
+  test("displays a failed state read without offering an archive action", async () => {
+    const error: Error = new Error("Could not load archive status");
+    getItemMock.mockRejectedValue(error);
+    await renderCard(resource);
+
+    expect(screen.getByText(error.message)).toBeInTheDocument();
+    expect(friendlyMessageMock).toHaveBeenCalledWith(error);
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(updateByIdMock).not.toHaveBeenCalled();
+    expect(navigateMock).not.toHaveBeenCalled();
+  });
+
+  test.each([false, true])(
+    "displays save failures and never navigates away (archived: %s)",
+    async (isArchived: boolean) => {
+      const error: Error = new Error("The archive update could not be saved");
+      getItemMock.mockResolvedValue({ isArchived: isArchived });
+      updateByIdMock.mockRejectedValue(error);
+      await renderCard(resource);
+      submitConfirmation(
+        openConfirmation(isArchived ? "Unarchive" : "Archive"),
+      );
+
+      expect(await screen.findByText(error.message)).toBeInTheDocument();
+      expect(friendlyMessageMock).toHaveBeenCalledWith(error);
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(updateByIdMock).toHaveBeenCalledTimes(1);
+      expect(navigateMock).not.toHaveBeenCalled();
+    },
+  );
+});

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

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "@jest/globals";
+import fs from "fs";
+import path from "path";
+import AIChatUnavailableReason, {
+  AIChatUnavailableCopy,
+  getAIChatUnavailableCopy,
+  getAIChatUnavailableReason,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/AIChat/AIChatAvailability";
+import PageMap from "../../../../App/FeatureSet/Dashboard/src/Utils/PageMap";
+import RouteMap from "../../../../App/FeatureSet/Dashboard/src/Utils/RouteMap";
+import Route from "../../../Types/API/Route";
+
+/*
+ * The rule Ask AI uses to decide whether it can take a question, and the words
+ * it uses to explain a "no".
+ *
+ * Two things are easy to get wrong here and neither shows up as a crash:
+ *
+ *   ORDER. Three separate switches can each stop a chat turn, and they are not
+ *   independent — a project on a plan without AI cannot use its own enableAi
+ *   toggle, and a toggle that is off makes a configured provider irrelevant.
+ *   Reporting the wrong one sends the user to a settings page that will not fix
+ *   anything, which is worse than saying nothing.
+ *
+ *   FAILING OPEN. The verdict arrives on the same request as the provider list,
+ *   and that request is slow before it is anything else. Treating "not answered
+ *   yet" as "disabled" would flash a setup notice over a working assistant on
+ *   every single open, and would strand members whose permissions do not let
+ *   them read providers at all.
+ */
+
+const REPO_ROOT: string = path.join(__dirname, "..", "..", "..", "..");
+
+const ALL_REASONS: Array<AIChatUnavailableReason> = Object.values(
+  AIChatUnavailableReason,
+);
+
+// Everything on: the state in which Ask AI must simply work.
+const HEALTHY: Parameters<typeof getAIChatUnavailableReason>[0] = {
+  isAccessibleOnPlan: true,
+  isProjectAIEnabled: true,
+  hasLoadedProviders: true,
+  providerCount: 1,
+};
+
+describe("what stops Ask AI from taking a question", () => {
+  test("nothing, when the plan allows it, the project has AI on and a provider exists", () => {
+    expect(getAIChatUnavailableReason(HEALTHY)).toBeNull();
+  });
+
+  test("a plan without AI", () => {
+    expect(
+      getAIChatUnavailableReason({ ...HEALTHY, isAccessibleOnPlan: false }),
+    ).toBe(AIChatUnavailableReason.PlanUpgradeRequired);
+  });
+
+  test("the project's own AI kill switch", () => {
+    expect(
+      getAIChatUnavailableReason({ ...HEALTHY, isProjectAIEnabled: false }),
+    ).toBe(AIChatUnavailableReason.DisabledForProject);
+  });
+
+  test("a project with no LLM provider at all", () => {
+    expect(getAIChatUnavailableReason({ ...HEALTHY, providerCount: 0 })).toBe(
+      AIChatUnavailableReason.NoProviderConfigured,
+    );
+  });
+});
+
+describe("the reason reported is the one the user has to fix first", () => {
+  test("plan beats the project toggle — the toggle cannot help without the plan", () => {
+    expect(
+      getAIChatUnavailableReason({
+        ...HEALTHY,
+        isAccessibleOnPlan: false,
+        isProjectAIEnabled: false,
+      }),
+    ).toBe(AIChatUnavailableReason.PlanUpgradeRequired);
+  });
+
+  test("plan beats a missing provider", () => {
+    expect(
+      getAIChatUnavailableReason({
+        ...HEALTHY,
+        isAccessibleOnPlan: false,
+        providerCount: 0,
+      }),
+    ).toBe(AIChatUnavailableReason.PlanUpgradeRequired);
+  });
+
+  test("the project toggle beats a missing provider — adding one changes nothing while AI is off", () => {
+    expect(
+      getAIChatUnavailableReason({
+        ...HEALTHY,
+        isProjectAIEnabled: false,
+        providerCount: 0,
+      }),
+    ).toBe(AIChatUnavailableReason.DisabledForProject);
+  });
+
+  test("with everything off, the answer is still the plan", () => {
+    expect(
+      getAIChatUnavailableReason({
+        isAccessibleOnPlan: false,
+        isProjectAIEnabled: false,
+        hasLoadedProviders: true,
+        providerCount: 0,
+      }),
+    ).toBe(AIChatUnavailableReason.PlanUpgradeRequired);
+  });
+});
+
+describe("an unanswered question is not a 'no'", () => {
+  test("an empty provider list that has not loaded yet reports nothing", () => {
+    expect(
+      getAIChatUnavailableReason({
+        ...HEALTHY,
+        hasLoadedProviders: false,
+        providerCount: 0,
+      }),
+    ).toBeNull();
+  });
+
+  test("the toggle defaults to enabled, so a surface that never asked stays usable", () => {
+    /*
+     * This is the shape of a first render, and of a member whose permissions
+     * get the providers request refused: no verdict, no providers, no notice.
+     */
+    expect(
+      getAIChatUnavailableReason({
+        isAccessibleOnPlan: true,
+        isProjectAIEnabled: true,
+        hasLoadedProviders: false,
+        providerCount: 0,
+      }),
+    ).toBeNull();
+  });
+
+  test("only a loaded, genuinely empty provider list closes the door", () => {
+    expect(
+      getAIChatUnavailableReason({
+        ...HEALTHY,
+        hasLoadedProviders: true,
+        providerCount: 0,
+      }),
+    ).not.toBeNull();
+  });
+});
+
+describe("every reason can be explained to the person who hit it", () => {
+  test.each(ALL_REASONS)(
+    "%s has a title, an explanation and a way out",
+    (reason: AIChatUnavailableReason) => {
+      const copy: AIChatUnavailableCopy = getAIChatUnavailableCopy(reason);
+
+      expect(copy.title.length).toBeGreaterThan(0);
+      expect(copy.description.length).toBeGreaterThan(0);
+      expect(copy.actionLabel.length).toBeGreaterThan(0);
+    },
+  );
+
+  test.each(ALL_REASONS)(
+    "%s points at a page that actually exists",
+    (reason: AIChatUnavailableReason) => {
+      const copy: AIChatUnavailableCopy = getAIChatUnavailableCopy(reason);
+
+      expect(Object.values(PageMap)).toContain(copy.actionPage);
+      expect(RouteMap[copy.actionPage as PageMap]).toBeInstanceOf(Route);
+    },
+  );
+
+  test.each(ALL_REASONS)(
+    "%s tells the user where to go, not just that something is wrong",
+    (reason: AIChatUnavailableReason) => {
+      const copy: AIChatUnavailableCopy = getAIChatUnavailableCopy(reason);
+
+      /*
+       * The whole point of the notice: whoever is looking at it usually did
+       * not flip the switch, so "Settings" alone is not an answer.
+       */
+      expect(copy.actionLabel).toMatch(/Settings/);
+    },
+  );
+
+  test("each reason points somewhere different — three reasons collapsing onto one page would hide two of them", () => {
+    const pages: Array<PageMap> = ALL_REASONS.map(
+      (reason: AIChatUnavailableReason) => {
+        return getAIChatUnavailableCopy(reason).actionPage;
+      },
+    );
+
+    expect(new Set(pages).size).toBe(ALL_REASONS.length);
+  });
+
+  test("the kill-switch notice points at the same page the server's own refusal names", () => {
+    /*
+     * AIService.AI_DISABLED_MESSAGE is the sentence a user reads in Slack, on
+     * a runbook step and behind every "Generate with AI" button. Ask AI now
+     * says the same thing before the request instead of after it, and the two
+     * must not drift into naming different screens.
+     *
+     * Read as source text rather than imported: AIService is server code with
+     * a database-shaped import graph, and this file runs in the browser suite.
+     */
+    const aiService: string = fs.readFileSync(
+      path.join(REPO_ROOT, "Common", "Server", "Services", "AIService.ts"),
+      "utf8",
+    );
+
+    const message: string = (aiService.match(
+      /AI_DISABLED_MESSAGE:\s*string\s*=\s*\n?\s*"([^"]+)"/,
+    ) || [])[1] as string;
+
+    expect(message).toBeDefined();
+    expect(message).toContain("AI Credits");
+
+    const copy: AIChatUnavailableCopy = getAIChatUnavailableCopy(
+      AIChatUnavailableReason.DisabledForProject,
+    );
+
+    expect(copy.actionPage).toBe(PageMap.SETTINGS_AI_CREDITS);
+    expect(copy.actionLabel).toContain("AI Credits");
+  });
+});