@oneuptime/common 11.5.8 → 11.5.10

package/Tests/UI/Components/Charts/AxisTickColor.test.tsx

@@ -0,0 +1,66 @@
+import { AreaChart } from "../../../../UI/Components/Charts/ChartLibrary/AreaChart/AreaChart";
+import { BarChart } from "../../../../UI/Components/Charts/ChartLibrary/BarChart/BarChart";
+import { LineChart } from "../../../../UI/Components/Charts/ChartLibrary/LineChart/LineChart";
+import "@testing-library/jest-dom/extend-expect";
+import { render } 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 });
+    },
+  };
+});
+
+type ChartData = Record<string, any>;
+
+const data: ChartData[] = [
+  { time: "10:00", Requests: 1200 },
+  { time: "10:05", Requests: 2400 },
+  { time: "10:10", Requests: 1800 },
+];
+
+const CHARTS: Array<[string, React.ReactElement]> = [
+  [
+    "LineChart",
+    <LineChart data={data} index="time" categories={["Requests"]} />,
+  ],
+  [
+    "AreaChart",
+    <AreaChart data={data} index="time" categories={["Requests"]} />,
+  ],
+  ["BarChart", <BarChart data={data} index="time" categories={["Requests"]} />],
+];
+
+describe("Chart axis tick colour", () => {
+  /*
+   * Recharts >= 3.4 portals tick labels into a separate z-index layer, outside the
+   * axis <g>. Anything that relies on the axis's class or on fill inheritance to
+   * colour them silently paints black, which is invisible in dark mode. The tick
+   * must therefore carry its own fill.
+   */
+  test.each(CHARTS)(
+    "%s gives axis ticks an explicit themeable fill",
+    (_name: string, element: React.ReactElement) => {
+      const { container } = render(element);
+
+      const ticks: Array<Element> = Array.from(
+        container.querySelectorAll(".recharts-cartesian-axis-tick-value"),
+      );
+
+      expect(ticks.length).toBeGreaterThan(0);
+
+      for (const tick of ticks) {
+        expect(tick.getAttribute("fill")).toBe("var(--ou-chart-tick)");
+      }
+    },
+  );
+});

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

@@ -9,9 +9,11 @@ describe("XAxisUtil", () => {
       xAxisMax: new Date("2026-04-07T14:00:00.000Z"),
     });
 
