@oneuptime/common 11.6.1 → 11.6.2

package/Tests/Server/Utils/MonitorCriteriaMessageFormatter.test.ts

@@ -0,0 +1,282 @@
+import MonitorCriteriaMessageFormatter from "../../../Server/Utils/Monitor/MonitorCriteriaMessageFormatter";
+import { BasicDiskMetrics } from "../../../Types/Infrastructure/BasicMetrics";
+import { ServerProcess } from "../../../Types/Monitor/ServerMonitor/ServerMonitorResponse";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * MonitorCriteriaMessageFormatter builds the human-readable snippets that go
+ * into monitor alert/incident messages. Every method here is pure and its
+ * output is user-facing text, so these tests pin the exact formatting rules
+ * (fraction-digit thresholds, byte scaling, truncation) that a copy-tweak
+ * could quietly change.
+ */
+
+describe("MonitorCriteriaMessageFormatter.formatNumber", () => {
+  test("returns null for null/undefined/NaN", () => {
+    expect(MonitorCriteriaMessageFormatter.formatNumber(null)).toBeNull();
+    expect(MonitorCriteriaMessageFormatter.formatNumber(undefined)).toBeNull();
+    expect(MonitorCriteriaMessageFormatter.formatNumber(NaN)).toBeNull();
+  });
+
+  test("uses 2 fraction digits for magnitude < 10", () => {
+    expect(MonitorCriteriaMessageFormatter.formatNumber(3.14159)).toBe("3.14");
+  });
+
+  test("uses 1 fraction digit for magnitude between 10 and 100", () => {
+    expect(MonitorCriteriaMessageFormatter.formatNumber(42.789)).toBe("42.8");
+  });
+
+  test("uses 0 fraction digits for magnitude >= 100", () => {
+    expect(MonitorCriteriaMessageFormatter.formatNumber(1234.9)).toBe("1235");
+  });
+
+  test("respects an explicit maximumFractionDigits override", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.formatNumber(3.14159, {
+        maximumFractionDigits: 4,
+      }),
+    ).toBe("3.1416");
+  });
+
+  test("applies the magnitude buckets to negative numbers too", () => {
+    expect(MonitorCriteriaMessageFormatter.formatNumber(-5.5)).toBe("-5.50");
+    expect(MonitorCriteriaMessageFormatter.formatNumber(-250.4)).toBe("-250");
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.formatPercentage", () => {
+  test("appends a percent sign with 1 decimal below 100", () => {
+    expect(MonitorCriteriaMessageFormatter.formatPercentage(87.654)).toBe(
+      "87.7%",
+    );
+  });
+
+  test("uses 0 decimals at/above 100", () => {
+    expect(MonitorCriteriaMessageFormatter.formatPercentage(100)).toBe("100%");
+  });
+
+  test("returns null for null input", () => {
+    expect(MonitorCriteriaMessageFormatter.formatPercentage(null)).toBeNull();
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.formatBytes", () => {
+  test("keeps small values in bytes", () => {
+    expect(MonitorCriteriaMessageFormatter.formatBytes(512)).toBe("512 B");
+  });
+
+  test("scales to KB (values < 10 keep 2 decimals)", () => {
+    expect(MonitorCriteriaMessageFormatter.formatBytes(1536)).toBe("1.50 KB");
+  });
+
+  test("scales to MB", () => {
+    expect(MonitorCriteriaMessageFormatter.formatBytes(5 * 1024 * 1024)).toBe(
+      "5.00 MB",
+    );
+  });
+
+  test("scales to GB with proper precision", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.formatBytes(2.5 * 1024 * 1024 * 1024),
+    ).toBe("2.50 GB");
+  });
+
+  test("large scaled values >= 100 drop the decimals", () => {
+    // 512 GB -> value 512 in-unit, which is >= 100 so 0 fraction digits.
+    expect(
+      MonitorCriteriaMessageFormatter.formatBytes(512 * 1024 * 1024 * 1024),
+    ).toBe("512 GB");
+  });
+
+  test("returns null for null/NaN", () => {
+    expect(MonitorCriteriaMessageFormatter.formatBytes(null)).toBeNull();
+    expect(MonitorCriteriaMessageFormatter.formatBytes(NaN)).toBeNull();
+  });
+
+  test("handles zero bytes", () => {
+    expect(MonitorCriteriaMessageFormatter.formatBytes(0)).toBe("0.00 B");
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.formatList", () => {
+  test("returns empty string for an empty list", () => {
+    expect(MonitorCriteriaMessageFormatter.formatList([])).toBe("");
+  });
+
+  test("joins items under the cap with commas", () => {
+    expect(MonitorCriteriaMessageFormatter.formatList(["a", "b", "c"])).toBe(
+      "a, b, c",
+    );
+  });
+
+  test("truncates with a +N more suffix past the cap", () => {
+    const result: string = MonitorCriteriaMessageFormatter.formatList(
+      ["a", "b", "c", "d", "e", "f", "g"],
+      3,
+    );
+    expect(result).toContain("a, b, c");
+    expect(result).toContain("+4 more");
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.formatSnippet", () => {
+  test("collapses whitespace runs into single spaces", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.formatSnippet("hello   \n\t  world"),
+    ).toBe("hello world");
+  });
+
+  test("truncates with an ellipsis past maxLength", () => {
+    const result: string = MonitorCriteriaMessageFormatter.formatSnippet(
+      "abcdefghij",
+      5,
+    );
+    expect(result).toBe("abcde…");
+  });
+
+  test("leaves short text untouched", () => {
+    expect(MonitorCriteriaMessageFormatter.formatSnippet("short", 100)).toBe(
+      "short",
+    );
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.describeProcesses", () => {
+  test("returns null for no processes", () => {
+    expect(MonitorCriteriaMessageFormatter.describeProcesses([])).toBeNull();
+  });
+
+  test("summarizes processes as name (pid N)", () => {
+    const processes: Array<ServerProcess> = [
+      { pid: 100, name: "node", command: "node index.js" },
+      { pid: 200, name: "nginx", command: "nginx" },
+    ];
+    const result: string | null =
+      MonitorCriteriaMessageFormatter.describeProcesses(processes);
+    expect(result).toContain("node (pid 100)");
+    expect(result).toContain("nginx (pid 200)");
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.computeDiskUsagePercent", () => {
+  const baseDisk: BasicDiskMetrics = {
+    total: 0,
+    free: 0,
+    used: 0,
+    diskPath: "/",
+    percentUsed: NaN,
+    percentFree: NaN,
+  };
+
+  test("returns null for a missing disk metric", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.computeDiskUsagePercent(
+        undefined as unknown as BasicDiskMetrics,
+      ),
+    ).toBeNull();
+  });
+
+  test("prefers percentUsed when present", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.computeDiskUsagePercent({
+        ...baseDisk,
+        percentUsed: 73,
+      }),
+    ).toBe(73);
+  });
+
+  test("derives from percentFree when percentUsed is absent", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.computeDiskUsagePercent({
+        ...baseDisk,
+        percentUsed: NaN,
+        percentFree: 40,
+      }),
+    ).toBe(60);
+  });
+
+  test("falls back to used/total ratio", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.computeDiskUsagePercent({
+        ...baseDisk,
+        percentUsed: NaN,
+        percentFree: NaN,
+        total: 200,
+        used: 50,
+      }),
+    ).toBe(25);
+  });
+
+  test("returns null when nothing usable is present", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.computeDiskUsagePercent({
+        ...baseDisk,
+      }),
+    ).toBeNull();
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.summarizeNumericSeries", () => {
+  test("returns null for an empty series", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.summarizeNumericSeries([]),
+    ).toBeNull();
+  });
+
+  test("single value reports latest and one data point", () => {
+    const result: string | null =
+      MonitorCriteriaMessageFormatter.summarizeNumericSeries([0.06], "sec");
+    expect(result).toBe("latest 0.06 sec across 1 data point");
+  });
+
+  test("multi value reports latest, min, max and count", () => {
+    const result: string | null =
+      MonitorCriteriaMessageFormatter.summarizeNumericSeries(
+        [10, 5, 20, 15],
+        "ms",
+      );
+    expect(result).toContain("latest 15.00 ms");
+    expect(result).toContain("min 5.00 ms");
+    expect(result).toContain("max 20.00 ms");
+    expect(result).toContain("across 4 data points");
+  });
+
+  test("omits the unit suffix when no unit is given", () => {
+    const result: string | null =
+      MonitorCriteriaMessageFormatter.summarizeNumericSeries([1, 2]);
+    expect(result).toContain("latest 2.00 (min 1.00, max 2.00)");
+    expect(result).not.toContain("undefined");
+  });
+});
+
+describe("MonitorCriteriaMessageFormatter.formatResultValue", () => {
+  test("returns the string 'undefined' for null/undefined", () => {
+    expect(MonitorCriteriaMessageFormatter.formatResultValue(null)).toBe(
+      "undefined",
+    );
+    expect(MonitorCriteriaMessageFormatter.formatResultValue(undefined)).toBe(
+      "undefined",
+    );
+  });
+
+  test("JSON-stringifies objects", () => {
+    expect(
+      MonitorCriteriaMessageFormatter.formatResultValue({ a: 1, b: "x" }),
+    ).toBe('{"a":1,"b":"x"}');
+  });
+
+  test("returns [object] for a value that cannot be stringified", () => {
+    const circular: Record<string, unknown> = {};
+    circular["self"] = circular;
+    expect(MonitorCriteriaMessageFormatter.formatResultValue(circular)).toBe(
+      "[object]",
+    );
+  });
+
+  test("stringifies primitives via toString", () => {
+    expect(MonitorCriteriaMessageFormatter.formatResultValue(42)).toBe("42");
+    expect(MonitorCriteriaMessageFormatter.formatResultValue(true)).toBe(
+      "true",
+    );
+  });
+});

