@oneuptime/common 11.7.0 → 11.7.2

package/Tests/Types/DateUserTimezone.test.ts

@@ -0,0 +1,205 @@
+/**
+ * The user's profile timezone (User Settings > Timezone) — not the zone the
+ * browser reports — decides which wall clock OneUptimeDate reads and writes.
+ *
+ * The bug these lock in: a user in America/New_York whose browser reported
+ * America/Adak was told "your local timezone - HDT" on every date field, and
+ * had to enter Hawaii-Aleutian times for their events to land correctly. The
+ * profile timezone was stored but never consulted by the UI.
+ *
+ * Every assertion is expressed in explicit-zone wall-clock (or absolute
+ * milliseconds) so it holds under whatever TZ the suite runs in.
+ */
+import OneUptimeDate from "../../Types/Date";
+import Timezone from "../../Types/Timezone";
+import moment from "moment-timezone";
+
+const NY: Timezone = Timezone.AmericaNew_York;
+const ADAK: Timezone = Timezone.AmericaAdak;
+const KOLKATA: Timezone = Timezone.AsiaKolkata;
+
+describe("OneUptimeDate user timezone", () => {
+  afterEach(() => {
+    // Never leak an override into the rest of the suite.
+    OneUptimeDate.setUserTimezone(null);
+  });
+
+  describe("setUserTimezone / getCurrentTimezone", () => {
+    it("falls back to the browser / process zone when no user timezone is set", () => {
+      expect(OneUptimeDate.getUserTimezone()).toBeNull();
+      expect(OneUptimeDate.getCurrentTimezone().toString()).toBe(
+        moment.tz.guess(),
+      );
+    });
+
+    it("prefers the user timezone over the browser / process zone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      expect(OneUptimeDate.getCurrentTimezone()).toBe(NY);
+      expect(OneUptimeDate.getUserTimezone()).toBe(NY);
+    });
+
+    it("reports the abbreviation of the user timezone, DST aware", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // The bug reported "HDT" (America/Adak) for a New York user.
+      expect(OneUptimeDate.getCurrentTimezoneString()).not.toBe("HDT");
+      expect(["EST", "EDT"]).toContain(
+        OneUptimeDate.getCurrentTimezoneString(),
+      );
+    });
+
+    it("clears back to the browser / process zone when set to null", () => {
+      OneUptimeDate.setUserTimezone(NY);
+      OneUptimeDate.setUserTimezone(null);
+
+      expect(OneUptimeDate.getUserTimezone()).toBeNull();
+      expect(OneUptimeDate.getCurrentTimezone().toString()).toBe(
+        moment.tz.guess(),
+      );
+    });
+
+    it("ignores a value moment does not recognise as a zone rather than breaking every date", () => {
+      OneUptimeDate.setUserTimezone("Not/AZone" as Timezone);
+
+      expect(OneUptimeDate.getUserTimezone()).toBeNull();
+      expect(OneUptimeDate.getCurrentTimezone().toString()).toBe(
+        moment.tz.guess(),
+      );
+      // Formatting still works.
+      expect(
+        OneUptimeDate.toDateTimeLocalString(new Date("2026-07-09T13:00:00Z")),
+      ).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/);
+    });
+  });
+
+  describe("datetime-local round trip", () => {
+    it("renders a stored instant as its wall-clock in the user timezone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // 17:00 UTC on 2026-07-09 is 13:00 in New York (EDT).
+      expect(
+        OneUptimeDate.toDateTimeLocalString(new Date("2026-07-09T17:00:00Z")),
+      ).toBe("2026-07-09T13:00:00");
+    });
+
+    it("resolves a typed wall-clock in the user timezone, not the browser zone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const typed: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T13:00");
+
+      expect(typed.toISOString()).toBe("2026-07-09T17:00:00.000Z");
+    });
+
+    it("round trips what the user typed back into the picker unchanged", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const typed: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-01-15T09:30");
+
+      expect(OneUptimeDate.toDateTimeLocalString(typed)).toBe(
+        "2026-01-15T09:30:00",
+      );
+    });
+
+    it("stores different instants for the same wall-clock in different user timezones", () => {
+      OneUptimeDate.setUserTimezone(NY);
+      const inNY: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T13:00");
+
+      OneUptimeDate.setUserTimezone(ADAK);
+      const inAdak: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T13:00");
+
+      // Adak is 5 hours behind New York in July.
+      expect(inAdak.getTime() - inNY.getTime()).toBe(5 * 60 * 60 * 1000);
+    });
+
+    it("honours the user timezone's DST offset for a winter instant", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // 09:00 EST is 14:00 UTC in January.
+      expect(
+        OneUptimeDate.fromDateTimeLocalString("2026-01-15T09:00").toISOString(),
+      ).toBe("2026-01-15T14:00:00.000Z");
+    });
+  });
+
+  describe("display helpers", () => {
+    it("formats an instant in the user timezone with its abbreviation", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const formatted: string = OneUptimeDate.getDateAsLocalFormattedString(
+        new Date("2026-07-09T17:00:00Z"),
+      );
+
+      expect(formatted).toContain("Jul 09 2026");
+      expect(formatted).toContain("13:00");
+      expect(formatted).toContain("EDT");
+    });
+
+    it("reads the hour and minute of an instant in the user timezone", () => {
+      OneUptimeDate.setUserTimezone(KOLKATA);
+
+      const instant: Date = new Date("2026-07-09T17:00:00Z");
+
+      // 17:00 UTC is 22:30 in Kolkata (UTC+5:30).
+      expect(OneUptimeDate.getLocalHours(instant)).toBe(22);
+      expect(OneUptimeDate.getLocalMinutes(instant)).toBe(30);
+      expect(OneUptimeDate.getLocalTimeString(instant)).toBe("22:30");
+    });
+
+    it("rolls the calendar day when the user timezone puts the instant on another date", () => {
+      OneUptimeDate.setUserTimezone(KOLKATA);
+
+      // 23:00 UTC on Jul 9 is already 04:30 on Jul 10 in Kolkata.
+      const instant: Date = new Date("2026-07-09T23:00:00Z");
+
+      expect(OneUptimeDate.asDateForDatabaseQuery(instant)).toBe("2026-07-10");
+      expect(OneUptimeDate.getDateAsLocalDayMonthString(instant)).toBe(
+        "10 Jul",
+      );
+      expect(OneUptimeDate.getDateAsLocalMonthYearString(instant)).toBe(
+        "Jul 2026",
+      );
+    });
+  });
+
+  describe("schedule-zone wall-clock bridge", () => {
+    it("reads the entered wall-clock in the user timezone before anchoring it to the schedule zone", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      // The admin typed 09:00 while working in New York.
+      const typed: Date =
+        OneUptimeDate.fromDateTimeLocalString("2026-07-09T09:00");
+
+      const stored: Date = OneUptimeDate.getInstantFromLocalWallClockInTimezone(
+        typed,
+        KOLKATA.toString(),
+      );
+
+      // ...and the schedule enforces 09:00 in Kolkata.
+      expect(moment.tz(stored, KOLKATA.toString()).format("HH:mm")).toBe(
+        "09:00",
+      );
+    });
+
+    it("redisplays a stored schedule-zone time as the same wall-clock in the picker", () => {
+      OneUptimeDate.setUserTimezone(NY);
+
+      const stored: Date = moment
+        .tz("2026-07-09 09:00", KOLKATA.toString())
+        .toDate();
+
+      const forPicker: Date = OneUptimeDate.getLocalDateFromWallClockInTimezone(
+        stored,
+        KOLKATA.toString(),
+      );
+
+      expect(OneUptimeDate.toDateTimeLocalString(forPicker)).toBe(
+        "2026-07-09T09:00:00",
+      );
+    });
+  });
+});

