@oneuptime/common 11.4.0 → 11.5.0

package/Tests/Server/Utils/Monitor/Criteria/SnmpMonitorCriteria.test.ts

@@ -207,6 +207,65 @@ describe("SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet", () => {
       expect(result).toBeTruthy();
       expect(result).toContain("equal to OK");
     });
+
+    test("empty OctetString is NOT coerced to numeric 0 for an 'equal to 0' filter", async () => {
+      /*
+       * Regression: Number("") === 0, so an empty value used to spuriously
+       * satisfy a numeric "== 0" criterion. It must fall through to a string
+       * comparison ("" !== "0") and not match.
+       */
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpOidValue,
+        filterType: FilterType.EqualTo,
+        value: "0",
+        snmpMonitorOptions: { oid: PSU_OID },
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [
+          {
+            oid: PSU_OID,
+            value: "",
+            type: SnmpDataType.OctetString,
+          },
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
+
+    test("whitespace-only OctetString is NOT coerced to numeric 0", async () => {
+      const criteriaFilter: CriteriaFilter = {
+        checkOn: CheckOn.SnmpOidValue,
+        filterType: FilterType.EqualTo,
+        value: "0",
+        snmpMonitorOptions: { oid: PSU_OID },
+      };
+
+      const dataToProcess: ProbeMonitorResponse = buildDataToProcess({
+        oidResponses: [
+          {
+            oid: PSU_OID,
+            value: "   ",
+            type: SnmpDataType.OctetString,
+          },
+        ],
+      });
+
+      const result: string | null =
+        await SnmpMonitorCriteria.isMonitorInstanceCriteriaFilterMet({
+          dataToProcess,
+          criteriaFilter,
+        });
+
+      expect(result).toBeNull();
+    });
   });
 
   describe("SnmpOidValue guards", () => {

package/Tests/Server/Utils/Monitor/IoTDeviceAbsenceSeries.test.ts

@@ -0,0 +1,113 @@
+import {
+  IOT_DEVICE_ID_ATTRIBUTE_KEY,
+  buildAbsentIoTDeviceSeries,
+  getIoTDeviceAbsenceGroupByKey,
+} from "../../../../Server/Utils/Monitor/IoTDeviceAbsenceSeries";
+import MetricSeriesResult from "../../../../Types/Monitor/MetricMonitor/MetricSeriesResult";
+import MetricSeriesFingerprint from "../../../../Utils/Metrics/MetricSeriesFingerprint";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The absence-series helpers are what turn a silent registered device
+ * into a per-device offline incident — pin down the gating and the
+ * synthetic-series shape (which must match what the device's real
+ * series would carry so incidents dedupe and auto-resolve).
+ */
+
+function presentSeries(deviceIds: Array<string>): Array<MetricSeriesResult> {
+  return deviceIds.map((id: string) => {
+    return {
+      fingerprint: MetricSeriesFingerprint.computeFingerprint({
+        [IOT_DEVICE_ID_ATTRIBUTE_KEY]: id,
+      }),
+      labels: { [IOT_DEVICE_ID_ATTRIBUTE_KEY]: id },
+      // present series carry samples; the builder only reads labels.
+      aggregatedResults: [],
+    };
+  });
+}
+
+describe("getIoTDeviceAbsenceGroupByKey", () => {
+  test("returns the key only for a pure device.id group-by", () => {
+    expect(getIoTDeviceAbsenceGroupByKey(["device.id"])).toBe("device.id");
+  });
+
+  test.each([
+    [[]],
+    [["iot.device.type"]],
+    [["device.id", "iot.device.type"]],
+    [["resource.iot.fleet.name"]],
+  ])("returns null for %j", (keys: Array<string>) => {
+    expect(getIoTDeviceAbsenceGroupByKey(keys)).toBeNull();
+  });
+});
+
+describe("buildAbsentIoTDeviceSeries", () => {
+  test("emits one empty series per registered-but-absent device", () => {
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: presentSeries(["sensor-1"]),
+      expectedDeviceExternalIds: ["sensor-1", "sensor-2", "sensor-3"],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 2,
+    });
+
+    expect(absent).toHaveLength(2);
+    const ids: Array<string> = absent.map((s: MetricSeriesResult) => {
+      return String(s.labels["device.id"]);
+    });
+    expect(ids.sort()).toEqual(["sensor-2", "sensor-3"]);
+
+    for (const series of absent) {
+      // One empty slot per query+formula so criteria alias resolution lines up.
+      expect(series.aggregatedResults).toHaveLength(2);
+      for (const slot of series.aggregatedResults) {
+        expect(slot.data).toEqual([]);
+      }
+      // Fingerprint must match what the device's REAL series would carry.
+      expect(series.fingerprint).toBe(
+        MetricSeriesFingerprint.computeFingerprint(series.labels),
+      );
+    }
+  });
+
+  test("device ids are compared byte-exact — no canonicalization", () => {
+    /*
+     * device.id labels are stored verbatim (unlike host.name). A
+     * registered id differing only in case is a DIFFERENT device and
+     * must be treated as absent; lowercasing would fork the
+     * fingerprint from the real series and break dedupe.
+     */
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: presentSeries(["Sensor-A"]),
+      expectedDeviceExternalIds: ["Sensor-A", "sensor-a"],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 1,
+    });
+
+    expect(absent).toHaveLength(1);
+    expect(absent[0]?.labels["device.id"]).toBe("sensor-a");
+  });
+
+  test("dedupes duplicate registered ids and skips empties", () => {
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: [],
+      expectedDeviceExternalIds: ["sensor-1", "sensor-1", ""],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 0, // clamps to 1
+    });
+
+    expect(absent).toHaveLength(1);
+    expect(absent[0]?.aggregatedResults).toHaveLength(1);
+  });
+
+  test("returns nothing when every registered device is present", () => {
+    const absent: Array<MetricSeriesResult> = buildAbsentIoTDeviceSeries({
+      presentSeries: presentSeries(["a", "b"]),
+      expectedDeviceExternalIds: ["a", "b"],
+      deviceKey: IOT_DEVICE_ID_ATTRIBUTE_KEY,
+      slotCount: 1,
+    });
+
+    expect(absent).toHaveLength(0);
+  });
+});

