@oneuptime/common 12.0.1 → 12.0.3

package/Tests/Types/Monitor/SnmpVersionParsing.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from "@jest/globals";
+import SnmpVersion, {
+  SnmpVersionUtil,
+} from "../../../Types/Monitor/SnmpMonitor/SnmpVersion";
+
+/*
+ * snmpVersion is a free-text column with two live spellings: the enum VALUES
+ * ("1"/"2c"/"3") that the probe contract uses, and the enum KEYS ("V1"/"V2c"/
+ * "V3") that every form writes and the column default holds. SnmpVersionUtil is
+ * the seam that reconciles them. Reading the column any other way silently takes
+ * the wrong branch — a stored "V3" is not === SnmpVersion.V3 ("3"), so a v3
+ * device would read as v2c and be polled in cleartext.
+ *
+ * Unlike the SnmpV3 protocol parsers, parse() cannot return undefined: the probe
+ * must pick exactly one session type, so an unreadable value falls back to v2c
+ * rather than refusing. These tests pin both the recognized spellings and that
+ * deliberate default so a future edit cannot widen or narrow it unnoticed.
+ */
+
+describe("SnmpVersionUtil.parse", () => {
+  test.each([
+    ["1", SnmpVersion.V1],
+    ["2c", SnmpVersion.V2c],
+    ["3", SnmpVersion.V3],
+  ])(
+    "reads the probe-contract value spelling %j",
+    (stored: string, expected: SnmpVersion) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(expected);
+    },
+  );
+
+  /*
+   * The stored spelling — what forms write and the column default holds. This
+   * is the spelling the bare-cast bug got wrong, so it is the one that most
+   * needs a test.
+   */
+  test.each([
+    ["V1", SnmpVersion.V1],
+    ["V2c", SnmpVersion.V2c],
+    ["V3", SnmpVersion.V3],
+  ])(
+    "reads the stored enum-key spelling %j",
+    (stored: string, expected: SnmpVersion) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(expected);
+    },
+  );
+
+  test.each([
+    ["V1", SnmpVersion.V1],
+    ["v1", SnmpVersion.V1],
+    ["  1  ", SnmpVersion.V1],
+    ["\tv3\n", SnmpVersion.V3],
+    ["V3", SnmpVersion.V3],
+    ["v3", SnmpVersion.V3],
+  ])(
+    "tolerates case and surrounding whitespace in %j",
+    (stored: string, expected: SnmpVersion) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(expected);
+    },
+  );
+
+  /*
+   * v2c is the fallback branch, so every v2c spelling AND every value the parser
+   * does not recognize must land here. The two are indistinguishable by design:
+   * there is no "undefined version", the probe always needs a session type, and
+   * v2c is the safe historic default. Anything that stops mapping to v2c here is
+   * a behavior change, not a bug fix.
+   */
+  test.each([
+    ["2c", "an exact value"],
+    ["V2c", "the stored key"],
+    ["v2c", "lowercased key"],
+    ["2", "the version number without the c"],
+    ["V2", "the key without the c"],
+    [undefined, "an undefined column"],
+    [null, "a null column"],
+    ["", "an empty string"],
+    ["   ", "whitespace only"],
+    ["nonsense", "garbage"],
+    ["v4", "a version that does not exist"],
+    ["0", "a zero"],
+  ])(
+    "falls back to v2c for %j (%s)",
+    (stored: string | undefined | null, _description: string) => {
+      expect(SnmpVersionUtil.parse(stored)).toBe(SnmpVersion.V2c);
+    },
+  );
+});
+
+describe("SnmpVersionUtil.isV3", () => {
+  test.each([["3"], ["v3"], ["V3"], ["  V3  "], ["\tv3\n"]])(
+    "is true for the v3 spelling %j",
+    (stored: string) => {
+      expect(SnmpVersionUtil.isV3(stored)).toBe(true);
+    },
+  );
+
+  /*
+   * The consequential direction: everything that is not v3 must read as not-v3,
+   * because isV3 gates whether auth/priv credentials are applied. A false
+   * positive would be harmless; a false negative strands a v3 device in a v2c
+   * branch and polls it without credentials.
+   */
+  test.each([
+    ["1"],
+    ["V1"],
+    ["2c"],
+    ["V2c"],
+    ["v2c"],
+    ["2"],
+    [undefined],
+    [null],
+    [""],
+    ["   "],
+    ["nonsense"],
+  ])(
+    "is false for the non-v3 value %j",
+    (stored: string | undefined | null) => {
+      expect(SnmpVersionUtil.isV3(stored)).toBe(false);
+    },
+  );
+
+  test("agrees with parse() for every recognized spelling", () => {
+    for (const spelling of ["1", "v1", "V1", "2c", "V2c", "3", "v3", "V3"]) {
+      expect(SnmpVersionUtil.isV3(spelling)).toBe(
+        SnmpVersionUtil.parse(spelling) === SnmpVersion.V3,
+      );
+    }
+  });
+});
+
+describe("every enum member survives a round trip", () => {
+  /*
+   * Exhaustive over the enum rather than a fixed list, so adding a version
+   * without teaching parse() its value AND key spelling fails here instead of
+   * silently collapsing to v2c in production.
+   */
+  test("each value spelling parses back to itself", () => {
+    for (const member of Object.values(SnmpVersion)) {
+      expect(SnmpVersionUtil.parse(member)).toBe(member);
+    }
+  });
+
+  test("each key spelling parses to its member", () => {
+    for (const key of Object.keys(SnmpVersion)) {
+      // Keys are "V1"/"V2c"/"V3"; the member is looked up by that key.
+      const expected: SnmpVersion =
+        SnmpVersion[key as keyof typeof SnmpVersion];
+      expect(SnmpVersionUtil.parse(key)).toBe(expected);
+    }
+  });
+});