package/Tests/Server/Utils/OuiLookupUtil.test.ts

@@ -0,0 +1,59 @@
+import OuiLookupUtil from "../../../Server/Utils/Monitor/OuiLookupUtil";
+
+/*
+ * The known-prefix assertions pin real rows from the bundled
+ * Data/OuiVendors.json (generated from the IEEE MA-L registry — see the
+ * header comment in OuiLookupUtil). If a registry refresh renames an
+ * organization, update the expected strings to the new registry value.
+ */
+describe("OuiLookupUtil.lookupVendor", () => {
+  it("resolves the classic Cisco OUI 00:00:0c", () => {
+    expect(OuiLookupUtil.lookupVendor("00:00:0c:12:34:56")).toBe(
+      "Cisco Systems, Inc",
+    );
+  });
+
+  it("resolves the Raspberry Pi OUI b8:27:eb", () => {
+    expect(OuiLookupUtil.lookupVendor("b8:27:eb:aa:bb:cc")).toBe(
+      "Raspberry Pi Foundation",
+    );
+  });
+
+  it("resolves the Ubiquiti OUI f0:9f:c2", () => {
+    expect(OuiLookupUtil.lookupVendor("f0:9f:c2:00:11:22")).toBe(
+      "Ubiquiti Inc",
+    );
+  });
+
+  it("accepts every MAC spelling normalizeMac understands", () => {
+    expect(OuiLookupUtil.lookupVendor("00-00-0C-12-34-56")).toBe(
+      "Cisco Systems, Inc",
+    );
+    expect(OuiLookupUtil.lookupVendor("0000.0c12.3456")).toBe(
+      "Cisco Systems, Inc",
+    );
+    expect(OuiLookupUtil.lookupVendor("00000c123456")).toBe(
+      "Cisco Systems, Inc",
+    );
+    expect(OuiLookupUtil.lookupVendor("0x00000C123456")).toBe(
+      "Cisco Systems, Inc",
+    );
+  });
+
+  it("returns undefined for OUIs outside the filtered registry", () => {
+    // Locally administered — never in the IEEE registry.
+    expect(OuiLookupUtil.lookupVendor("02:00:00:00:00:01")).toBeUndefined();
+  });
+
+  it("returns undefined for malformed MACs", () => {
+    expect(OuiLookupUtil.lookupVendor(undefined)).toBeUndefined();
+    expect(OuiLookupUtil.lookupVendor("")).toBeUndefined();
+    expect(OuiLookupUtil.lookupVendor("00:00:0c")).toBeUndefined();
+    expect(OuiLookupUtil.lookupVendor("not-a-mac")).toBeUndefined();
+    expect(OuiLookupUtil.lookupVendor("gg:hh:ii:jj:kk:ll")).toBeUndefined();
+  });
+
+  it("never returns a value for a bare OUI prefix (needs a full MAC)", () => {
+    expect(OuiLookupUtil.lookupVendor("00000c")).toBeUndefined();
+  });
+});

