@oneuptime/common 11.5.7 → 11.5.9

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

@@ -0,0 +1,167 @@
+import BasicForm from "../../../UI/Components/Forms/BasicForm";
+import Fields from "../../../UI/Components/Forms/Types/Fields";
+import FormFieldSchemaType from "../../../UI/Components/Forms/Types/FormFieldSchemaType";
+import FormValues from "../../../UI/Components/Forms/Types/FormValues";
+import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
+import ObjectID from "../../../Types/ObjectID";
+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 getJestMockFunction, { MockFunction } from "../../MockType";
+
+/*
+ * BasicForm's initial-values effect canonicalizes each Dropdown field's stored
+ * value onto the matching option. It used to finish with
+ *
+ *   values[fieldName] = dropdownOption?.value || null;
+ *
+ * which silently replaced any value that matched no option with null. That is
+ * data loss, not cosmetics: ModelForm submits every selected field, so an
+ * untouched field whose value was wiped here is PUT back as null and clears
+ * the column.
+ *
+ * Options legitimately fail to contain a valid stored value — a
+ * permission-scoped or truncated entity list, an options fetch that failed, or
+ * a free-text column holding a spelling the options don't list verbatim
+ * (NetworkDevice.snmpVersion stores either "V3" or the raw enum "3", and the
+ * SNMP form's showIf tolerates both via SnmpVersionUtil — but only if the
+ * value survives long enough to be read).
+ *
+ * These tests drive the real component and assert on the values it actually
+ * submits, because the normalization lives in a useEffect and re-implementing
+ * it in a test would pin nothing.
+ *
+ * Note: jest-dom matchers (toBeInTheDocument etc.) fail typecheck repo-wide,
+ * so assertions here stay on submitted values and plain DOM text.
+ */
+
+describe("BasicForm dropdown initial-value normalization", () => {
+  const OPTIONS: Array<DropdownOption> = [
+    { label: "V1", value: "V1" },
+    { label: "V2c", value: "V2c" },
+    { label: "V3", value: "V3" },
+  ];
+
+  type BuildFieldsFunction = (
+    options: Array<DropdownOption>,
+  ) => Fields<FormValues<any>>;
+
+  const buildFields: BuildFieldsFunction = (
+    options: Array<DropdownOption>,
+  ): Fields<FormValues<any>> => {
+    return [
+      {
+        field: { snmpVersion: true },
+        title: "SNMP Version",
+        fieldType: FormFieldSchemaType.Dropdown,
+        dropdownOptions: options,
+        required: false,
+      },
+    ];
+  };
+
+  type SubmitFormFunction = (
+    initialValues: FormValues<any>,
+    fields: Fields<FormValues<any>>,
+  ) => Promise<FormValues<any>>;
+
+  /*
+   * Renders the form, clicks Save, and hands back the values BasicForm
+   * submitted — i.e. what would be written to the database.
+   */
+  const submitForm: SubmitFormFunction = async (
+    initialValues: FormValues<any>,
+    fields: Fields<FormValues<any>>,
+  ): Promise<FormValues<any>> => {
+    const onSubmit: MockFunction = getJestMockFunction();
+
+    render(
+      <BasicForm
+        fields={fields}
+        id="dropdown-normalization"
+        initialValues={initialValues}
+        onSubmit={onSubmit}
+        submitButtonText="Save"
+      />,
+    );
+
+    await userEvent.setup().click(screen.getByTestId("Save"));
+
+    return onSubmit.mock.calls[0]?.[0] as FormValues<any>;
+  };
+
+  test("keeps a stored value that matches no option instead of nulling it", async () => {
+    /*
+     * The reported case: a device whose snmpVersion column holds the raw enum
+     * spelling "3" while the dropdown lists "V1"/"V2c"/"V3".
+     */
+    const submitted: FormValues<any> = await submitForm(
+      { snmpVersion: "3" } as FormValues<any>,
+      buildFields(OPTIONS),
+    );
+
+    expect(submitted).toEqual({ snmpVersion: "3" });
+  });
+
+  test("keeps stored values when the options failed to load", async () => {
+    /*
+     * ModelForm sets dropdownOptions to [] when an entity list comes back
+     * empty or its fetch throws. Nulling on no-match wiped every dropdown on
+     * such a form.
+     */
+    const submitted: FormValues<any> = await submitForm(
+      { snmpVersion: "V3" } as FormValues<any>,
+      buildFields([]),
+    );
+
+    expect(submitted).toEqual({ snmpVersion: "V3" });
+  });
+
+  test("still canonicalizes a value that does match an option", async () => {
+    const submitted: FormValues<any> = await submitForm(
+      { snmpVersion: "V3" } as FormValues<any>,
+      buildFields(OPTIONS),
+    );
+
+    expect(submitted).toEqual({ snmpVersion: "V3" });
+  });
+
+  test("converts a matching ObjectID initial value to its string form", async () => {
+    const id: ObjectID = new ObjectID("3f1b6b0e-0000-4000-8000-000000000001");
+
+    const submitted: FormValues<any> = await submitForm(
+      { snmpVersion: id } as unknown as FormValues<any>,
+      buildFields([{ label: "Probe A", value: id.toString() }]),
+    );
+
+    expect(submitted).toEqual({ snmpVersion: id.toString() });
+  });
+
+  test("preserves an unmatched ObjectID as a string, not as an ObjectID", async () => {
+    /*
+     * An entity dropdown whose referenced row is missing from the (possibly
+     * permission-scoped) option list must still submit the canonical string
+     * the API expects — preserving the raw ObjectID instance would send an
+     * object.
+     */
+    const id: ObjectID = new ObjectID("3f1b6b0e-0000-4000-8000-000000000002");
+
+    const submitted: FormValues<any> = await submitForm(
+      { snmpVersion: id } as unknown as FormValues<any>,
+      buildFields([{ label: "Someone else", value: "a-different-id" }]),
+    );
+
+    expect(submitted).toEqual({ snmpVersion: id.toString() });
+    expect(typeof submitted["snmpVersion"]).toBe("string");
+  });
+
+  test("leaves an absent value alone", async () => {
+    const submitted: FormValues<any> = await submitForm(
+      {} as FormValues<any>,
+      buildFields(OPTIONS),
+    );
+
+    expect(submitted["snmpVersion"]).toBeUndefined();
+  });
+});

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/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);
+    });
+  });
+});