@oneuptime/common 12.0.22 → 12.0.24

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

@@ -0,0 +1,346 @@
+import { describe, expect, test } from "@jest/globals";
+import SecurityEvent from "../../../Models/AnalyticsModels/SecurityEvent";
+import ObjectID from "../../../Types/ObjectID";
+import OcsfSeverity from "../../../Types/SecurityEvent/OcsfSeverity";
+import {
+  CENTER_NODE_ID,
+  CLASS_NODE_PREFIX,
+  CorrelationGraphData,
+  CorrelationGraphEdge,
+  CorrelationGraphNode,
+  OBSERVABLE_NODE_PREFIX,
+  buildCorrelationGraph,
+  dedupeSecurityEvents,
+  severityRank,
+} from "../../../../App/FeatureSet/Dashboard/src/Utils/CorrelationGraph";
+
+/*
+ * The correlate graph builder aggregates fetched events into the
+ * center/class/observable neighborhood: event counts per class, worst
+ * severity per class (for node tinting), co-observable counting with
+ * per-event dedupe, exclusion of the searched values, the top-N cap with
+ * honest drop accounting, and the union-dedupe used when OR mode runs one
+ * query per condition. All pinned here as pure data — no React, no
+ * ReactFlow.
+ */
+
+interface EventInput {
+  id?: string;
+  eventUid?: string;
+  className?: string;
+  severityName?: OcsfSeverity;
+  observables?: Array<string>;
+  time?: Date;
+}
+
+function buildEvent(input: EventInput): SecurityEvent {
+  const event: SecurityEvent = new SecurityEvent();
+  if (input.id) {
+    event._id = new ObjectID(input.id);
+  }
+  if (input.eventUid) {
+    event.eventUid = input.eventUid;
+  }
+  if (input.className) {
+    event.className = input.className;
+  }
+  if (input.severityName) {
+    event.severityName = input.severityName;
+  }
+  event.observables = input.observables || [];
+  if (input.time) {
+    event.time = input.time;
+  }
+  return event;
+}
+
+function nodeById(
+  graph: CorrelationGraphData,
+  id: string,
+): CorrelationGraphNode | undefined {
+  return graph.nodes.find((node: CorrelationGraphNode) => {
+    return node.id === id;
+  });
+}
+
+function edgeById(
+  graph: CorrelationGraphData,
+  id: string,
+): CorrelationGraphEdge | undefined {
+  return graph.edges.find((edge: CorrelationGraphEdge) => {
+    return edge.id === id;
+  });
+}
+
+describe("severityRank", () => {
+  test("orders real severities and puts Unknown/Other/blank at the bottom", () => {
+    expect(severityRank(OcsfSeverity.Fatal)).toBeGreaterThan(
+      severityRank(OcsfSeverity.Critical),
+    );
+    expect(severityRank(OcsfSeverity.Critical)).toBeGreaterThan(
+      severityRank(OcsfSeverity.High),
+    );
+    expect(severityRank(OcsfSeverity.High)).toBeGreaterThan(
+      severityRank(OcsfSeverity.Medium),
+    );
+    expect(severityRank(OcsfSeverity.Medium)).toBeGreaterThan(
+      severityRank(OcsfSeverity.Low),
+    );
+    expect(severityRank(OcsfSeverity.Low)).toBeGreaterThan(
+      severityRank(OcsfSeverity.Informational),
+    );
+    expect(severityRank(OcsfSeverity.Unknown)).toBe(0);
+    expect(severityRank(OcsfSeverity.Other)).toBe(0);
+    expect(severityRank(undefined)).toBe(0);
+    expect(severityRank("")).toBe(0);
+  });
+});
+
+describe("buildCorrelationGraph", () => {
+  test("no events → empty graph", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [],
+      centerLabel: 'Observable is "x"',
+      excludedObservables: ["x"],
+    });
+    expect(graph.nodes).toHaveLength(0);
+    expect(graph.edges).toHaveLength(0);
+    expect(graph.droppedCoObservableCount).toBe(0);
+  });
+
+  test("one node per class with event counts on the center edges", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [
+        buildEvent({ className: "Authentication", observables: ["host-1"] }),
+        buildEvent({ className: "Authentication", observables: ["host-1"] }),
+        buildEvent({ className: "Process Activity", observables: ["host-1"] }),
+        buildEvent({ observables: ["host-1"] }), // no class → Unclassified
+      ],
+      centerLabel: "center-label",
+      excludedObservables: ["host-1"],
+    });
+
+    const center: CorrelationGraphNode | undefined = nodeById(
+      graph,
+      CENTER_NODE_ID,
+    );
+    expect(center).toBeTruthy();
+    expect(center?.label).toBe("center-label");
+    expect(center?.kind).toBe("center");
+
+    const authClass: CorrelationGraphNode | undefined = nodeById(
+      graph,
+      `${CLASS_NODE_PREFIX}Authentication`,
+    );
+    expect(authClass?.count).toBe(2);
+    expect(
+      edgeById(graph, `${CENTER_NODE_ID}->${CLASS_NODE_PREFIX}Authentication`)
+        ?.count,
+    ).toBe(2);
+
+    expect(nodeById(graph, `${CLASS_NODE_PREFIX}Unclassified`)?.count).toBe(1);
+    expect(nodeById(graph, `${CLASS_NODE_PREFIX}Process Activity`)?.count).toBe(
+      1,
+    );
+
+    // Excluded observable never becomes a node.
+    expect(nodeById(graph, `${OBSERVABLE_NODE_PREFIX}host-1`)).toBeUndefined();
+  });
+
+  test("class nodes carry the WORST severity among their events", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [
+        buildEvent({
+          className: "Authentication",
+          severityName: OcsfSeverity.Low,
+        }),
+        buildEvent({
+          className: "Authentication",
+          severityName: OcsfSeverity.Critical,
+        }),
+        buildEvent({
+          className: "Authentication",
+          severityName: OcsfSeverity.Medium,
+        }),
+        buildEvent({
+          className: "Compliance Finding",
+          severityName: OcsfSeverity.Unknown,
+        }),
+      ],
+      centerLabel: "c",
+      excludedObservables: [],
+    });
+
+    expect(
+      nodeById(graph, `${CLASS_NODE_PREFIX}Authentication`)?.worstSeverity,
+    ).toBe(OcsfSeverity.Critical);
+    /*
+     * Unknown ranks zero — the node gets NO severity rather than
+     * pretending "Unknown" is a color-worthy signal.
+     */
+    expect(
+      nodeById(graph, `${CLASS_NODE_PREFIX}Compliance Finding`)?.worstSeverity,
+    ).toBeUndefined();
+  });
+
+  test("co-observables count once per event even when repeated in one row", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [
+        buildEvent({
+          className: "Authentication",
+          observables: ["searched", "alice", "alice", "alice"],
+        }),
+        buildEvent({
+          className: "Authentication",
+          observables: ["searched", "alice"],
+        }),
+      ],
+      centerLabel: "c",
+      excludedObservables: ["searched"],
+    });
+
+    expect(
+      edgeById(
+        graph,
+        `${CLASS_NODE_PREFIX}Authentication->${OBSERVABLE_NODE_PREFIX}alice`,
+      )?.count,
+    ).toBe(2);
+  });
+
+  test("empty observable strings are ignored", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [
+        buildEvent({ className: "Authentication", observables: ["", "alice"] }),
+      ],
+      centerLabel: "c",
+      excludedObservables: [],
+    });
+    expect(nodeById(graph, `${OBSERVABLE_NODE_PREFIX}alice`)).toBeTruthy();
+    expect(nodeById(graph, `${OBSERVABLE_NODE_PREFIX}`)).toBeUndefined();
+  });
+
+  test("an observable shared by two classes gets ONE node and two edges", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [
+        buildEvent({ className: "Authentication", observables: ["alice"] }),
+        buildEvent({ className: "Process Activity", observables: ["alice"] }),
+      ],
+      centerLabel: "c",
+      excludedObservables: [],
+    });
+
+    const observableNodes: Array<CorrelationGraphNode> = graph.nodes.filter(
+      (node: CorrelationGraphNode) => {
+        return node.kind === "observable";
+      },
+    );
+    expect(observableNodes).toHaveLength(1);
+    expect(
+      edgeById(
+        graph,
+        `${CLASS_NODE_PREFIX}Authentication->${OBSERVABLE_NODE_PREFIX}alice`,
+      ),
+    ).toBeTruthy();
+    expect(
+      edgeById(
+        graph,
+        `${CLASS_NODE_PREFIX}Process Activity->${OBSERVABLE_NODE_PREFIX}alice`,
+      ),
+    ).toBeTruthy();
+  });
+
+  test("caps co-observables at the most frequent N and reports the drop count", () => {
+    const events: Array<SecurityEvent> = [];
+    // "popular" appears in 3 events, every "rare-N" in exactly one.
+    for (let eventIndex: number = 0; eventIndex < 3; eventIndex++) {
+      events.push(
+        buildEvent({
+          className: "Authentication",
+          observables: ["popular", `rare-${eventIndex}`],
+        }),
+      );
+    }
+    events.push(
+      buildEvent({ className: "Authentication", observables: ["rare-3"] }),
+    );
+
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: events,
+      centerLabel: "c",
+      excludedObservables: [],
+      maxCoObservables: 2,
+    });
+
+    const observableNodes: Array<CorrelationGraphNode> = graph.nodes.filter(
+      (node: CorrelationGraphNode) => {
+        return node.kind === "observable";
+      },
+    );
+    expect(observableNodes).toHaveLength(2);
+    // Highest count first, then alphabetical among the tied rares.
+    expect(nodeById(graph, `${OBSERVABLE_NODE_PREFIX}popular`)).toBeTruthy();
+    expect(nodeById(graph, `${OBSERVABLE_NODE_PREFIX}rare-0`)).toBeTruthy();
+    expect(graph.droppedCoObservableCount).toBe(3);
+  });
+
+  test("cap exactly met → nothing reported dropped", () => {
+    const graph: CorrelationGraphData = buildCorrelationGraph({
+      events: [
+        buildEvent({ className: "Authentication", observables: ["a", "b"] }),
+      ],
+      centerLabel: "c",
+      excludedObservables: [],
+      maxCoObservables: 2,
+    });
+    expect(graph.droppedCoObservableCount).toBe(0);
+  });
+});
+
+describe("dedupeSecurityEvents", () => {
+  test("unions result sets by row id", () => {
+    const shared: SecurityEvent = buildEvent({
+      id: "11111111-1111-4111-8111-111111111111",
+      className: "Authentication",
+    });
+    const onlyFirst: SecurityEvent = buildEvent({
+      id: "22222222-2222-4222-8222-222222222222",
+    });
+    const onlySecond: SecurityEvent = buildEvent({
+      id: "33333333-3333-4333-8333-333333333333",
+    });
+
+    const deduped: Array<SecurityEvent> = dedupeSecurityEvents([
+      [onlyFirst, shared],
+      [shared, onlySecond],
+    ]);
+
+    expect(deduped).toHaveLength(3);
+    expect(deduped[0]).toBe(onlyFirst);
+    expect(deduped[1]).toBe(shared);
+    expect(deduped[2]).toBe(onlySecond);
+  });
+
+  test("two model instances with the SAME id count once", () => {
+    const first: SecurityEvent = buildEvent({
+      id: "11111111-1111-4111-8111-111111111111",
+    });
+    const second: SecurityEvent = buildEvent({
+      id: "11111111-1111-4111-8111-111111111111",
+    });
+    expect(dedupeSecurityEvents([[first], [second]])).toHaveLength(1);
+  });
+
+  test("falls back to eventUid + time when _id was not selected", () => {
+    const time: Date = new Date("2026-08-25T10:00:00.000Z");
+    const first: SecurityEvent = buildEvent({ eventUid: "uid-1", time });
+    const duplicate: SecurityEvent = buildEvent({ eventUid: "uid-1", time });
+    const differentTime: SecurityEvent = buildEvent({
+      eventUid: "uid-1",
+      time: new Date("2026-08-25T11:00:00.000Z"),
+    });
+
+    expect(
+      dedupeSecurityEvents([[first], [duplicate], [differentTime]]),
+    ).toHaveLength(2);
+  });
+});

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