package/Tests/Server/Utils/SeriesResourceLabels.test.ts

@@ -0,0 +1,117 @@
+import SeriesResourceLabels, {
+  HostNameLabelKeys,
+  SeriesResourceRefs,
+} from "../../../Server/Utils/Monitor/SeriesResourceLabels";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * SeriesResourceLabels maps raw telemetry series labels onto OneUptime
+ * resource identifiers. The correlation that lights up "which host/cluster/
+ * service is this series about" depends entirely on collectLabelValues
+ * reading the right keys and deduping — these tests lock that behavior and
+ * the deliberate Docker/host key separation documented in the source.
+ */
+
+describe("SeriesResourceLabels.collectLabelValues", () => {
+  test("collects a single string value at a matching key", () => {
+    const labels: JSONObject = { "host.name": "web-1" };
+    expect(
+      SeriesResourceLabels.collectLabelValues(labels, HostNameLabelKeys),
+    ).toEqual(["web-1"]);
+  });
+
+  test("flattens array-valued labels", () => {
+    const labels: JSONObject = {
+      "host.name": ["web-1", "web-2"],
+    };
+    expect(
+      SeriesResourceLabels.collectLabelValues(labels, HostNameLabelKeys),
+    ).toEqual(["web-1", "web-2"]);
+  });
+
+  test("dedupes values that appear under multiple keys", () => {
+    const labels: JSONObject = {
+      "host.name": "web-1",
+      "resource.host.name": "web-1",
+      "oneuptime.host.name": "web-2",
+    };
+    const values: Array<string> = SeriesResourceLabels.collectLabelValues(
+      labels,
+      HostNameLabelKeys,
+    );
+    expect(values.sort()).toEqual(["web-1", "web-2"]);
+  });
+
+  test("ignores empty strings and non-string scalars", () => {
+    const labels: JSONObject = {
+      "host.name": "",
+      "resource.host.name": 42 as unknown as string,
+    };
+    expect(
+      SeriesResourceLabels.collectLabelValues(labels, HostNameLabelKeys),
+    ).toEqual([]);
+  });
+
+  test("ignores non-string items within an array", () => {
+    const labels: JSONObject = {
+      "host.name": ["web-1", 5 as unknown as string, "", "web-3"],
+    };
+    expect(
+      SeriesResourceLabels.collectLabelValues(labels, HostNameLabelKeys),
+    ).toEqual(["web-1", "web-3"]);
+  });
+
+  test("returns empty array when no key matches", () => {
+    const labels: JSONObject = { "unrelated.key": "value" };
+    expect(
+      SeriesResourceLabels.collectLabelValues(labels, HostNameLabelKeys),
+    ).toEqual([]);
+  });
+});
+
+describe("SeriesResourceLabels.extractResourceRefs", () => {
+  test("splits ids and names across resource types", () => {
+    const labels: JSONObject = {
+      "oneuptime.host.id": "host-id-1",
+      "host.name": "web-1",
+      "k8s.cluster.name": "prod-cluster",
+      "service.name": "checkout",
+      "oneuptime.service.id": "svc-id-1",
+    };
+
+    const refs: SeriesResourceRefs =
+      SeriesResourceLabels.extractResourceRefs(labels);
+
+    expect(refs.hostIds).toEqual(["host-id-1"]);
+    expect(refs.hostNames).toEqual(["web-1"]);
+    expect(refs.kubernetesClusterNames).toEqual(["prod-cluster"]);
+    expect(refs.serviceNames).toEqual(["checkout"]);
+    expect(refs.serviceIds).toEqual(["svc-id-1"]);
+  });
+
+  test("a docker host label does not leak into host names", () => {
+    /*
+     * The source deliberately keeps raw host.name out of DockerHost keys and
+     * vice versa. A docker-only label must not populate hostNames.
+     */
+    const labels: JSONObject = {
+      "oneuptime.docker.host.name": "docker-box",
+    };
+
+    const refs: SeriesResourceRefs =
+      SeriesResourceLabels.extractResourceRefs(labels);
+
+    expect(refs.dockerHostNames).toEqual(["docker-box"]);
+    expect(refs.hostNames).toEqual([]);
+  });
+
+  test("returns all-empty refs for labels with no known keys", () => {
+    const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs({
+      "some.random.label": "x",
+    });
+
+    const allValues: Array<string> = Object.values(refs).flat();
+    expect(allValues).toEqual([]);
+  });
+});