package/Tests/Types/Port.test.ts

@@ -36,4 +36,42 @@ describe("Testing class port", () => {
     const value: Port = new Port("6000");
     expect(typeof value.port.positiveNumber).toBe("number");
   });
+
+  /*
+   * A port column is declared `TableColumnType.Number`, so whatever reaches
+   * the transformer may be a Port, a string, or a plain number depending on
+   * how far the request body got through deserialization. A raw number used
+   * to fall off the end of `toDatabase` and return null, which wrote NULL
+   * over an SMTP port the user had just typed — silently, since null is a
+   * legal value for the column.
+   */
+  describe("getDatabaseTransformer().to", () => {
+    const transformer: ReturnType<typeof Port.getDatabaseTransformer> =
+      Port.getDatabaseTransformer();
+
+    test("stores a Port instance as its number", () => {
+      expect(transformer.to(new Port(587))).toBe(587);
+    });
+
+    test("stores a raw string port as a number", () => {
+      expect(transformer.to("587")).toBe(587);
+    });
+
+    test("stores a raw number port rather than dropping it", () => {
+      expect(transformer.to(587)).toBe(587);
+      expect(transformer.to(0)).toBe(0);
+      expect(transformer.to(65535)).toBe(65535);
+    });
+
+    test("keeps undefined distinct from null so a column DEFAULT applies", () => {
+      expect(transformer.to(undefined)).toBeUndefined();
+      expect(transformer.to(null)).toBeNull();
+    });
+
+    test("rejects a port outside the valid range instead of storing null", () => {
+      expect(() => {
+        return transformer.to(70000);
+      }).toThrow(BadDataException);
+    });
+  });
 });

package/Tests/UI/Components/LogsHistogram.test.tsx