-    expect(formatter(new Date("2026-04-07T07:30:00.000Z"))).toBe(
-      "07 Apr, 08:00",
-    );
+    /*
+     * A 24h window now uses the fifteen-minute precision tier, whose labels
+     * are local wall-clock times: 07:30 UTC is 08:30 in BST.
+     */
+    expect(formatter(new Date("2026-04-07T07:30:00.000Z"))).toBe("08:30");
   });
 
   test("does not mutate the original date while rounding local labels", () => {

package/Tests/UI/Utils/AIChatExport/ChatWidgetData.test.ts

@@ -0,0 +1,319 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  AIChatWidget,
+  AIChatWidgetSpan,
+  AIChatWidgetType,
+} from "../../../../Types/AI/AIChatTypes";
+import {
+  ExportChartSeries,
+  SpanBarMetrics,
+  buildParentBySpanId,
+  chartHasData,
+  chartIsTimeBased,
+  computeSpanBar,
+  computeSpanDepth,
+  formatChartValue,
+  formatStatValue,
+  formatTableCell,
+  formatToolArguments,
+  toEntityListEntry,
+  toExportChartSeries,
+  totalTraceDuration,
+} from "../../../../UI/Utils/AIChatExport/ChatWidgetData";
+
+/*
+ * These helpers exist to keep the exports in step with what the chat renders,
+ * so the tests pin the behaviors that are easy to "tidy up" by accident — the
+ * dash for empty cells, 0 not being empty, and a numeric string deliberately
+ * not getting the grouping a real number gets.
+ */
+
+function chartWidget(data: AIChatWidget["data"]): AIChatWidget {
+  return {
+    id: "W1",
+    type: AIChatWidgetType.TimeSeriesChart,
+    title: "Chart",
+    data: data,
+  };
+}
+
+describe("ChatWidgetData", () => {
+  describe("formatTableCell", () => {
+    test("renders an em dash for null, undefined and empty string only", () => {
+      const column: { key: string; title: string } = { key: "a", title: "A" };
+
+      expect(formatTableCell(null, column)).toBe("—");
+      expect(formatTableCell(undefined, column)).toBe("—");
+      expect(formatTableCell("", column)).toBe("—");
+    });
+
+    test("keeps falsy-but-real values, which are not empty", () => {
+      const column: { key: string; title: string } = { key: "a", title: "A" };
+
+      expect(formatTableCell(0, column)).toBe("0");
+      expect(formatTableCell(false, column)).toBe("false");
+    });
+
+    test("groups a number column, but only when the value is really a number", () => {
+      const numeric: { key: string; title: string; type: "number" } = {
+        key: "n",
+        title: "N",
+        type: "number",
+      };
+
+      expect(formatTableCell(1234567, numeric)).toBe(
+        (1234567).toLocaleString(),
+      );
+      // A numeric string falls through to String() and keeps no separators.
+      expect(formatTableCell("1234567", numeric)).toBe("1234567");
+    });
+
+    test("stringifies anything else", () => {
+      const column: { key: string; title: string } = { key: "a", title: "A" };
+      expect(formatTableCell(["a", "b"], column)).toBe("a,b");
+    });
+  });
+
+  describe("formatStatValue", () => {
+    test("groups numbers and passes strings through verbatim", () => {
+      expect(formatStatValue({ label: "x", value: 1284322 })).toBe(
+        (1284322).toLocaleString(),
+      );
+      expect(formatStatValue({ label: "x", value: "1284322" })).toBe("1284322");
+    });
+
+    test("appends the unit when there is one", () => {
+      expect(formatStatValue({ label: "x", value: 12, unit: "ms" })).toBe(
+        "12 ms",
+      );
+      expect(formatStatValue({ label: "x", value: 12, unit: "" })).toBe("12");
+    });
+  });
+
+  describe("formatChartValue", () => {
+    test("rounds to a whole number at or above 100, and to 2dp below", () => {
+      expect(formatChartValue(1234.56)).toBe((1235).toLocaleString());
+      expect(formatChartValue(12.345)).toBe((12.35).toLocaleString());
+      expect(formatChartValue(-1234.56)).toBe((-1235).toLocaleString());
+    });
+
+    test("appends the unit after a single space", () => {
+      expect(formatChartValue(12.5, "ms")).toBe("12.5 ms");
+    });
+  });
+
+  describe("formatToolArguments", () => {
+    test("skips empty values but keeps 0 and false", () => {
+      expect(
+        formatToolArguments({ a: null, b: undefined, c: "", d: 0, e: false }),
+      ).toBe("d: 0  ·  e: false");
+    });
+
+    test("json-encodes objects and arrays", () => {
+      expect(formatToolArguments({ tags: ["a", "b"] })).toBe('tags: ["a","b"]');
+    });
+
+    test("truncates a long value with an ellipsis, never the key", () => {
+      const long: string = "x".repeat(200);
+      const result: string = formatToolArguments({ key: long });
+
+      expect(result.startsWith("key: ")).toBe(true);
+      expect(result.endsWith("…")).toBe(true);
+      expect(result).toBe(`key: ${"x".repeat(80)}…`);
+    });
+  });
+
+  describe("span helpers", () => {
+    const spans: Array<AIChatWidgetSpan> = [
+      {
+        spanId: "a",
+        name: "root",
+        startOffsetMs: 0,
+        durationMs: 100,
+        isError: false,
+      },
+      {
+        spanId: "b",
+        parentSpanId: "a",
+        name: "child",
+        startOffsetMs: 10,
+        durationMs: 50,
+        isError: false,
+      },
+      {
+        spanId: "c",
+        parentSpanId: "b",
+        name: "grandchild",
+        startOffsetMs: 20,
+        durationMs: 10,
+        isError: true,
+      },
+    ];
+
+    test("depth counts the parent chain", () => {
+      const parents: Map<string, string | undefined> =
+        buildParentBySpanId(spans);
+
+      expect(computeSpanDepth(spans[0] as AIChatWidgetSpan, parents)).toBe(0);
+      expect(computeSpanDepth(spans[1] as AIChatWidgetSpan, parents)).toBe(1);
+      expect(computeSpanDepth(spans[2] as AIChatWidgetSpan, parents)).toBe(2);
+    });
+
+    test("a parent cycle terminates instead of hanging", () => {
+      const cyclic: Array<AIChatWidgetSpan> = [
+        {
+          spanId: "x",
+          parentSpanId: "y",
+          name: "x",
+          startOffsetMs: 0,
+          durationMs: 1,
+          isError: false,
+        },
+        {
+          spanId: "y",
+          parentSpanId: "x",
+          name: "y",
+          startOffsetMs: 0,
+          durationMs: 1,
+          isError: false,
+        },
+      ];
+      const parents: Map<string, string | undefined> =
+        buildParentBySpanId(cyclic);
+
+      expect(
+        computeSpanDepth(cyclic[0] as AIChatWidgetSpan, parents),
+      ).toBeLessThanOrEqual(13);
+    });
+
+    test("the bar keeps a visible minimum width and stays inside the track", () => {
+      // A zero-duration span still gets the 1.5% floor.
+      const zero: SpanBarMetrics = computeSpanBar(
+        {
+          spanId: "z",
+          name: "z",
+          startOffsetMs: 0,
+          durationMs: 0,
+          isError: false,
+        },
+        1000,
+      );
+      expect(zero.widthPercent).toBe(1.5);
+
+      // A span running past the end is clipped to the right edge.
+      const overflowing: SpanBarMetrics = computeSpanBar(
+        {
+          spanId: "o",
+          name: "o",
+          startOffsetMs: 900,
+          durationMs: 5000,
+          isError: false,
+        },
+        1000,
+      );
+      expect(overflowing.leftPercent).toBe(90);
+      expect(overflowing.widthPercent).toBe(10);
+    });
+
+    test("the denominator never reaches zero", () => {
+      expect(
+        totalTraceDuration({
+          id: "W",
+          type: AIChatWidgetType.TraceWaterfall,
+          title: "t",
+          data: { totalDurationMs: 0 },
+        }),
+      ).toBe(1);
+    });
+  });
+
+  describe("toEntityListEntry", () => {
+    test("reads the exception fields, and 0 occurrences still shows a count", () => {
+      const entry: { heading: string; badges: Array<string> } =
+        toEntityListEntry(
+          { type: "TimeoutError", message: "boom", occurrences: 0 },
+          AIChatWidgetType.ExceptionList,
+        );
+
+      expect(entry.heading).toBe("TimeoutError");
+      expect(entry.badges).toContain("0×");
+    });
+
+    test("falls back to a generic exception heading", () => {
+      const entry: { heading: string } = toEntityListEntry(
+        { message: "boom" },
+        AIChatWidgetType.ExceptionList,
+      );
+      expect(entry.heading).toBe("Exception");
+    });
+
+    test("prefixes an incident with its number", () => {
+      const entry: { heading: string; badges: Array<string> } =
+        toEntityListEntry(
+          {
+            incidentNumber: 412,
+            title: "Down",
+            state: "Resolved",
+            severity: "Major",
+          },
+          AIChatWidgetType.IncidentList,
+        );
+
+      expect(entry.heading).toBe("#412 · Down");
+      expect(entry.badges).toEqual(["Resolved", "Major"]);
+    });
+
+    test("an alert reads its own number field", () => {
+      const entry: { heading: string } = toEntityListEntry(
+        { alertNumber: 9, incidentNumber: 1, title: "Alert" },
+        AIChatWidgetType.AlertList,
+      );
+      expect(entry.heading).toBe("#9 · Alert");
+    });
+  });
+
+  describe("toExportChartSeries", () => {
+    test("drops null and undefined y values", () => {
+      const series: Array<ExportChartSeries> = toExportChartSeries(
+        chartWidget({
+          series: [
+            {
+              name: "s",
+              points: [
+                { x: "2026-07-15T10:00:00Z", y: 1 },
+                { x: "2026-07-15T11:00:00Z", y: null },
+              ],
+            },
+          ],
+        }),
+      );
+
+      expect(series[0]?.points).toHaveLength(1);
+      expect(series[0]?.points[0]?.y).toBe(1);
+      expect(series[0]?.points[0]?.date).toBeInstanceOf(Date);
+    });
+
+    test("reports no data when every series is empty", () => {
+      expect(chartHasData(toExportChartSeries(chartWidget({})))).toBe(false);
+      expect(
+        chartHasData(
+          toExportChartSeries(
+            chartWidget({ series: [{ name: "s", points: [] }] }),
+          ),
+        ),
+      ).toBe(false);
+    });
+
+    test("a category x value is kept but not treated as a time", () => {
+      const series: Array<ExportChartSeries> = toExportChartSeries(
+        chartWidget({
+          series: [{ name: "s", points: [{ x: "ERROR", y: 2 }] }],
+        }),
+      );
+
+      expect(series[0]?.points[0]?.x).toBe("ERROR");
+      expect(series[0]?.points[0]?.date).toBeUndefined();
+      expect(chartIsTimeBased(series)).toBe(false);
+    });
+  });
+});

package/Tests/UI/Utils/AIChatExport/ChatWidgetMarkdown.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  AIChatToolActionStatus,
+  AIChatWidget,
+  AIChatWidgetType,
+} from "../../../../Types/AI/AIChatTypes";
+import { JSONObject } from "../../../../Types/JSON";
+import {
+  citationsToMarkdown,
+  toolActionsToMarkdown,
+  widgetToMarkdown,
+} from "../../../../UI/Utils/AIChatExport/ChatWidgetMarkdown";
+
+/*
+ * The chat caps how much of a widget it shows, and says so. An export that
+ * quietly dropped the overflow — or quietly included it — would misrepresent
+ * the answer either way, so the caps and their captions are pinned here.
+ */
+
+function rows(count: number): Array<JSONObject> {
+  return Array.from({ length: count }, (_unused: unknown, index: number) => {
+    return { name: `row-${index}` };
+  });
+}
+
+describe("ChatWidgetMarkdown", () => {
+  describe("widgetToMarkdown", () => {
+    test("renders the title and description", () => {
+      const markdown: string = widgetToMarkdown({
+        id: "W1",
+        type: AIChatWidgetType.StatCards,
+        title: "Summary",
+        description: "Last hour",
+        data: { stats: [{ label: "Errors", value: 3 }] },
+      });
+
+      expect(markdown).toContain("#### Summary");
+      expect(markdown).toContain("_Last hour_");
+      expect(markdown).toContain("| Errors | 3 |");
+    });
+
+    test("caps table rows at 25 and says how many were shown", () => {
+      const widget: AIChatWidget = {
+        id: "W1",
+        type: AIChatWidgetType.Table,
+        title: "Rows",
+        data: {
+          columns: [{ key: "name", title: "Name" }],
+          rows: rows(40),
+        },
+      };
+
+      const markdown: string = widgetToMarkdown(widget);
+
+      expect(markdown).toContain("row-24");
+      expect(markdown).not.toContain("row-25");
+      expect(markdown).toContain("_Showing 25 of 40 rows._");
+    });
+
+    test("caps entity lists at 12", () => {
+      const widget: AIChatWidget = {
+        id: "W1",
+        type: AIChatWidgetType.IncidentList,
+        title: "Incidents",
+        data: {
+          items: Array.from({ length: 20 }, (_u: unknown, i: number) => {
+            return { title: `incident-${i}` };
+          }),
+        },
+      };
+
+      const markdown: string = widgetToMarkdown(widget);
+
+      expect(markdown).toContain("incident-11");
+      expect(markdown).not.toContain("incident-12");
+      expect(markdown).toContain("_Showing 12 of 20._");
+    });
+
+    test("escapes a pipe so it cannot break the table", () => {
+      const markdown: string = widgetToMarkdown({
+        id: "W1",
+        type: AIChatWidgetType.Table,
+        title: "Rows",
+        data: {
+          columns: [{ key: "name", title: "Name" }],
+          rows: [{ name: "a|b" }],
+        },
+      });
+
+      expect(markdown).toContain("a\\|b");
+    });
+
+    test("empty widgets say so rather than rendering an empty table", () => {
+      expect(
+        widgetToMarkdown({
+          id: "W1",
+          type: AIChatWidgetType.Table,
+          title: "Rows",
+          data: { columns: [], rows: [] },
+        }),
+      ).toContain("_No rows._");
+
+      expect(
+        widgetToMarkdown({
+          id: "W2",
+          type: AIChatWidgetType.TimeSeriesChart,
+          title: "Chart",
+          data: { series: [] },
+        }),
+      ).toContain("_No data points in this range._");
+
+      expect(
+        widgetToMarkdown({
+          id: "W3",
+          type: AIChatWidgetType.IncidentList,
+          title: "Incidents",
+          data: { items: [] },
+        }),
+      ).toContain("_Nothing here._");
+    });
+  });
+
+  describe("toolActionsToMarkdown", () => {
+    test("leads with the status so a denied action cannot read as a done one", () => {
+      const markdown: string = toolActionsToMarkdown([
+        {
+          id: "t1",
+          toolName: "restart",
+          title: "Restart payment-svc",
+          arguments: { service: "payment-svc" },
+          isMutation: true,
+          requiresApproval: true,
+          status: AIChatToolActionStatus.Denied,
+        },
+      ]);
+
+      expect(markdown).toContain("- **Denied** — Restart payment-svc");
+      expect(markdown).toContain("service: payment-svc");
+    });
+
+    test("is empty when there are no actions", () => {
+      expect(toolActionsToMarkdown([])).toBe("");
+    });
+  });
+
+  describe("citationsToMarkdown", () => {
+    test("spells out a zero row count as evidence of absence", () => {
+      const markdown: string = citationsToMarkdown([
+        {
+          id: "C1",
+          toolName: "logs.query",
+          label: "Logs for payment-svc",
+          queryArguments: { service: "payment-svc" },
+          rowCount: 0,
+        },
+      ]);
+
+      expect(markdown).toContain("checked, found nothing");
+      expect(markdown).toContain('{"service":"payment-svc"}');
+    });
+
+    test("pluralizes a real row count", () => {
+      expect(
+        citationsToMarkdown([
+          {
+            id: "C1",
+            toolName: "t",
+            label: "l",
+            queryArguments: {},
+            rowCount: 1,
+          },
+        ]),
+      ).toContain("1 row");
+
+      expect(
+        citationsToMarkdown([
+          {
+            id: "C2",
+            toolName: "t",
+            label: "l",
+            queryArguments: {},
+            rowCount: 5,
+          },
+        ]),
+      ).toContain("5 rows");
+    });
+  });
+});

