@oneuptime/common 11.5.12 → 11.6.0

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

@@ -0,0 +1,311 @@
+import NotificationRuleCondition, {
+  ConditionType,
+  NotificationRuleConditionCheckOn,
+  NotificationRuleConditionUtil,
+} from "../../../../Types/Workspace/NotificationRules/NotificationRuleCondition";
+import NotificationRuleEventType from "../../../../Types/Workspace/NotificationRules/EventType";
+import IncidentNotificationRule from "../../../../Types/Workspace/NotificationRules/NotificationRuleTypes/IncidentNotificationRule";
+import WorkspaceType from "../../../../Types/Workspace/WorkspaceType";
+
+describe("NotificationRuleConditionUtil", () => {
+  const makeRule: (
+    overrides?: Partial<IncidentNotificationRule>,
+  ) => IncidentNotificationRule = (
+    overrides: Partial<IncidentNotificationRule> = {},
+  ): IncidentNotificationRule => {
+    return {
+      filters: [],
+      shouldCreateNewChannel: true,
+      newChannelTemplateName: "incident-{{id}}",
+      shouldPostToExistingChannel: false,
+      ...overrides,
+    } as unknown as IncidentNotificationRule;
+  };
+
+  const validate: (rule: IncidentNotificationRule) => string | null = (
+    rule: IncidentNotificationRule,
+  ): string | null => {
+    return NotificationRuleConditionUtil.getValidationError({
+      notificationRule: rule,
+      eventType: NotificationRuleEventType.Incident,
+      workspaceType: WorkspaceType.Slack,
+    });
+  };
+
+  describe("getValidationError - filters", () => {
+    test("requires checkOn on every filter", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        filters: [
+          {
+            conditionType: ConditionType.EqualTo,
+            value: "x",
+          } as unknown as NotificationRuleCondition,
+        ],
+      });
+      expect(validate(rule)).toBe("Check On is required");
+    });
+
+    test("requires a condition type", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        filters: [
+          {
+            checkOn: NotificationRuleConditionCheckOn.IncidentTitle,
+            conditionType: undefined,
+            value: "x",
+          },
+        ],
+      });
+      expect(validate(rule)).toBe(
+        `Filter Condition is required for ${NotificationRuleConditionCheckOn.IncidentTitle}`,
+      );
+    });
+
+    test("requires a value", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        filters: [
+          {
+            checkOn: NotificationRuleConditionCheckOn.IncidentTitle,
+            conditionType: ConditionType.EqualTo,
+            value: undefined,
+          },
+        ],
+      });
+      expect(validate(rule)).toBe(
+        `Value is required for ${NotificationRuleConditionCheckOn.IncidentTitle}`,
+      );
+    });
+
+    test("rejects an empty-array value", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        filters: [
+          {
+            checkOn: NotificationRuleConditionCheckOn.IncidentLabels,
+            conditionType: ConditionType.ContainsAny,
+            value: [],
+          },
+        ],
+      });
+      expect(validate(rule)).toBe(
+        `Value is required for ${NotificationRuleConditionCheckOn.IncidentLabels}`,
+      );
+    });
+  });
+
+  describe("getValidationError - channel selection", () => {
+    test("requires either create-new or post-to-existing channel", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+      });
+      expect(validate(rule)).toBe(
+        "Please select either create slack channel or post to existing Slack channel",
+      );
+    });
+
+    test("requires an existing channel name when posting to an existing channel", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: true,
+        existingChannelNames: "   ",
+      });
+      expect(validate(rule)).toBe("Existing Slack channel name is required");
+    });
+
+    test("requires a new channel name when creating a channel", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: true,
+        newChannelTemplateName: "  ",
+      });
+      expect(validate(rule)).toBe("New Slack channel name is required");
+    });
+
+    test("returns null for a fully valid rule", () => {
+      expect(validate(makeRule())).toBeNull();
+    });
+
+    test("skips channel validation for event types that do not post to channels", () => {
+      const rule: IncidentNotificationRule = makeRule({
+        shouldCreateNewChannel: false,
+        shouldPostToExistingChannel: false,
+      });
+      // Monitor events are not in the channel-required set.
+      expect(
+        NotificationRuleConditionUtil.getValidationError({
+          notificationRule: rule,
+          eventType: NotificationRuleEventType.Monitor,
+          workspaceType: WorkspaceType.Slack,
+        }),
+      ).toBeNull();
+    });
+  });
+
+  describe("hasValueField", () => {
+    test.each([
+      ConditionType.IsEmpty,
+      ConditionType.IsNotEmpty,
+      ConditionType.True,
+      ConditionType.False,
+    ])(
+      "returns false for the valueless condition %s",
+      (conditionType: ConditionType) => {
+        expect(
+          NotificationRuleConditionUtil.hasValueField({
+            checkOn: NotificationRuleConditionCheckOn.IncidentTitle,
+            conditionType,
+          }),
+        ).toBe(false);
+      },
+    );
+
+    test.each([ConditionType.EqualTo, ConditionType.Contains])(
+      "returns true for the value-based condition %s",
+      (conditionType: ConditionType) => {
+        expect(
+          NotificationRuleConditionUtil.hasValueField({
+            checkOn: NotificationRuleConditionCheckOn.IncidentTitle,
+            conditionType,
+          }),
+        ).toBe(true);
+      },
+    );
+  });
+
+  describe("isDropdownValueField", () => {
+    test("returns false when checkOn or conditionType is missing", () => {
+      expect(
+        NotificationRuleConditionUtil.isDropdownValueField({
+          checkOn: undefined,
+          conditionType: ConditionType.ContainsAny,
+        }),
+      ).toBe(false);
+      expect(
+        NotificationRuleConditionUtil.isDropdownValueField({
+          checkOn: NotificationRuleConditionCheckOn.IncidentState,
+          conditionType: undefined,
+        }),
+      ).toBe(false);
+    });
+
+    test.each([
+      NotificationRuleConditionCheckOn.IncidentState,
+      NotificationRuleConditionCheckOn.IncidentSeverity,
+      NotificationRuleConditionCheckOn.MonitorLabels,
+      NotificationRuleConditionCheckOn.Monitors,
+    ])(
+      "returns true for the dropdown checkOn %s",
+      (checkOn: NotificationRuleConditionCheckOn) => {
+        expect(
+          NotificationRuleConditionUtil.isDropdownValueField({
+            checkOn,
+            conditionType: ConditionType.ContainsAny,
+          }),
+        ).toBe(true);
+      },
+    );
+
+    test.each([
+      NotificationRuleConditionCheckOn.IncidentTitle,
+      NotificationRuleConditionCheckOn.IncidentDescription,
+    ])(
+      "returns false for the free-text checkOn %s",
+      (checkOn: NotificationRuleConditionCheckOn) => {
+        expect(
+          NotificationRuleConditionUtil.isDropdownValueField({
+            checkOn,
+            conditionType: ConditionType.EqualTo,
+          }),
+        ).toBe(false);
+      },
+    );
+  });
+
+  describe("getCheckOnByEventType", () => {
+    test("returns incident checkOns for the Incident event", () => {
+      const checkOns: Array<NotificationRuleConditionCheckOn> =
+        NotificationRuleConditionUtil.getCheckOnByEventType(
+          NotificationRuleEventType.Incident,
+        );
+      expect(checkOns).toContain(
+        NotificationRuleConditionCheckOn.IncidentTitle,
+      );
+      expect(checkOns).toContain(NotificationRuleConditionCheckOn.Monitors);
+      expect(checkOns).not.toContain(
+        NotificationRuleConditionCheckOn.AlertTitle,
+      );
+    });
+
+    test("returns monitor checkOns for the Monitor event", () => {
+      const checkOns: Array<NotificationRuleConditionCheckOn> =
+        NotificationRuleConditionUtil.getCheckOnByEventType(
+          NotificationRuleEventType.Monitor,
+        );
+      expect(checkOns).toContain(NotificationRuleConditionCheckOn.MonitorName);
+      expect(checkOns).toContain(
+        NotificationRuleConditionCheckOn.MonitorStatus,
+      );
+    });
+
+    test("returns an empty list for an unhandled event type", () => {
+      expect(
+        NotificationRuleConditionUtil.getCheckOnByEventType(
+          NotificationRuleEventType.OnCallDutyPolicy,
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("getConditionTypeByCheckOn", () => {
+    test("free-text fields offer the string comparison operators", () => {
+      const types: Array<ConditionType> =
+        NotificationRuleConditionUtil.getConditionTypeByCheckOn(
+          NotificationRuleConditionCheckOn.IncidentTitle,
+        );
+      expect(types).toContain(ConditionType.EqualTo);
+      expect(types).toContain(ConditionType.Contains);
+      expect(types).toContain(ConditionType.StartsWith);
+      expect(types).not.toContain(ConditionType.ContainsAll);
+    });
+
+    test("state/severity fields offer ContainsAny / NotContains", () => {
+      expect(
+        NotificationRuleConditionUtil.getConditionTypeByCheckOn(
+          NotificationRuleConditionCheckOn.IncidentState,
+        ),
+      ).toEqual([ConditionType.ContainsAny, ConditionType.NotContains]);
+    });
+
+    test("label fields additionally offer ContainsAll", () => {
+      const types: Array<ConditionType> =
+        NotificationRuleConditionUtil.getConditionTypeByCheckOn(
+          NotificationRuleConditionCheckOn.IncidentLabels,
+        );
+      expect(types).toContain(ConditionType.ContainsAll);
+    });
+
+    test("returns an empty list for an unhandled checkOn", () => {
+      expect(
+        NotificationRuleConditionUtil.getConditionTypeByCheckOn(
+          "Unhandled" as NotificationRuleConditionCheckOn,
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("getDropdownOptionsByCheckOn", () => {
+    test("returns an empty list when the backing collections are empty", () => {
+      expect(
+        NotificationRuleConditionUtil.getDropdownOptionsByCheckOn({
+          alertSeverities: [],
+          alertStates: [],
+          incidentSeverities: [],
+          monitorStatus: [],
+          incidentStates: [],
+          scheduledMaintenanceStates: [],
+          labels: [],
+          monitors: [],
+          checkOn: NotificationRuleConditionCheckOn.IncidentSeverity,
+        }),
+      ).toEqual([]);
+    });
+  });
+});

package/Tests/UI/Components/ModelTableSelectFromColumns.test.ts

@@ -0,0 +1,259 @@
+import Columns from "../../../UI/Components/ModelTable/Columns";
+import {
+  getRelationSelectFromColumns,
+  getSelectFromColumns,
+} from "../../../UI/Components/ModelTable/SelectFromColumns";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import Alert from "../../../Models/DatabaseModels/Alert";
+import ProxmoxCluster from "../../../Models/DatabaseModels/ProxmoxCluster";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { describe, expect, test } from "@jest/globals";
+
+describe("ModelTable SelectFromColumns", () => {
+  describe("getSelectFromColumns", () => {
+    test("it selects every field a column declares, not just the first", () => {
+      /*
+       * Regression for OneUptime/oneuptime#2756: the Proxmox clusters list
+       * rendered "0/3 online" for a fully online cluster because only the
+       * first key of the column's field map was selected, leaving
+       * onlineNodeCount undefined on every row.
+       */
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBe(true);
+    });
+
+    test("it always selects _id", () => {
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: [],
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["_id"]).toBe(true);
+    });
+
+    test("it merges fields across multiple columns", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { name: true },
+          title: "Name",
+          type: FieldType.Text,
+        },
+        {
+          field: { guestCount: true, storageCount: true },
+          title: "Inventory",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["name"]).toBe(true);
+      expect(select["guestCount"]).toBe(true);
+      expect(select["storageCount"]).toBe(true);
+    });
+
+    test("it skips columns that declare no field", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: undefined as never,
+          title: "Actions",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(Object.keys(select)).toEqual(["_id"]);
+    });
+
+    test("it throws when the primary field is not a column on the model", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { notARealColumn: true } as never,
+          title: "Nope",
+          type: FieldType.Text,
+        },
+      ];
+
+      expect(() => {
+        return getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        });
+      }).toThrow(BadDataException);
+    });
+
+    test("it ignores a non-column secondary field rather than blanking the page", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { nodeCount: true, notARealColumn: true } as never,
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const consoleError: jest.SpyInstance = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["notARealColumn"]).toBeUndefined();
+      // It must not drop the field silently — that is how #2756 hid.
+      expect(consoleError).toHaveBeenCalled();
+
+      consoleError.mockRestore();
+    });
+
+    test("it drops a secondary field the user cannot read, so the API does not reject the whole request", () => {
+      /*
+       * checkSelectPermission throws NotAuthorizedException for the entire
+       * request when the select names an unreadable column, so widening the
+       * select must never add one.
+       */
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+          hasPermissionToReadField: (field: string): boolean => {
+            return field !== "onlineNodeCount";
+          },
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBeUndefined();
+    });
+
+    test("it keeps the primary field even when the permission callback rejects it, preserving prior behaviour", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: { nodeCount: true, onlineNodeCount: true },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const select: Record<string, unknown> =
+        getSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+          hasPermissionToReadField: (): boolean => {
+            return false;
+          },
+        }) as Record<string, unknown>;
+
+      expect(select["nodeCount"]).toBe(true);
+      expect(select["onlineNodeCount"]).toBeUndefined();
+    });
+  });
+
+  describe("getRelationSelectFromColumns", () => {
+    test("it selects every relation a column declares, not just the first", () => {
+      const columns: Columns<Alert> = [
+        {
+          field: {
+            monitor: { name: true, _id: true },
+            labels: { name: true, color: true },
+          },
+          title: "Resource",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<Alert>({
+          columns: columns,
+          model: new Alert(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect["monitor"]).toEqual({ name: true, _id: true });
+      expect(relationSelect["labels"]).toEqual({ name: true, color: true });
+    });
+
+    test("it leaves non-entity fields out of the relation select", () => {
+      const columns: Columns<ProxmoxCluster> = [
+        {
+          field: {
+            nodeCount: true,
+            onlineNodeCount: true,
+          },
+          title: "Nodes",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<ProxmoxCluster>({
+          columns: columns,
+          model: new ProxmoxCluster(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect).toEqual({});
+    });
+
+    test("it merges the same relation declared by two columns", () => {
+      const columns: Columns<Alert> = [
+        {
+          field: { monitor: { name: true } },
+          title: "Monitor",
+          type: FieldType.Element,
+        },
+        {
+          field: { monitor: { _id: true } },
+          title: "Monitor Id",
+          type: FieldType.Element,
+        },
+      ];
+
+      const relationSelect: Record<string, unknown> =
+        getRelationSelectFromColumns<Alert>({
+          columns: columns,
+          model: new Alert(),
+        }) as Record<string, unknown>;
+
+      expect(relationSelect["monitor"]).toEqual({ name: true, _id: true });
+    });
+  });
+});