@oneuptime/common 11.7.1 → 11.7.2

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);
+  });
+});