package/Tests/Server/Utils/Monitor/PerSeriesRecoveryResolution.test.ts

@@ -0,0 +1,198 @@
+import MonitorIncident from "../../../../Server/Utils/Monitor/MonitorIncident";
+import MonitorAlert from "../../../../Server/Utils/Monitor/MonitorAlert";
+import Incident from "../../../../Models/DatabaseModels/Incident";
+import Alert from "../../../../Models/DatabaseModels/Alert";
+import MonitorCriteriaInstance from "../../../../Types/Monitor/MonitorCriteriaInstance";
+import Dictionary from "../../../../Types/Dictionary";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Regression tests for per-series offline/online auto-resolve.
+ *
+ * Per-series offline monitors (Host / Proxmox / Ceph / IoTDevice) pair
+ * an OFFLINE criteria that creates incidents (e.g. Min(device_up) < 1)
+ * with a RECOVERY criteria that does not (Min(device_up) >= 1), grouped
+ * by a device/host key. Exactly one criteria wins per evaluation tick,
+ * and the breaching-series set handed to shouldClose{Incident,Alert} is
+ * that winning criteria's per-series matches.
+ *
+ * On the recovery tick the RECOVERY criteria wins, so its matches are
+ * the healthy series — NOT breaches. The bug: membership in that set was
+ * treated as "still breaching", so the open offline incident's own
+ * fingerprint kept it pinned open forever once no other series was down.
+ * The fix only counts membership when the matched criteria actually
+ * creates incidents/alerts.
+ */
+
+const CREATED_CRITERIA_ID: string = "offline-criteria";
+const TEMPLATE_ID: string = "template-1";
+const DEVICE_FP: string = "fp-device-1";
+
+const INCIDENT_AUTO_RESOLVE: Dictionary<Array<string>> = {
+  [CREATED_CRITERIA_ID]: [TEMPLATE_ID],
+};
+const ALERT_AUTO_RESOLVE: Dictionary<Array<string>> = {
+  [CREATED_CRITERIA_ID]: [TEMPLATE_ID],
+};
+
+function incident(fingerprint: string): Incident {
+  const i: Incident = new Incident();
+  i.createdCriteriaId = CREATED_CRITERIA_ID;
+  i.createdIncidentTemplateId = TEMPLATE_ID;
+  i.seriesFingerprint = fingerprint;
+  return i;
+}
+
+function alert(fingerprint: string): Alert {
+  const a: Alert = new Alert();
+  a.createdCriteriaId = CREATED_CRITERIA_ID;
+  a.seriesFingerprint = fingerprint;
+  return a;
+}
+
+function criteria(id: string, creates: boolean): MonitorCriteriaInstance {
+  const c: MonitorCriteriaInstance = new MonitorCriteriaInstance();
+  c.data!.id = id;
+  // Same flag drives both — the templates set createIncidents/createAlerts together.
+  c.data!.createIncidents = creates;
+  c.data!.createAlerts = creates;
+  return c;
+}
+
+function shouldCloseIncident(input: Record<string, unknown>): boolean {
+  return (
+    MonitorIncident as unknown as {
+      shouldCloseIncident: (i: Record<string, unknown>) => boolean;
+    }
+  ).shouldCloseIncident(input);
+}
+function shouldCloseAlert(input: Record<string, unknown>): boolean {
+  return (
+    MonitorAlert as unknown as {
+      shouldCloseAlert: (i: Record<string, unknown>) => boolean;
+    }
+  ).shouldCloseAlert(input);
+}
+
+describe("Per-series offline/online auto-resolve", () => {
+  describe("MonitorIncident.shouldCloseIncident", () => {
+    it("RESOLVES on the recovery tick even though the recovered series is in the matched (recovery) criteria's set", () => {
+      /*
+       * The device is back up: the RECOVERY criteria won, its match set
+       * contains the now-healthy device. It must NOT keep the incident open.
+       */
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("keeps the incident open while the device is still down (offline criteria won, series still breaching)", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(false);
+    });
+
+    it("resolves when this device recovered but another device is still down (offline criteria won, fp absent)", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          // Only some OTHER device is still breaching the offline criteria.
+          breachingSeriesFingerprints: new Set<string>(["fp-device-2"]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("does not resolve on recovery when the creating criteria did not opt into auto-resolve", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary: {}, // not configured
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(false);
+    });
+
+    it("still respects the event-driven guard (incoming-request) over recovery resolution", () => {
+      expect(
+        shouldCloseIncident({
+          openIncident: incident(DEVICE_FP),
+          autoResolveCriteriaInstanceIdIncidentIdsDictionary:
+            INCIDENT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: true,
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe("MonitorAlert.shouldCloseAlert", () => {
+    it("RESOLVES on the recovery tick even though the recovered series is in the matched (recovery) criteria's set", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("keeps the alert open while the device is still down", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(false);
+    });
+
+    it("resolves when this device recovered but another is still down", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria(CREATED_CRITERIA_ID, true),
+          breachingSeriesFingerprints: new Set<string>(["fp-device-2"]),
+          disableSeriesAbsenceResolution: false,
+        }),
+      ).toBe(true);
+    });
+
+    it("still respects the event-driven guard over recovery resolution", () => {
+      expect(
+        shouldCloseAlert({
+          openAlert: alert(DEVICE_FP),
+          autoResolveCriteriaInstanceIdAlertIdsDictionary: ALERT_AUTO_RESOLVE,
+          criteriaInstance: criteria("recovery-criteria", false),
+          breachingSeriesFingerprints: new Set<string>([DEVICE_FP]),
+          disableSeriesAbsenceResolution: true,
+        }),
+      ).toBe(false);
+    });
+  });
+});

package/Tests/Types/AI/AIAgentTaskStatus.test.ts

@@ -0,0 +1,86 @@
+import AIAgentTaskStatus, {
+  AIAgentTaskStatusHelper,
+  AIAgentTaskStatusProps,
+} from "../../../Types/AI/AIAgentTaskStatus";
+
+describe("AIAgentTaskStatusHelper", () => {
+  describe("getAllStatusProps", () => {
+    test("returns one entry per status with a title and description", () => {
+      const props: Array<AIAgentTaskStatusProps> =
+        AIAgentTaskStatusHelper.getAllStatusProps();
+
+      const statuses: Array<AIAgentTaskStatus> =
+        Object.values(AIAgentTaskStatus);
+      expect(props.length).toBe(statuses.length);
+
+      for (const prop of props) {
+        expect(typeof prop.title).toBe("string");
+        expect(prop.title.length).toBeGreaterThan(0);
+        expect(typeof prop.description).toBe("string");
+        expect(prop.description.length).toBeGreaterThan(0);
+      }
+    });
+
+    test("covers every status in the enum exactly once", () => {
+      const seen: Set<AIAgentTaskStatus> = new Set<AIAgentTaskStatus>();
+      for (const prop of AIAgentTaskStatusHelper.getAllStatusProps()) {
+        expect(seen.has(prop.status)).toBe(false);
+        seen.add(prop.status);
+      }
+
+      for (const status of Object.values(AIAgentTaskStatus)) {
+        expect(seen.has(status)).toBe(true);
+      }
+    });
+  });
+
+  describe("getTitle", () => {
+    test("returns the configured title for a known status", () => {
+      expect(
+        AIAgentTaskStatusHelper.getTitle(AIAgentTaskStatus.InProgress),
+      ).toBe("In Progress");
+      expect(
+        AIAgentTaskStatusHelper.getTitle(AIAgentTaskStatus.Completed),
+      ).toBe("Completed");
+    });
+
+    test("returns an empty string for an unknown status", () => {
+      expect(
+        AIAgentTaskStatusHelper.getTitle("NonExistent" as AIAgentTaskStatus),
+      ).toBe("");
+    });
+  });
+
+  describe("getDescription", () => {
+    test("returns a non-empty description for a known status", () => {
+      expect(
+        AIAgentTaskStatusHelper.getDescription(AIAgentTaskStatus.Scheduled)
+          .length,
+      ).toBeGreaterThan(0);
+    });
+
+    test("returns an empty string for an unknown status", () => {
+      expect(
+        AIAgentTaskStatusHelper.getDescription(
+          "NonExistent" as AIAgentTaskStatus,
+        ),
+      ).toBe("");
+    });
+  });
+
+  describe("isTerminalStatus", () => {
+    test.each([AIAgentTaskStatus.Completed, AIAgentTaskStatus.Error])(
+      "returns true for terminal status %s",
+      (status: AIAgentTaskStatus) => {
+        expect(AIAgentTaskStatusHelper.isTerminalStatus(status)).toBe(true);
+      },
+    );
+
+    test.each([AIAgentTaskStatus.Scheduled, AIAgentTaskStatus.InProgress])(
+      "returns false for non-terminal status %s",
+      (status: AIAgentTaskStatus) => {
+        expect(AIAgentTaskStatusHelper.isTerminalStatus(status)).toBe(false);
+      },
+    );
+  });
+});

package/Tests/Types/BaseDatabase/AggregationIntervalUtil.test.ts

@@ -0,0 +1,127 @@
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
+import AggregationIntervalUtil from "../../../Types/BaseDatabase/AggregationIntervalUtil";
+
+describe("AggregationIntervalUtil", () => {
+  const SECOND: number = 1000;
+  const HOUR: number = SECOND * 60 * 60;
+  const DAY: number = HOUR * 24;
+
+  const windowOf: (durationMs: number) => { startDate: Date; endDate: Date } = (
+    durationMs: number,
+  ): { startDate: Date; endDate: Date } => {
+    const startDate: Date = new Date(Date.UTC(2020, 0, 1, 0, 0, 0));
+    const endDate: Date = new Date(startDate.getTime() + durationMs);
+    return { startDate, endDate };
+  };
+
+  describe("getAggregationIntervalForWindow", () => {
+    const cases: Array<[string, number, AggregationInterval]> = [
+      ["2 hours -> Minute", 2 * HOUR, AggregationInterval.Minute],
+      [
+        "exactly 3 hours -> Minute (inclusive bound)",
+        3 * HOUR,
+        AggregationInterval.Minute,
+      ],
+      ["3 hours + 1ms -> Hour", 3 * HOUR + 1, AggregationInterval.Hour],
+      ["1 day -> Hour", DAY, AggregationInterval.Hour],
+      [
+        "exactly 7 days -> Hour (inclusive bound)",
+        7 * DAY,
+        AggregationInterval.Hour,
+      ],
+      ["7 days + 1ms -> Day", 7 * DAY + 1, AggregationInterval.Day],
+      ["14 days -> Day", 14 * DAY, AggregationInterval.Day],
+      [
+        "exactly 6 weeks -> Day (inclusive bound)",
+        42 * DAY,
+        AggregationInterval.Day,
+      ],
+      ["6 weeks + 1ms -> Week", 42 * DAY + 1, AggregationInterval.Week],
+      ["60 days -> Week", 60 * DAY, AggregationInterval.Week],
+      ["200 days -> Month", 200 * DAY, AggregationInterval.Month],
+      ["8 years -> Year", 8 * 365 * DAY, AggregationInterval.Year],
+    ];
+
+    test.each(cases)(
+      "%s",
+      (_label: string, durationMs: number, expected: AggregationInterval) => {
+        expect(
+          AggregationIntervalUtil.getAggregationIntervalForWindow(
+            windowOf(durationMs),
+          ),
+        ).toBe(expected);
+      },
+    );
+
+    test("returns the widest interval as the window grows", () => {
+      const order: Array<AggregationInterval> = [
+        AggregationInterval.Minute,
+        AggregationInterval.Hour,
+        AggregationInterval.Day,
+        AggregationInterval.Week,
+        AggregationInterval.Month,
+        AggregationInterval.Year,
+      ];
+      const durations: Array<number> = [
+        HOUR,
+        2 * DAY,
+        30 * DAY,
+        90 * DAY,
+        365 * DAY,
+        10 * 365 * DAY,
+      ];
+
+      const results: Array<AggregationInterval> = durations.map(
+        (d: number): AggregationInterval => {
+          return AggregationIntervalUtil.getAggregationIntervalForWindow(
+            windowOf(d),
+          );
+        },
+      );
+
+      // Each larger window is at least as wide an interval as the previous.
+      for (let i: number = 1; i < results.length; i++) {
+        expect(order.indexOf(results[i]!)).toBeGreaterThanOrEqual(
+          order.indexOf(results[i - 1]!),
+        );
+      }
+    });
+  });
+
+  describe("getAggregationIntervalMs", () => {
+    test.each([
+      [AggregationInterval.Minute, 1000 * 60],
+      [AggregationInterval.Hour, 1000 * 60 * 60],
+      [AggregationInterval.Day, 1000 * 60 * 60 * 24],
+      [AggregationInterval.Week, 1000 * 60 * 60 * 24 * 7],
+      [AggregationInterval.Month, 1000 * 60 * 60 * 24 * 30],
+      [AggregationInterval.Year, 1000 * 60 * 60 * 24 * 365],
+    ])(
+      "maps %s to its nominal width",
+      (interval: AggregationInterval, expectedMs: number) => {
+        expect(AggregationIntervalUtil.getAggregationIntervalMs(interval)).toBe(
+          expectedMs,
+        );
+      },
+    );
+
+    test("intervals are strictly increasing in width", () => {
+      const ordered: Array<AggregationInterval> = [
+        AggregationInterval.Minute,
+        AggregationInterval.Hour,
+        AggregationInterval.Day,
+        AggregationInterval.Week,
+        AggregationInterval.Month,
+        AggregationInterval.Year,
+      ];
+
+      for (let i: number = 1; i < ordered.length; i++) {
+        expect(
+          AggregationIntervalUtil.getAggregationIntervalMs(ordered[i]!),
+        ).toBeGreaterThan(
+          AggregationIntervalUtil.getAggregationIntervalMs(ordered[i - 1]!),
+        );
+      }
+    });
+  });
+});