@@ -0,0 +1,276 @@
+/** @timezone UTC */
+
+import LogsHistogram from "../../../UI/Components/LogsViewer/components/LogsHistogram";
+import { HistogramBucket } from "../../../UI/Components/LogsViewer/types";
+import LogSeverity from "../../../Types/Log/LogSeverity";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * ResponsiveContainer measures its parent, which is always 0x0 in jsdom, so the
+ * chart renders nothing without a fixed size.
+ */
+jest.mock("recharts", () => {
+  const actual: Record<string, any> = jest.requireActual("recharts");
+  return {
+    ...actual,
+    ResponsiveContainer: ({ children }: { children: React.ReactElement }) => {
+      return React.cloneElement(children, { width: 600, height: 300 });
+    },
+  };
+});
+
+function bucket(
+  time: string,
+  severity: string,
+  count: number,
+): HistogramBucket {
+  return { time, severity, count };
+}
+
+/** One bar rectangle is drawn per severity per bucket that has a count. */
+function barCount(container: HTMLElement): number {
+  return container.querySelectorAll(".recharts-bar-rectangle").length;
+}
+
+/** One <g> per stacked series, i.e. per severity present in the data. */
+function seriesCount(container: HTMLElement): number {
+  return container.querySelectorAll(".recharts-bar").length;
+}
+
+const CLOCK_LABEL: RegExp = /^\d{2}:\d{2}$/;
+
+/*
+ * Recharts portals tick labels out of their axis group, so the two axes are
+ * told apart by what they render: the time axis is formatted as a clock, the
+ * count axis as a number.
+ */
+function axisLabels(
+  container: HTMLElement,
+  axis: "time" | "count",
+): Array<string> {
+  const labels: Array<string> = Array.from(
+    container.querySelectorAll(".recharts-cartesian-axis-tick-value"),
+  ).map((tick: Element): string => {
+    return tick.textContent || "";
+  });
+
+  return labels.filter((label: string): boolean => {
+    return CLOCK_LABEL.test(label) === (axis === "time");
+  });
+}
+
+const ONE_SEVERITY: Array<HistogramBucket> = [
+  bucket("2026-08-05T11:58:00Z", LogSeverity.Error, 3),
+  bucket("2026-08-05T11:59:00Z", LogSeverity.Error, 5),
+  bucket("2026-08-05T12:00:00Z", LogSeverity.Error, 7),
+];
+
+describe("LogsHistogram", () => {
+  describe("empty and loading states", () => {
+    test("renders nothing when the window holds no logs", () => {
+      const { container } = render(
+        <LogsHistogram buckets={[]} isLoading={false} />,
+      );
+
+      expect(container.innerHTML).toBe("");
+    });
+
+    test("shows the loader on the very first load", () => {
+      render(<LogsHistogram buckets={[]} isLoading={true} />);
+
+      expect(screen.queryByTestId("component-loader")).not.toBeNull();
+    });
+
+    /*
+     * Live mode refreshes the histogram every few seconds. Swapping the chart
+     * for a loader on each poll would make it flash; the chart already on
+     * screen stays until the new buckets land.
+     */
+    test("keeps the chart on screen while a refresh is in flight", () => {
+      const { container } = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={true} />,
+      );
+
+      expect(screen.queryByTestId("component-loader")).toBeNull();
+      expect(screen.queryByText("Log Volume")).not.toBeNull();
+      expect(barCount(container)).toBe(3);
+    });
+  });
+
+  describe("drawing the buckets", () => {
+    test("draws one bar per bucket", () => {
+      const { container } = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      expect(barCount(container)).toBe(3);
+      expect(seriesCount(container)).toBe(1);
+    });
+
+    test("stacks a bar per severity inside a bucket", () => {
+      const { container } = render(
+        <LogsHistogram
+          buckets={[
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Error, 4),
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Warning, 6),
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Information, 9),
+          ]}
+          isLoading={false}
+        />,
+      );
+
+      expect(seriesCount(container)).toBe(3);
+      expect(barCount(container)).toBe(3);
+    });
+
+    test("labels the time axis in the reader's clock", () => {
+      const { container } = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      expect(axisLabels(container, "time")).toContain("12:00");
+    });
+
+    test("lists only the severities present in the window", () => {
+      render(
+        <LogsHistogram
+          buckets={[
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Error, 4),
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Debug, 1),
+          ]}
+          isLoading={false}
+        />,
+      );
+
+      expect(screen.queryByText("Error")).not.toBeNull();
+      expect(screen.queryByText("Debug")).not.toBeNull();
+      expect(screen.queryByText("Fatal")).toBeNull();
+    });
+  });
+
+  /*
+   * What live mode looks like from the chart's side: the same component is
+   * handed a fresh set of buckets every poll and has to redraw.
+   */
+  describe("when a live refresh brings new data", () => {
+    test("adds a bar as a new bucket opens", () => {
+      const view: ReturnType<typeof render> = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      expect(barCount(view.container)).toBe(3);
+
+      view.rerender(
+        <LogsHistogram
+          buckets={[
+            ...ONE_SEVERITY,
+            bucket("2026-08-05T12:01:00Z", LogSeverity.Error, 2),
+          ]}
+          isLoading={false}
+        />,
+      );
+
+      expect(barCount(view.container)).toBe(4);
+    });
+
+    test("follows the window as it slides off the oldest bucket", () => {
+      const view: ReturnType<typeof render> = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      expect(axisLabels(view.container, "time")).toContain("11:58");
+
+      view.rerender(
+        <LogsHistogram
+          buckets={[
+            ...ONE_SEVERITY.slice(1),
+            bucket("2026-08-05T12:01:00Z", LogSeverity.Error, 2),
+          ]}
+          isLoading={false}
+        />,
+      );
+
+      const labels: Array<string> = axisLabels(view.container, "time");
+      expect(labels).not.toContain("11:58");
+      expect(labels).toContain("12:01");
+    });
+
+    test("rescales the count axis as the newest bucket fills up", () => {
+      const view: ReturnType<typeof render> = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      const before: Array<string> = axisLabels(view.container, "count");
+
+      view.rerender(
+        <LogsHistogram
+          buckets={[
+            ...ONE_SEVERITY.slice(0, 2),
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Error, 400),
+          ]}
+          isLoading={false}
+        />,
+      );
+
+      const after: Array<string> = axisLabels(view.container, "count");
+
+      expect(after).not.toEqual(before);
+      expect(Number(after[after.length - 1])).toBeGreaterThan(
+        Number(before[before.length - 1]),
+      );
+    });
+
+    test("adds a series and a legend entry when a new severity shows up", () => {
+      const view: ReturnType<typeof render> = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      expect(screen.queryByText("Fatal")).toBeNull();
+
+      view.rerender(
+        <LogsHistogram
+          buckets={[
+            ...ONE_SEVERITY,
+            bucket("2026-08-05T12:00:00Z", LogSeverity.Fatal, 1),
+          ]}
+          isLoading={false}
+        />,
+      );
+
+      expect(screen.queryByText("Fatal")).not.toBeNull();
+      expect(seriesCount(view.container)).toBe(2);
+    });
+
+    test("empties the chart when the refreshed window has no logs", () => {
+      const view: ReturnType<typeof render> = render(
+        <LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />,
+      );
+
+      view.rerender(<LogsHistogram buckets={[]} isLoading={false} />);
+
+      expect(view.container.innerHTML).toBe("");
+    });
+  });
+
+  describe("drag to zoom", () => {
+    test("offers the affordance when the parent can act on a selection", () => {
+      render(
+        <LogsHistogram
+          buckets={ONE_SEVERITY}
+          isLoading={false}
+          onTimeRangeSelect={() => {}}
+        />,
+      );
+
+      expect(screen.queryByText("Drag to zoom")).not.toBeNull();
+    });
+
+    test("hides the affordance when there is nothing to zoom into", () => {
+      render(<LogsHistogram buckets={ONE_SEVERITY} isLoading={false} />);
+
+      expect(screen.queryByText("Drag to zoom")).toBeNull();
+    });
+  });
+});