package/Tests/Utils/EnterpriseLicenseUsage.test.ts

@@ -163,3 +163,79 @@ describe("EnterpriseLicenseUsageUtil.getUniqueUserCount", () => {
     expect(EnterpriseLicenseUsageUtil.getUniqueUserCount([], now)).toBe(0);
   });
 });
+
+describe("EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails", () => {
+  it("returns empty array for non-array input", () => {
+    expect(EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails(null)).toEqual(
+      [],
+    );
+    expect(
+      EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails("admin@acme.com"),
+    ).toEqual([]);
+    expect(EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails({})).toEqual(
+      [],
+    );
+  });
+
+  it("keeps only email-shaped strings, normalizes case and trims", () => {
+    const result: Array<string> =
+      EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails([
+        " Admin@Acme.COM ",
+        "not-an-email",
+        "missing@tld",
+        "spaces in@acme.com",
+        12345,
+        null,
+        "second.admin@acme.com",
+      ]);
+
+    expect(result).toEqual(["admin@acme.com", "second.admin@acme.com"]);
+  });
+
+  it("removes duplicates", () => {
+    const result: Array<string> =
+      EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails([
+        "admin@acme.com",
+        "ADMIN@ACME.COM",
+        "admin@acme.com",
+      ]);
+
+    expect(result).toEqual(["admin@acme.com"]);
+  });
+
+  it("caps the list size", () => {
+    const tooMany: Array<string> = [];
+
+    for (
+      let i: number = 0;
+      i < EnterpriseLicenseUsageUtil.maxMasterAdminEmailsPerInstance + 10;
+      i++
+    ) {
+      tooMany.push(`admin${i}@acme.com`);
+    }
+
+    const result: Array<string> =
+      EnterpriseLicenseUsageUtil.sanitizeMasterAdminEmails(tooMany);
+
+    expect(result.length).toBe(
+      EnterpriseLicenseUsageUtil.maxMasterAdminEmailsPerInstance,
+    );
+  });
+});
+
+describe("EnterpriseLicenseUsageUtil.maskLicenseKey", () => {
+  it("fully masks short keys", () => {
+    expect(EnterpriseLicenseUsageUtil.maskLicenseKey("")).toBe("••••••••");
+    expect(EnterpriseLicenseUsageUtil.maskLicenseKey("abcd1234")).toBe(
+      "••••••••",
+    );
+  });
+
+  it("keeps only the first and last four characters of longer keys", () => {
+    expect(
+      EnterpriseLicenseUsageUtil.maskLicenseKey(
+        "abcd-1234-efgh-5678-ijkl-9012",
+      ),
+    ).toBe("abcd••••9012");
+  });
+});