package/Tests/Types/DateUserTimezoneOverridesBrowser.test.ts

@@ -0,0 +1,73 @@
+/** @timezone America/Adak */
+
+/**
+ * Regression test for the reported bug, reproduced exactly: the process (a
+ * stand-in for the customer's browser) reports America/Adak — abbreviated
+ * "HDT" — while the user has picked America/New_York in User Settings.
+ *
+ * Before the fix, every date field labelled itself "your local timezone - HDT"
+ * and resolved what the user typed in Adak's zone, so a New York user had to
+ * enter Hawaii-Aleutian times to get the right instant stored. The profile
+ * timezone must win over whatever the browser reports.
+ */
+import OneUptimeDate from "../../Types/Date";
+import Timezone from "../../Types/Timezone";
+import moment from "moment-timezone";
+
+const NY: Timezone = Timezone.AmericaNew_York;
+
+describe("user timezone overrides a browser reporting a different zone", () => {
+  afterEach(() => {
+    OneUptimeDate.setUserTimezone(null);
+  });
+
+  it("confirms the process really is on the Adak (HDT) clock", () => {
+    // Guards the premise of every assertion below.
+    expect(moment.tz.guess()).toBe("America/Adak");
+    expect(OneUptimeDate.getCurrentTimezoneString()).toBe("HDT");
+  });
+
+  it("labels date fields with the profile timezone, not HDT", () => {
+    OneUptimeDate.setUserTimezone(NY);
+
+    expect(OneUptimeDate.getCurrentTimezoneString()).toBe("EDT");
+    expect(OneUptimeDate.getCurrentTimezone()).toBe(NY);
+  });
+
+  it("stores the wall-clock the user typed as New York time", () => {
+    OneUptimeDate.setUserTimezone(NY);
+
+    /*
+     * The user schedules maintenance for 14:00 on Jul 9. That is 18:00 UTC in
+     * New York; reading it on the Adak clock would have stored 23:00 UTC —
+     * five hours off, which is exactly what the customer worked around.
+     */
+    const startsAt: Date =
+      OneUptimeDate.fromDateTimeLocalString("2026-07-09T14:00");
+
+    expect(startsAt.toISOString()).toBe("2026-07-09T18:00:00.000Z");
+  });
+
+  it("reads a stored event back at the wall-clock the user typed", () => {
+    OneUptimeDate.setUserTimezone(NY);
+
+    const startsAt: Date = new Date("2026-07-09T18:00:00.000Z");
+
+    expect(OneUptimeDate.toDateTimeLocalString(startsAt)).toBe(
+      "2026-07-09T14:00:00",
+    );
+    expect(OneUptimeDate.getDateAsLocalFormattedString(startsAt)).toContain(
+      "EDT",
+    );
+    expect(OneUptimeDate.getLocalTimeString(startsAt)).toBe("14:00");
+  });
+
+  it("still follows the browser zone for a user who has not picked one", () => {
+    OneUptimeDate.setUserTimezone(null);
+
+    // 14:00 HDT (UTC-9) is 23:00 UTC the same day.
+    expect(
+      OneUptimeDate.fromDateTimeLocalString("2026-07-09T14:00").toISOString(),
+    ).toBe("2026-07-09T23:00:00.000Z");
+  });
+});

