@oneuptime/common 14.0.13 → 14.0.14

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

@@ -0,0 +1,333 @@
+import "@testing-library/jest-dom";
+import {
+  act,
+  cleanup,
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from "@testing-library/react";
+import { afterEach, describe, expect, jest, test } from "@jest/globals";
+import React from "react";
+
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string, options?: { defaultValue?: string }): string => {
+          return options?.defaultValue ?? key;
+        },
+      };
+    },
+  };
+});
+
+import BulkChangeStateModal, {
+  BulkChangeStateSubmitData,
+  NOTIFY_SUBSCRIBERS_FIELD_KEY,
+  getBulkChangeStateFormFields,
+} from "../../../../App/FeatureSet/Dashboard/src/Components/EventView/BulkChangeStateModal";
+import {
+  BulkStateChangeNoteTemplate,
+  BulkStateChangeNoteType,
+} from "../../../../App/FeatureSet/Dashboard/src/Utils/BulkStateChange";
+import { JSONObject } from "../../../Types/JSON";
+import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
+import Field from "../../../UI/Components/Forms/Types/Field";
+import Fields from "../../../UI/Components/Forms/Types/Fields";
+import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * The bulk Change State behind the incidents, alerts, episodes and scheduled
+ * maintenance tables walked two steps - State, then Note - once a project
+ * had note templates. With the note folded under "Add a public note" /
+ * "Add a private note", like the single-event dialogs, it is one page of at
+ * most three rows: the state, whether subscribers hear about it, and the
+ * folded note. What it hands the table on submit is unchanged.
+ */
+
+const STATE_KEY: string = "incidentStateId";
+const RESOLVED_ID: string = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaa3";
+
+const STATE_OPTIONS: Array<DropdownOption> = [
+  { value: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaa1", label: "Identified" },
+  { value: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaa2", label: "Acknowledged" },
+  { value: RESOLVED_ID, label: "Resolved" },
+];
+
+const TEMPLATES: Array<BulkStateChangeNoteTemplate> = [
+  {
+    id: "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbb1",
+    templateName: "All clear",
+    note: "Everything is back to normal.",
+  },
+];
+
+const NOTE_TEXT: string = "Rolled back the deploy for every one of these.";
+
+interface RenderOptions {
+  noteType: BulkStateChangeNoteType;
+  showNotify: boolean;
+}
+
+function renderModal(options: RenderOptions): MockFunction {
+  const onSubmit: MockFunction = getJestMockFunction();
+  onSubmit.mockResolvedValue(undefined as never);
+
+  render(
+    <BulkChangeStateModal
+      title="Change Incident State"
+      description="Select the state to change incidents to."
+      stateFieldKey={STATE_KEY}
+      stateOptions={STATE_OPTIONS}
+      noteType={options.noteType}
+      noteTitle={
+        options.noteType === BulkStateChangeNoteType.Public
+          ? "Public Note"
+          : "Private Note"
+      }
+      noteDescription="The same note is added to every incident you selected."
+      noteTemplates={TEMPLATES}
+      showNotifyStatusPageSubscribers={options.showNotify}
+      onClose={getJestMockFunction()}
+      onSubmit={
+        onSubmit as unknown as (
+          data: BulkChangeStateSubmitData,
+        ) => Promise<void>
+      }
+    />,
+  );
+
+  return onSubmit;
+}
+
+function modal(): HTMLElement {
+  return screen.getByTestId("modal");
+}
+
+async function pickResolved(): Promise<void> {
+  const picker: HTMLElement = await within(modal()).findByRole("combobox");
+
+  fireEvent.keyDown(picker, { key: "ArrowDown", code: "ArrowDown" });
+  fireEvent.click(await screen.findByRole("option", { name: "Resolved" }));
+}
+
+async function writeNote(foldName: string): Promise<void> {
+  const fold: HTMLElement = within(modal()).getByRole("button", {
+    name: foldName,
+  });
+
+  expect(fold).toHaveAttribute("aria-expanded", "false");
+  fireEvent.click(fold);
+  expect(fold).toHaveAttribute("aria-expanded", "true");
+
+  // The markdown source view is a plain textarea.
+  fireEvent.click(within(modal()).getByTitle("Switch to markdown source"));
+  fireEvent.change(
+    await within(modal()).findByPlaceholderText("Type your markdown here..."),
+    { target: { value: NOTE_TEXT } },
+  );
+}
+
+async function submit(
+  onSubmit: MockFunction,
+): Promise<BulkChangeStateSubmitData> {
+  fireEvent.click(within(modal()).getByTestId("modal-footer-submit-button"));
+
+  await waitFor(() => {
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  return onSubmit.mock.calls[0]![0] as BulkChangeStateSubmitData;
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("the bulk Change State form", () => {
+  function keyOf(field: Field<JSONObject>): string {
+    return field.overrideFieldKey || Object.keys(field.field || {})[0] || "";
+  }
+
+  test("is the state, the subscriber switch and the folded note - no steps", () => {
+    const fields: Fields<JSONObject> = getBulkChangeStateFormFields({
+      stateFieldKey: STATE_KEY,
+      stateOptions: STATE_OPTIONS,
+      noteType: BulkStateChangeNoteType.Public,
+      noteTitle: "Public Note",
+      noteDescription: "The same note is added to every incident you selected.",
+      noteTemplates: TEMPLATES,
+      showNotifyStatusPageSubscribers: true,
+    });
+
+    expect(fields.map(keyOf)).toEqual([
+      STATE_KEY,
+      NOTIFY_SUBSCRIBERS_FIELD_KEY,
+      "publicNoteTemplate",
+      "publicNote",
+    ]);
+
+    for (const field of fields) {
+      expect(field.stepId).toBeUndefined();
+    }
+
+    // The state stays required; the rest is optional.
+    expect(fields[0]!.title).toBe("Select State");
+    expect(fields[0]!.required).toBe(true);
+    expect(fields[0]!.fieldType).toBe(FormFieldSchemaType.Dropdown);
+    expect(fields[0]!.dropdownOptions).toBe(STATE_OPTIONS);
+
+    // Only the note and its template are folded, under one line.
+    expect(fields[0]!.collapsibleSection).toBeUndefined();
+    expect(fields[1]!.collapsibleSection).toBeUndefined();
+    expect(fields[2]!.collapsibleSection?.title).toBe("Add a public note");
+    expect(fields[3]!.collapsibleSection).toBe(fields[2]!.collapsibleSection);
+
+    // A bulk change does not read each event's settings: the box starts on.
+    expect(fields[1]!.defaultValue).toBe(true);
+  });
+
+  test("has no subscriber switch for alerts and episodes", () => {
+    const fields: Fields<JSONObject> = getBulkChangeStateFormFields({
+      stateFieldKey: "alertStateId",
+      stateOptions: STATE_OPTIONS,
+      noteType: BulkStateChangeNoteType.Private,
+      noteTitle: "Private Note",
+      noteDescription: "Only your team can see it.",
+      noteTemplates: TEMPLATES,
+    });
+
+    expect(fields.map(keyOf)).toEqual([
+      "alertStateId",
+      "privateNoteTemplate",
+      "privateNote",
+    ]);
+    expect(fields[1]!.collapsibleSection?.title).toBe("Add a private note");
+  });
+});
+
+describe("the bulk Change State dialog", () => {
+  test("is one short page with the note folded, even when the project has templates", async () => {
+    renderModal({ noteType: BulkStateChangeNoteType.Public, showNotify: true });
+
+    await within(modal()).findByRole("combobox");
+    // BasicForm settles its steps after mounting.
+    await act(async () => {});
+
+    expect(
+      within(modal()).queryByRole("navigation", { name: "Progress" }),
+    ).toBeNull();
+    expect(
+      within(modal()).queryByTestId("modal-footer-next-button"),
+    ).toBeNull();
+    expect(
+      within(modal()).getByTestId("modal-footer-submit-button"),
+    ).toHaveTextContent("Change State");
+
+    expect(
+      within(modal()).getByRole("checkbox", {
+        name: "Notify Status Page Subscribers",
+      }),
+    ).toBeChecked();
+    expect(
+      within(modal()).getByRole("button", { name: "Add a public note" }),
+    ).toHaveAttribute("aria-expanded", "false");
+
+    // Short while the note is folded; wide once it is opened.
+    expect(modal()).toHaveClass("sm:max-w-lg");
+
+    fireEvent.click(
+      within(modal()).getByRole("button", { name: "Add a public note" }),
+    );
+
+    expect(modal()).toHaveClass("sm:max-w-7xl");
+    expect(
+      within(modal()).getByText("Select Note Template"),
+    ).toBeInTheDocument();
+  });
+
+  test("sends the state, the note and the subscriber choice, as before", async () => {
+    const onSubmit: MockFunction = renderModal({
+      noteType: BulkStateChangeNoteType.Public,
+      showNotify: true,
+    });
+
+    await pickResolved();
+    await writeNote("Add a public note");
+
+    const data: BulkChangeStateSubmitData = await submit(onSubmit);
+
+    expect(data.stateId.toString()).toBe(RESOLVED_ID);
+    expect(data.note).toBe(NOTE_TEXT);
+    expect(data.shouldStatusPageSubscribersBeNotified).toBe(true);
+  });
+
+  test("unticking the box sends false", async () => {
+    const onSubmit: MockFunction = renderModal({
+      noteType: BulkStateChangeNoteType.Public,
+      showNotify: true,
+    });
+
+    await pickResolved();
+    fireEvent.click(
+      within(modal()).getByRole("checkbox", {
+        name: "Notify Status Page Subscribers",
+      }),
+    );
+
+    const data: BulkChangeStateSubmitData = await submit(onSubmit);
+
+    expect(data.shouldStatusPageSubscribersBeNotified).toBe(false);
+    // Nothing written: no note.
+    expect(data.note).toBeUndefined();
+  });
+
+  test("a private note goes with an alert's state, and no subscriber choice is sent", async () => {
+    const onSubmit: MockFunction = renderModal({
+      noteType: BulkStateChangeNoteType.Private,
+      showNotify: false,
+    });
+
+    await pickResolved();
+
+    expect(
+      within(modal()).queryByRole("checkbox", {
+        name: "Notify Status Page Subscribers",
+      }),
+    ).toBeNull();
+
+    await writeNote("Add a private note");
+
+    const data: BulkChangeStateSubmitData = await submit(onSubmit);
+
+    expect(data.stateId.toString()).toBe(RESOLVED_ID);
+    expect(data.note).toBe(NOTE_TEXT);
+    expect(
+      Object.prototype.hasOwnProperty.call(
+        data,
+        "shouldStatusPageSubscribersBeNotified",
+      ),
+    ).toBe(false);
+  });
+
+  test("a state is still required", async () => {
+    const onSubmit: MockFunction = renderModal({
+      noteType: BulkStateChangeNoteType.Private,
+      showNotify: false,
+    });
+
+    await within(modal()).findByRole("combobox");
+
+    fireEvent.click(within(modal()).getByTestId("modal-footer-submit-button"));
+
+    await waitFor(() => {
+      expect(
+        within(modal()).getByText(/Select State is required/i),
+      ).toBeInTheDocument();
+    });
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,307 @@
+import "@testing-library/jest-dom";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import React, { ReactElement } from "react";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+
+/*
+ * Since #4269 an empty list's card description is what its empty state
+ * explains, under "No X yet". These lists used to explain themselves with
+ * "Here is a list of all the incident templates in this project." and the
+ * like; each now says what its items are for. The real pages are rendered
+ * here, for an empty project, as a project admin.
+ *
+ * The copy itself, its translations and the rule against the old openers
+ * are pinned in App/Tests/Dashboard (CardDescriptionsSayWhatFor and
+ * CardDescriptionBoilerplateGuard).
+ */
+
+jest.mock("../../../UI/Utils/Permission", () => {
+  return {
+    __esModule: true,
+    default: {
+      getAllPermissions: (): Array<unknown> => {
+        return ["ProjectAdmin"];
+      },
+      getProjectPermissions: (): null => {
+        return null;
+      },
+      getGlobalPermissions: (): { globalPermissions: Array<unknown> } => {
+        return { globalPermissions: ["ProjectAdmin"] };
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/User", () => {
+  return {
+    __esModule: true,
+    default: {
+      isMasterAdmin: (): boolean => {
+        return false;
+      },
+      getUserId: (): null => {
+        return null;
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Translation", () => {
+  return {
+    __esModule: true,
+    default: () => {
+      return {
+        translateString: (value: string | undefined): string | undefined => {
+          return value;
+        },
+        translateValue: (value: unknown): unknown => {
+          return value;
+        },
+      };
+    },
+  };
+});
+
+// An empty project: every list is empty, every count is zero.
+jest.mock("../../../UI/Utils/ModelAPI/ModelAPI", () => {
+  return {
+    __esModule: true,
+    default: {
+      getList: async (): Promise<{
+        data: Array<unknown>;
+        count: number;
+        skip: number;
+        limit: number;
+      }> => {
+        return { data: [], count: 0, skip: 0, limit: 10 };
+      },
+      getItem: async (): Promise<null> => {
+        return null;
+      },
+      count: async (): Promise<number> => {
+        return 0;
+      },
+      deleteItem: async (): Promise<void> => {
+        return undefined;
+      },
+      updateById: async (): Promise<void> => {
+        return undefined;
+      },
+      createOrUpdate: async (): Promise<null> => {
+        return null;
+      },
+    },
+  };
+});
+
+jest.mock("../../../UI/Utils/Project", () => {
+  return {
+    __esModule: true,
+    default: {
+      getCurrentProjectId: (): { toString: () => string } => {
+        return {
+          toString: (): string => {
+            return "00000000-0000-4000-8000-000000000001";
+          },
+        };
+      },
+      getCurrentProject: (): null => {
+        return null;
+      },
+      getCurrentPlan: (): null => {
+        return null;
+      },
+    },
+  };
+});
+
+import IncidentTemplatesPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Incidents/Settings/IncidentTemplates";
+import ScheduledMaintenanceTemplatesPage from "../../../../App/FeatureSet/Dashboard/src/Pages/ScheduledMaintenanceEvents/Settings/ScheduledMaintenanceTemplates";
+import AnnouncementTemplatesPage from "../../../../App/FeatureSet/Dashboard/src/Pages/StatusPages/Settings/StatusPageAnnouncementTemplates";
+import IncidentEpisodesPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Incidents/Episodes";
+import AlertEpisodesPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Alerts/Episodes";
+import ProjectInvitationsPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Global/ProjectInvitations";
+import GlobalActiveIncidentsPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Global/ActiveIncidents";
+import GlobalActiveAlertsPage from "../../../../App/FeatureSet/Dashboard/src/Pages/Global/ActiveAlerts";
+import PageComponentProps from "../../../../App/FeatureSet/Dashboard/src/Pages/PageComponentProps";
+import PageMap from "../../../../App/FeatureSet/Dashboard/src/Utils/PageMap";
+import RouteMap from "../../../../App/FeatureSet/Dashboard/src/Utils/RouteMap";
+import Route from "../../../Types/API/Route";
+import Navigation from "../../../UI/Utils/Navigation";
+import PermissionGate from "../../../UI/Utils/PermissionGate";
+import TableFilterUrlState from "../../../UI/Utils/TableFilterUrlState";
+import { getJestSpyOn } from "../../Spy";
+
+const PROJECT_ID: string = "00000000-0000-4000-8000-000000000001";
+
+function propsFor(page: PageMap): PageComponentProps {
+  return {
+    pageRoute: RouteMap[page] as Route,
+    hasPaymentMethod: true,
+    currentProject: null,
+  } as unknown as PageComponentProps;
+}
+
+interface EmptyList {
+  name: string;
+  render: () => ReactElement;
+  description: string;
+}
+
+const EMPTY_LISTS: Array<EmptyList> = [
+  {
+    name: "Incident Templates",
+    render: (): ReactElement => {
+      return (
+        <IncidentTemplatesPage
+          {...propsFor(PageMap.INCIDENTS_SETTINGS_TEMPLATES)}
+        />
+      );
+    },
+    description:
+      "Ready-made incidents for problems you expect, with the title, severity, monitors and on-call policy filled in. Use one with Create from Template on the Incidents page.",
+  },
+  {
+    name: "Scheduled Maintenance Templates",
+    render: (): ReactElement => {
+      return (
+        <ScheduledMaintenanceTemplatesPage
+          {...propsFor(PageMap.SCHEDULED_MAINTENANCE_EVENTS_SETTINGS_TEMPLATES)}
+        />
+      );
+    },
+    description:
+      "Ready-made maintenance events for work you do often, with the title, monitors, status pages and notifications filled in. Use one with Create from Template, or make it recurring to schedule events automatically.",
+  },
+  {
+    name: "Status Page Announcement Templates",
+    render: (): ReactElement => {
+      return (
+        <AnnouncementTemplatesPage
+          {...propsFor(PageMap.STATUS_PAGES_SETTINGS_ANNOUNCEMENT_TEMPLATES)}
+        />
+      );
+    },
+    description:
+      "Ready-made announcements for news you post often, such as a planned upgrade. Use one with Create from Template on the Announcements page, and edit it before you publish.",
+  },
+  {
+    name: "Incident Episodes",
+    render: (): ReactElement => {
+      return <IncidentEpisodesPage {...propsFor(PageMap.INCIDENT_EPISODES)} />;
+    },
+    description:
+      "Episodes group related incidents so you can respond to them together. Grouping rules open episodes for you, or you can create one yourself.",
+  },
+  {
+    name: "Alert Episodes",
+    render: (): ReactElement => {
+      return <AlertEpisodesPage {...propsFor(PageMap.ALERT_EPISODES)} />;
+    },
+    description:
+      "Episodes group related alerts so you can respond to them together. Grouping rules open episodes for you, or you can create one yourself.",
+  },
+  {
+    name: "Project Invitations",
+    render: (): ReactElement => {
+      return (
+        <ProjectInvitationsPage {...propsFor(PageMap.PROJECT_INVITATIONS)} />
+      );
+    },
+    description:
+      "When someone invites you to a project or a team, the invitation waits here until you accept or reject it.",
+  },
+];
+
+beforeEach(() => {
+  PermissionGate.clearPermissionPropsCache();
+  window.history.replaceState(
+    window.history.state,
+    "",
+    `/dashboard/${PROJECT_ID}/home`,
+  );
+  TableFilterUrlState.resetClaimedKeys();
+  window.localStorage.clear();
+  getJestSpyOn(Navigation, "navigate").mockImplementation((): void => {
+    return undefined;
+  });
+});
+
+afterEach(() => {
+  cleanup();
+  jest.restoreAllMocks();
+});
+
+async function emptyStateDescription(): Promise<HTMLElement> {
+  return await screen.findByTestId(
+    "table-empty-state-description",
+    {},
+    { timeout: 10000 },
+  );
+}
+
+describe.each(EMPTY_LISTS)("$name, empty", (list: EmptyList) => {
+  test("explains what the list is for", async () => {
+    render(list.render());
+
+    const description: HTMLElement = await emptyStateDescription();
+
+    expect(description).toHaveTextContent(list.description);
+  });
+
+  test("says it once, and never 'Here is a list of'", async () => {
+    render(list.render());
+    await emptyStateDescription();
+
+    // The card's header leaves its description out while the state says it.
+    expect(screen.queryByTestId("card-description")).toBeNull();
+    expect(document.body.textContent || "").not.toMatch(/Here (is|are)\b/);
+  });
+});
+
+describe("the cross-project Active lists say what they hold", () => {
+  test.each([
+    [
+      "Active Incidents",
+      (): ReactElement => {
+        return (
+          <GlobalActiveIncidentsPage {...propsFor(PageMap.ACTIVE_INCIDENTS)} />
+        );
+      },
+      "Incidents nobody has acknowledged yet, from every project you belong to. Open one to acknowledge it.",
+    ],
+    [
+      "Active Alerts",
+      (): ReactElement => {
+        return <GlobalActiveAlertsPage {...propsFor(PageMap.ACTIVE_ALERTS)} />;
+      },
+      "Alerts nobody has acknowledged yet, from every project you belong to. Open one to acknowledge it.",
+    ],
+  ])(
+    "%s, in the header above its all-clear",
+    async (_name: string, page: () => ReactElement, sentence: string) => {
+      render(page());
+
+      /*
+       * Empty is good news here: the state is all clear, and the list's
+       * description stays in the card's header above it.
+       */
+      await waitFor(
+        () => {
+          expect(screen.getByTestId("card-description")).toHaveTextContent(
+            sentence,
+          );
+        },
+        { timeout: 10000 },
+      );
+      expect(document.body.textContent || "").not.toMatch(/Here (is|are)\b/);
+    },
+  );
+});

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

@@ -452,14 +452,28 @@ describe.each([
 
       fireEvent.click(document.getElementById(headerCase.acknowledgeId)!);
 
+      type ModalField = {
+        overrideFieldKey?: string | undefined;
+        showIf?: () => boolean;
+      };
+
       const modalProps: {
-        formProps: { fields: Array<{ showIf?: () => boolean }> };
+        formProps: { fields: Array<ModalField> };
       } = modelFormModalMock.mock.calls[
         modelFormModalMock.mock.calls.length - 1
-      ]![0] as { formProps: { fields: Array<{ showIf?: () => boolean }> } };
+      ]![0] as { formProps: { fields: Array<ModalField> } };
+
+      /*
+       * No templates, so the template picker (folded with the note, after
+       * any notify checkbox) stays hidden.
+       */
+      const templatePicker: ModalField | undefined =
+        modalProps.formProps.fields.find((field: ModalField): boolean => {
+          return Boolean(field.overrideFieldKey?.endsWith("NoteTemplate"));
+        });
 
-      // No templates, so the template picker stays hidden.
-      expect(modalProps.formProps.fields[0]!.showIf!()).toBe(false);
+      expect(templatePicker).toBeDefined();
+      expect(templatePicker!.showIf!()).toBe(false);
     });
 
     test("a failed state read offers a retry that recovers", async () => {

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

@@ -27,6 +27,7 @@ import ProjectUtil from "../../../UI/Utils/Project";
 import { HOST, HTTP_PROTOCOL } from "../../../UI/Config";
 import Protocol from "../../../Types/API/Protocol";
 import TelemetryIngestionKey from "../../../Models/DatabaseModels/TelemetryIngestionKey";
+import TelemetryIngestionKeyType from "../../../Types/Telemetry/TelemetryIngestionKeyType";
 import ObjectID from "../../../Types/ObjectID";
 import {
   CLOUD_PROVIDER_LABELS,
@@ -371,13 +372,17 @@ describe("CloudDocumentationCard", () => {
         "Pick an ingestion key in step 1",
       );
 
-      // Every key in the project is offered: a cloud workload is a server.
+      /*
+       * Only Server keys are offered (and made): a cloud workload is a
+       * server, and its exporter sends no Origin header, so a Browser key
+       * would be refused on every export.
+       */
       const query: Record<string, unknown> = (
         getList.mock.calls[0]![0] as unknown as {
           query: Record<string, unknown>;
         }
       ).query;
-      expect(query["keyType"]).toBeUndefined();
+      expect(query["keyType"]).toBe(TelemetryIngestionKeyType.Server);
     });
 
     test("before the project has a key, the snippets show the placeholder and say where to pick one", async () => {