@@ -0,0 +1,256 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import * as React from "react";
+import { describe, expect, test } from "@jest/globals";
+import CriteriaFilterElement from "../../../../App/FeatureSet/Dashboard/src/Components/Form/Monitor/CriteriaFilter";
+import CriteriaFiltersElement from "../../../../App/FeatureSet/Dashboard/src/Components/Form/Monitor/CriteriaFilters";
+import {
+  CheckOn,
+  CriteriaFilter,
+  FilterType,
+} from "../../../Types/Monitor/CriteriaFilter";
+import MonitorCriteriaInstance from "../../../Types/Monitor/MonitorCriteriaInstance";
+import MonitorStep from "../../../Types/Monitor/MonitorStep";
+import MonitorType from "../../../Types/Monitor/MonitorType";
+import ObjectID from "../../../Types/ObjectID";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * #3412 as the user met it: the "Filter Condition" dropdown on the
+ * "External Status Page Active Incidents" filter showed an empty "Select...",
+ * while the sibling filter's condition read "True" and this filter's own
+ * value box already showed 0.
+ *
+ * The option-list tests in ExternalStatusPageCriteriaFilter.test.ts and
+ * CriteriaFilterDefaults.test.ts pin the data the dropdown is built from.
+ * This file drives the real component instead, because "Select..." is
+ * something react-select decides to render when it cannot find an option
+ * matching the value it was handed — a rule about lists cannot say whether
+ * that happens on screen, only the rendered row can.
+ *
+ * Assertions stay on plain DOM text: jest-dom's matchers do not typecheck
+ * repo-wide.
+ */
+
+// react-select's placeholder, i.e. what "unset" looks like to the user.
+const UNSET: string = "Select...";
+
+function monitorStep(): MonitorStep {
+  return new MonitorStep();
+}
+
+function seededExternalStatusPageFilters(): Array<CriteriaFilter> {
+  return MonitorCriteriaInstance.getDefaultOnlineMonitorCriteriaInstance({
+    monitorType: MonitorType.ExternalStatusPage,
+    monitorStatusId: new ObjectID("aaaaaaaaaaaaaaaaaaaaaaaa"),
+    monitorName: "Acme Status",
+  })!.data!.filters;
+}
+
+function renderFilter(
+  criteriaFilter: CriteriaFilter,
+  monitorType: MonitorType,
+): {
+  onChange: MockFunction;
+} {
+  const onChange: MockFunction = getJestMockFunction();
+
+  render(
+    <CriteriaFilterElement
+      monitorType={monitorType}
+      monitorStep={monitorStep()}
+      value={criteriaFilter}
+      onChange={onChange as unknown as (value: CriteriaFilter) => void}
+    />,
+  );
+
+  return { onChange: onChange };
+}
+
+/*
+ * The last filter each onChange handed back. The component replaces the whole
+ * filter object on every edit, so the newest call is the current state.
+ */
+function lastFilterFrom(onChange: MockFunction): CriteriaFilter {
+  expect(onChange.mock.calls.length).toBeGreaterThan(0);
+
+  return onChange.mock.calls[
+    onChange.mock.calls.length - 1
+  ]![0] as CriteriaFilter;
+}
+
+// The filter list the last onChange handed back, after "Add Filter" ran.
+function lastFilterListFrom(onChange: MockFunction): Array<CriteriaFilter> {
+  expect(onChange.mock.calls.length).toBeGreaterThan(0);
+
+  return onChange.mock.calls[
+    onChange.mock.calls.length - 1
+  ]![0] as Array<CriteriaFilter>;
+}
+
+async function pickFromDropdown(input: {
+  labelledBy: string;
+  optionLabel: string;
+}): Promise<void> {
+  const user: ReturnType<typeof userEvent.setup> = userEvent.setup();
+
+  /*
+   * react-select renders its own text input per dropdown. Ordering follows
+   * the form: "Filter Type" first, then "Filter Condition".
+   */
+  const comboboxes: Array<HTMLElement> = screen.getAllByRole("combobox");
+  const index: number = input.labelledBy === "Filter Type" ? 0 : 1;
+
+  await user.click(comboboxes[index]!);
+  await user.click(await screen.findByText(input.optionLabel));
+}
+
+describe("The criteria Filter Condition dropdown", () => {
+  describe("the row reported in #3412", () => {
+    test("the seeded active-incidents filter shows its condition, not an empty Select...", () => {
+      const criteriaFilter: CriteriaFilter =
+        seededExternalStatusPageFilters()[1]!;
+
+      expect(criteriaFilter.checkOn).toBe(
+        CheckOn.ExternalStatusPageActiveIncidents,
+      );
+
+      renderFilter(criteriaFilter, MonitorType.ExternalStatusPage);
+
+      // The Filter Type dropdown, which was never the problem.
+      expect(
+        screen.getAllByText(CheckOn.ExternalStatusPageActiveIncidents).length,
+      ).toBeGreaterThan(0);
+
+      // The Filter Condition dropdown. This is what showed "Select...".
+      expect(screen.getAllByText(FilterType.EqualTo).length).toBeGreaterThan(0);
+      expect(screen.queryByText(UNSET)).toBeNull();
+    });
+
+    test("the sibling is-online filter still shows True", () => {
+      const criteriaFilter: CriteriaFilter =
+        seededExternalStatusPageFilters()[0]!;
+
+      expect(criteriaFilter.checkOn).toBe(CheckOn.ExternalStatusPageIsOnline);
+
+      renderFilter(criteriaFilter, MonitorType.ExternalStatusPage);
+
+      expect(screen.getAllByText(FilterType.True).length).toBeGreaterThan(0);
+      expect(screen.queryByText(UNSET)).toBeNull();
+    });
+
+    test("both seeded filters render with nothing left unset", () => {
+      for (const criteriaFilter of seededExternalStatusPageFilters()) {
+        const { unmount }: { unmount: () => void } = render(
+          <CriteriaFilterElement
+            monitorType={MonitorType.ExternalStatusPage}
+            monitorStep={monitorStep()}
+            value={criteriaFilter}
+            onChange={() => {}}
+          />,
+        );
+
+        expect(screen.queryByText(UNSET)).toBeNull();
+        unmount();
+      }
+    });
+  });
+
+  describe("changing the Filter Type", () => {
+    test("moves the condition to the new check's default instead of clearing it", async () => {
+      const { onChange }: { onChange: MockFunction } = renderFilter(
+        seededExternalStatusPageFilters()[0]!,
+        MonitorType.ExternalStatusPage,
+      );
+
+      await pickFromDropdown({
+        labelledBy: "Filter Type",
+        optionLabel: CheckOn.ExternalStatusPageActiveIncidents,
+      });
+
+      const emitted: CriteriaFilter = lastFilterFrom(onChange);
+
+      expect(emitted.checkOn).toBe(CheckOn.ExternalStatusPageActiveIncidents);
+      // Was undefined, which is what left the next dropdown blank.
+      expect(emitted.filterType).toBe(FilterType.EqualTo);
+    });
+
+    test("a check with exactly one condition no longer asks the user to re-pick it", async () => {
+      const { onChange }: { onChange: MockFunction } = renderFilter(
+        {
+          checkOn: CheckOn.ResponseBody,
+          filterType: FilterType.Contains,
+          value: "ok",
+        },
+        MonitorType.API,
+      );
+
+      await pickFromDropdown({
+        labelledBy: "Filter Type",
+        optionLabel: CheckOn.JavaScriptExpression,
+      });
+
+      const emitted: CriteriaFilter = lastFilterFrom(onChange);
+
+      expect(emitted.checkOn).toBe(CheckOn.JavaScriptExpression);
+      expect(emitted.filterType).toBe(FilterType.EvaluatesToTrue);
+    });
+  });
+
+  describe("adding a filter", () => {
+    test("an External Status Page monitor gets a filter it can actually render", () => {
+      const onChange: MockFunction = getJestMockFunction();
+
+      render(
+        <CriteriaFiltersElement
+          monitorType={MonitorType.ExternalStatusPage}
+          monitorStep={monitorStep()}
+          value={[seededExternalStatusPageFilters()[0]!]}
+          onChange={
+            onChange as unknown as (value: Array<CriteriaFilter>) => void
+          }
+        />,
+      );
+
+      screen.getByText("Add Filter").click();
+
+      const added: CriteriaFilter = lastFilterListFrom(onChange)[1]!;
+
+      /*
+       * Was { checkOn: IsOnline, filterType: EqualTo } — a check this monitor
+       * type does not offer, paired with a condition that check has never
+       * accepted, so both dropdowns opened blank.
+       */
+      expect(added.checkOn).toBe(CheckOn.ExternalStatusPageIsOnline);
+      expect(added.filterType).toBe(FilterType.True);
+    });
+
+    test("a website monitor keeps its up/down check and gains a condition", () => {
+      const onChange: MockFunction = getJestMockFunction();
+
+      render(
+        <CriteriaFiltersElement
+          monitorType={MonitorType.Website}
+          monitorStep={monitorStep()}
+          value={[
+            {
+              checkOn: CheckOn.IsOnline,
+              filterType: FilterType.True,
+              value: undefined,
+            },
+          ]}
+          onChange={
+            onChange as unknown as (value: Array<CriteriaFilter>) => void
+          }
+        />,
+      );
+
+      screen.getByText("Add Filter").click();
+
+      const added: CriteriaFilter = lastFilterListFrom(onChange)[1]!;
+
+      expect(added.checkOn).toBe(CheckOn.IsOnline);
+      expect(added.filterType).toBe(FilterType.True);
+    });
+  });
+});