package/Tests/Types/Workspace/NotificationRules/NotificationRuleCondition.test.ts

@@ -98,7 +98,7 @@ describe("NotificationRuleConditionUtil", () => {
         shouldPostToExistingChannel: false,
       });
       expect(validate(rule)).toBe(
-        "Please select either create slack channel or post to existing Slack channel",
+        "Please select a destination: create a Slack channel or post to an existing Slack channel",
       );
     });
 
@@ -139,6 +139,224 @@ describe("NotificationRuleConditionUtil", () => {
     });
   });
 
+  describe("getValidationError - chats", () => {
+    const teamsChatEitherOrError: string =
+      "Please select a destination: create a Microsoft Teams channel, post to an existing Microsoft Teams channel, or post to an existing Microsoft Teams chat";
+
+    const teamsChatIdsError: string =
+      "Please select at least one Microsoft Teams chat to post to. If no chats are listed, add the OneUptime app to a chat in Microsoft Teams first.";
+
+    const validateTeams: (
+      rule: IncidentNotificationRule,
+      eventType?: NotificationRuleEventType,
+    ) => string | null = (
+      rule: IncidentNotificationRule,
+      eventType: NotificationRuleEventType = NotificationRuleEventType.Incident,
+    ): string | null => {
+      return NotificationRuleConditionUtil.getValidationError({
+        notificationRule: rule,
+        eventType: eventType,
+        workspaceType: WorkspaceType.MicrosoftTeams,
+      });
+    };
+
+    test("a Teams rule posting only to an existing chat satisfies the either/or requirement", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+        existingChatIds: ["c1"],
+      });
+      expect(validateTeams(rule)).toBeNull();
+    });
+
+    test("a Teams rule with all three destination toggles off mentions the chat option in the error", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: false,
+      });
+      expect(validateTeams(rule)).toBe(teamsChatEitherOrError);
+    });
+
+    test("a Slack rule with both channel toggles off does not mention the chat option", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+      });
+      const error: string | null = validate(rule);
+      expect(error).toBe(
+        "Please select a destination: create a Slack channel or post to an existing Slack channel",
+      );
+      expect(error).not.toContain("chat");
+    });
+
+    test("chat toggle on with an empty chat-id list returns the chat-selection error", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+        existingChatIds: [],
+      });
+      expect(validateTeams(rule)).toBe(teamsChatIdsError);
+    });
+
+    test("chat toggle on with undefined chat ids returns the chat-selection error", () => {
+      // existingChatIds is intentionally left off the rule so it is undefined.
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+      });
+      expect(rule.existingChatIds).toBeUndefined();
+      expect(validateTeams(rule)).toBe(teamsChatIdsError);
+    });
+
+    test("chat toggle on with chat ids passes even when channel toggles are also configured", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldPostToExistingChat: true,
+        existingChatIds: ["19:abc@thread.v2", "19:def@unq.gbl.spaces"],
+      });
+      expect(validateTeams(rule)).toBeNull();
+    });
+
+    test("chat-id validation still runs for the Monitor event type (either/or block is skipped)", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+        existingChatIds: [],
+      });
+      expect(validateTeams(rule, NotificationRuleEventType.Monitor)).toBe(
+        teamsChatIdsError,
+      );
+    });
+
+    test("chat-id validation still runs for the OnCallDutyPolicy event type", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+        existingChatIds: [],
+      });
+      expect(
+        validateTeams(rule, NotificationRuleEventType.OnCallDutyPolicy),
+      ).toBe(teamsChatIdsError);
+    });
+
+    test("a Monitor-event chat rule with chat ids passes", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+        existingChatIds: ["c1"],
+      });
+      expect(validateTeams(rule, NotificationRuleEventType.Monitor)).toBeNull();
+    });
+
+    test("a combined existing-channel + chat rule is valid", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: true,
+        existingChannelNames: "ops-alerts",
+        shouldPostToExistingChat: true,
+        existingChatIds: ["c1"],
+      });
+      expect(validateTeams(rule)).toBeNull();
+    });
+
+    test("existing-channel toggle still requires channel names even when chat fields are valid", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: true,
+        existingChannelNames: "   ",
+        shouldPostToExistingChat: true,
+        existingChatIds: ["c1"],
+      });
+      expect(validateTeams(rule)).toBe(
+        "Existing Microsoft Teams channel name is required",
+      );
+    });
+
+    test("create-channel toggle still requires a template name even when chat fields are valid", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: true,
+        newChannelTemplateName: "  ",
+        shouldPostToExistingChannel: false,
+        shouldPostToExistingChat: true,
+        existingChatIds: ["c1"],
+      });
+      expect(validateTeams(rule)).toBe(
+        "New Microsoft Teams channel name is required",
+      );
+    });
+
+    test("channel-name errors take precedence over the chat-id error", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: true,
+        existingChannelNames: "",
+        shouldPostToExistingChat: true,
+        existingChatIds: [],
+      });
+      expect(validateTeams(rule)).toBe(
+        "Existing Microsoft Teams channel name is required",
+      );
+    });
+
+    test("chat-id validation is workspace-agnostic: a Slack rule with the chat toggle on and no ids errors too", () => {
+      /*
+       * The chat toggle is only surfaced in the Teams UI, but the validator
+       * does not gate the chat-ids check on workspace type. Pin the current
+       * behavior so a change here is deliberate.
+       */
+      const rule: IncidentNotificationRule = makeRule({
+        shouldPostToExistingChat: true,
+        existingChatIds: [],
+      });
+      expect(validate(rule)).toBe(
+        "Please select at least one Slack chat to post to. If no chats are listed, add the OneUptime app to a chat in Slack first.",
+      );
+    });
+
+    test.each([
+      NotificationRuleEventType.Incident,
+      NotificationRuleEventType.Alert,
+      NotificationRuleEventType.AlertEpisode,
+      NotificationRuleEventType.IncidentEpisode,
+      NotificationRuleEventType.ScheduledMaintenance,
+    ])(
+      "a chat-only Teams rule is accepted for the %s event type",
+      (eventType: NotificationRuleEventType) => {
+        const rule: IncidentNotificationRule = makeRule({
+          shouldCreateNewChannel: false,
+          shouldPostToExistingChannel: false,
+          shouldPostToExistingChat: true,
+          existingChatIds: ["c1"],
+        });
+        expect(validateTeams(rule, eventType)).toBeNull();
+      },
+    );
+
+    test.each([
+      NotificationRuleEventType.Incident,
+      NotificationRuleEventType.Alert,
+      NotificationRuleEventType.AlertEpisode,
+      NotificationRuleEventType.IncidentEpisode,
+      NotificationRuleEventType.ScheduledMaintenance,
+    ])(
+      "a Teams rule with no destination at all is rejected for the %s event type",
+      (eventType: NotificationRuleEventType) => {
+        const rule: IncidentNotificationRule = makeRule({
+          shouldCreateNewChannel: false,
+          shouldPostToExistingChannel: false,
+          shouldPostToExistingChat: false,
+        });
+        expect(validateTeams(rule, eventType)).toBe(teamsChatEitherOrError);
+      },
+    );
+  });
+
   describe("hasValueField", () => {
     test.each([
       ConditionType.IsEmpty,

package/Tests/UI/Components/BulkUpdateForm.test.tsx

@@ -0,0 +1,174 @@
+import { describe, expect, test } from "@jest/globals";
+import { fireEvent, render, RenderResult } from "@testing-library/react";
+import * as React from "react";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import BulkUpdateForm, {
+  BulkActionButtonSchema,
+  ComponentProps,
+} from "../../../UI/Components/BulkUpdate/BulkUpdateForm";
+import { ButtonStyleType } from "../../../UI/Components/Button/Button";
+import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
+
+/*
+ * react-i18next is not initialized in the test environment. Mock the hook so
+ * translate helpers echo their input and the component renders synchronously.
+ */
+jest.mock("react-i18next", () => {
+  return {
+    useTranslation: () => {
+      return {
+        t: (key: string, opts?: { defaultValue?: string }): string => {
+          return opts?.defaultValue ?? key;
+        },
+      };
+    },
+  };
+});
+
+interface Row {
+  _id?: string | undefined;
+  name?: string | undefined;
+}
+
+type MakeRowsFunction = (count: number) => Array<Row>;
+
+const makeRows: MakeRowsFunction = (count: number): Array<Row> => {
+  const rows: Array<Row> = [];
+
+  for (let i: number = 0; i < count; i++) {
+    rows.push({ _id: `id-${i}`, name: `Row ${i}` });
+  }
+
+  return rows;
+};
+
+const BUTTONS: Array<BulkActionButtonSchema<Row>> = [
+  {
+    title: "Archive",
+    buttonStyleType: ButtonStyleType.NORMAL,
+    onClick: (): Promise<void> => {
+      return Promise.resolve();
+    },
+  },
+];
+
+type RenderFormFunction = (
+  overrides: Partial<ComponentProps<Row>>,
+) => RenderResult;
+
+const renderForm: RenderFormFunction = (
+  overrides: Partial<ComponentProps<Row>>,
+): RenderResult => {
+  const props: ComponentProps<Row> = {
+    selectedItems: makeRows(3),
+    isAllItemsSelected: false,
+    onSelectAllClick: () => {},
+    onClearSelectionClick: () => {},
+    singularLabel: "Label",
+    pluralLabel: "Labels",
+    buttons: BUTTONS,
+    ...overrides,
+  };
+
+  return render(<BulkUpdateForm<Row> {...props} />);
+};
+
+describe("BulkUpdateForm", () => {
+  test("renders nothing when nothing is selected", () => {
+    const { container } = renderForm({ selectedItems: [] });
+
+    expect(container.innerHTML).toBe("");
+  });
+
+  test("offers Select All while only part of the table is selected", () => {
+    const { getByText } = renderForm({ isAllItemsSelected: false });
+
+    expect(getByText("3 Labels Selected")).toBeTruthy();
+    expect(getByText("Select All Labels")).toBeTruthy();
+  });
+
+  test("hides Select All once everything really is selected", () => {
+    const { queryByText } = renderForm({ isAllItemsSelected: true });
+
+    expect(queryByText("Select All Labels")).toBeNull();
+  });
+
+  test("blocks a second Select All while the first is still loading", () => {
+    const onSelectAllClick: MockFunction = getJestMockFunction();
+
+    const { getByText } = renderForm({
+      isSelectingAllItems: true,
+      onSelectAllClick: onSelectAllClick as unknown as () => void,
+    });
+
+    const button: HTMLElement = getByText("Selecting All Labels...");
+
+    fireEvent.click(button);
+
+    /*
+     * Selecting everything is a paged, multi-request fetch. Letting it be
+     * re-entrant would interleave two runs over the same selection.
+     */
+    expect(onSelectAllClick).not.toHaveBeenCalled();
+  });
+
+  test("surfaces a failed select-all next to the button that triggered it", () => {
+    const { getByText } = renderForm({
+      errorMessage: "Network request failed",
+    });
+
+    expect(getByText("Network request failed")).toBeTruthy();
+    // The selection the user already had is still reported.
+    expect(getByText("3 Labels Selected")).toBeTruthy();
+  });
+
+  test("shows no error when the select-all succeeded", () => {
+    const { queryByText } = renderForm({ errorMessage: undefined });
+
+    expect(queryByText(/failed/)).toBeNull();
+  });
+
+  test("names real numbers when the selection was truncated", () => {
+    const { getByText } = renderForm({
+      selectedItems: makeRows(5),
+      isAllItemsSelected: true,
+      isSelectionTruncated: true,
+      totalMatchingItemsCount: 24318,
+    });
+
+    expect(
+      getByText(
+        new RegExp(`Selected 5 of ${(24318).toLocaleString()} matching Labels`),
+      ),
+    ).toBeTruthy();
+  });
+
+  test("stays quiet when a full selection happens to sit on the ceiling", () => {
+    /*
+     * The warning used to be inferred from
+     * `selectedItems.length === LIMIT_PER_PROJECT`, so a project holding
+     * exactly the ceiling was told its selection had been cut short when
+     * nothing had been dropped at all.
+     */
+    const { queryByText } = renderForm({
+      selectedItems: makeRows(LIMIT_PER_PROJECT),
+      isAllItemsSelected: true,
+      isSelectionTruncated: false,
+      totalMatchingItemsCount: LIMIT_PER_PROJECT,
+    });
+
+    expect(queryByText(/matching Labels/)).toBeNull();
+  });
+
+  test("clearing the selection calls back", () => {
+    const onClearSelectionClick: MockFunction = getJestMockFunction();
+
+    const { getByText } = renderForm({
+      onClearSelectionClick: onClearSelectionClick as unknown as () => void,
+    });
+
+    fireEvent.click(getByText("Clear Selection"));
+
+    expect(onClearSelectionClick).toHaveBeenCalledTimes(1);
+  });
+});